Add hold-shift-to-pause for autoscroll

Hold either Shift key to pause auto-scrolling, letting the user
read at their own pace. Releasing Shift resumes from current position.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.bazelrc

@@ -29,6 +29,9 @@ common --javacopt="-Xlint:-options"
 common --linkopt=-Wl
 common:macos --linkopt=-Wl,-no_warn_duplicate_libraries
 
+# Fix Xcode version caching issue - avoids need for `bazel clean --expunge` after Xcode updates
+common:macos --repo_env=DEVELOPER_DIR=/Applications/Xcode.app/Contents/Developer
+
 common --java_language_version=17
 common --java_runtime_version=remotejdk_17
 common --tool_java_language_version=17

.gitignore

@@ -37,3 +37,4 @@ scripts/refresh_name_layers/refresh_name_layers.zip
 .metals
 api_keys.txt
 
+src/main/csharp/net/eagle0/clients/unity/eagle0/ProjectSettings/Packages/com.unity.dedicated-server/

.pre-commit-config.yaml

@@ -32,8 +32,9 @@ repos:
       - id: gazelle
         name: gazelle
         language: system
-        entry: bazel run //:gazelle
+        entry: ./scripts/pre-commit-gazelle.sh
         files: '(\.go|\.proto|BUILD\.bazel|BUILD|WORKSPACE|WORKSPACE\.bazel|\.bzl)$'
+        pass_filenames: false
 -   repo: local
     hooks:
     -   id: update-action-result-types

CLAUDE.md

@@ -85,6 +85,16 @@ bazel run gazelle              # Update Go build files
 ./scripts/updateActionResultTypes.sh   # Update protocol buffer mappings
 ```
 
+### Pre-Commit Checklist
+
+**MANDATORY: Before running `git commit`, verify:**
+
+1. **If you modified any BUILD.bazel file:** Run `bazel run gazelle` and stage any changes it makes
+2. **If you modified C++ or C# files:** Run `clang-format -i` on the modified files
+3. **If you modified Scala files:** scalafmt will run automatically via pre-commit hook
+
+The pre-commit hook runs gazelle but only checks if it succeeds - it does NOT verify the BUILD files are in canonical format. The `gazelle_test` will fail if deps are not alphabetically sorted. **Always run gazelle manually after BUILD file changes.**
+
 ### Code Formatting
 
 ```bash
@@ -206,6 +216,31 @@ to be used for different players or game situations within the same server proce
 - Map validation tests ensure game content integrity
 - Use `GameSettings_test_utils.cpp` and `ShardokEngineBasedTestData.cpp` for C++ test helpers
 
+### Scala Testing Patterns
+
+**Use `inside()` instead of `asInstanceOf` for type matching in tests:**
+
+Never use `asInstanceOf` in tests. Instead, use ScalaTest's `inside()` pattern for safe type matching:
+
+```scala
+// BAD - don't do this
+val changedHero = result.changedHeroes.head.asInstanceOf[ChangedHeroC]
+changedHero.heroId shouldBe 19
+
+// GOOD - use inside() pattern
+import org.scalatest.Inside.inside
+
+inside(result.changedHeroes.head) { case changedHero: ChangedHeroC =>
+  changedHero.heroId shouldBe 19
+  changedHero.vigorChange shouldBe StatDelta(17.2)
+}
+```
+
+The `inside()` pattern:
+- Provides better error messages when the type doesn't match
+- Is idiomatic ScalaTest
+- Works with pattern matching for more complex assertions
+
 ## Performance Testing
 
 When making performance-related changes to the AI or engine:
@@ -244,6 +279,32 @@ done
 - **Always test performance changes** - what seems like an optimization may sometimes have unexpected overhead or
   behavior changes.
 
+## Troubleshooting Scala Build Errors
+
+### MissingType Errors
+
+When you see errors like:
+```
+dotty.tools.dotc.core.MissingType: Cannot resolve reference to type net.eagle0.eagle.internal.game_state.type.GameState
+```
+
+**This is NOT a Scala compiler crash.** This is a missing dependency in BUILD.bazel.
+
+**How to fix:**
+1. Identify the missing type from the error message (e.g., `game_state.GameState`)
+2. Find the Bazel target that provides this type (e.g., `//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto`)
+3. Add it to the `deps` of the failing target
+4. If the type appears in a public method signature, also add it to `exports` so downstream targets can see it
+
+**Common pattern:** When adding a method to a class that takes or returns a proto type, the proto dependency often needs to be added to both `deps` AND `exports`.
+
+### Bazel Clean
+
+**NEVER run `bazel clean` without asking first.** It rarely fixes actual issues and wastes significant rebuild time. The issues that seem like they need `bazel clean` are usually:
+- Missing imports in Scala code
+- Missing dependencies in BUILD.bazel
+- Missing exports for types used in public signatures
+
 ## Game Content
 
 **Maps:** `.e0mj` files in `/src/main/resources/net/eagle0/shardok/maps/`

MODULE.bazel

@@ -76,6 +76,7 @@ use_repo(
     "com_github_aws_aws_sdk_go_v2_config",
     "com_github_aws_aws_sdk_go_v2_credentials",
     "com_github_aws_aws_sdk_go_v2_service_s3",
+    "org_golang_google_grpc",
     "org_golang_google_protobuf",
 )
 
@@ -160,6 +161,10 @@ maven.install(
         # Other
         "org.reactivestreams:reactive-streams:1.0.4",
         "javax.xml.bind:jaxb-api:2.3.1",
+
+        # OkHttp (for SSE with read timeout support)
+        "com.squareup.okhttp3:okhttp:4.12.0",
+        "com.squareup.okhttp3:okhttp-sse:4.12.0",
     ],
     duplicate_version_warning = "error",
     fail_if_repin_required = True,

ci/unity_version.sh

@@ -1,2 +1 @@
-
-UNITY_VERSION='6000.2.7f2'
+UNITY_VERSION='6000.3.0f1'

docs/DEPROTO_PLAN.md

@@ -0,0 +1,309 @@
+# Deproto Migration Plan
+
+## Vision
+
+**Protocol buffers should only be used at the edges** — for network serialization (gRPC) and disk persistence. Inside the Eagle game engine, all logic should operate on native Scala models.
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                         GRPC BOUNDARY                               │
+│  EagleServiceImpl.scala  ←→  Proto Messages  ←→  Unity Client       │
+└─────────────────────────────────────────────────────────────────────┘
+                                   ↓
+                          GameStateConverter
+                                   ↓
+┌─────────────────────────────────────────────────────────────────────┐
+│                         SCALA ENGINE                                │
+│                                                                     │
+│   GameStateC ───→ Actions ───→ ActionResultT ───→ New GameStateC   │
+│       ↑                                                   │        │
+│       │               (Pure Scala models)                 │        │
+│       └───────────────────────────────────────────────────┘        │
+│                                                                     │
+│   HeroC, FactionC, ProvinceC, BattalionC, ArmyC, etc.              │
+└─────────────────────────────────────────────────────────────────────┘
+                                   ↓
+                          GameStateConverter
+                                   ↓
+┌─────────────────────────────────────────────────────────────────────┐
+│                      PERSISTENCE BOUNDARY                           │
+│  GameHistory.scala  ←→  Proto Messages  ←→  File/Database          │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Current State
+
+### Completed Phases
+
+| Phase | Status | Summary |
+|-------|--------|---------|
+| Phase 1: GameStateC | **Complete** | Scala `GameState` model with 22 fields |
+| Phase 2: EngineImpl | **Complete** | Holds Scala `GameState` internally |
+| Phase 3: GameHistory | **Complete** | `stateAfter` returns Scala GameState |
+| Phase 4: ActionResultT | **Complete** | All 59 actions return `ActionResultT` |
+| Phase 5: Action Base Classes | **Complete** | All `RandomSequentialResultsAction` and `DeterministicSingleResultAction` converted to T-type base classes |
+| Phase 5b: Base Class Cleanup | **Complete** | `RandomSequentialResultsAction` and `DeterministicSingleResultAction` deleted |
+| Phase 5c: RoundPhaseAdvancer Actions | **Complete** | All actions called by RoundPhaseAdvancer accept Scala GameState |
+| Phase 5d: RoundPhaseAdvancer Itself | **Complete** | RoundPhaseAdvancer.checkForPhaseAdvancement takes Scala GameState |
+
+### Phase 5c/5d Progress (Complete)
+
+`RoundPhaseAdvancer.checkForPhaseAdvancement` now accepts Scala `GameState` and `ActionResultApplier` directly (PR #4677).
+
+| Action | PR | Status |
+|--------|-----|--------|
+| `PrisonerExchangeAction` | #4670 | ✅ Merged |
+| `PerformForcedTurnBackAction` | #4671 | ✅ Merged |
+| `PerformHeroDeparturesAction` | #4672 | ✅ Merged |
+| `RequestFreeForAllBattlesAction` | #4673 | ✅ Merged |
+| `EndPlayerCommandsPhaseAction` | #4674 | ✅ Merged |
+| `EndDiplomacyResolutionPhaseAction` | #4675 | ✅ Merged |
+| `RoundPhaseAdvancer` itself | #4677 | ✅ Merged |
+
+### EngineImpl Progress
+
+| Change | PR | Status |
+|--------|-----|--------|
+| `recursiveTransform` deleted | #4677 | ✅ Merged |
+| `recursiveTransformT` uses `RandomStateTSequencer` | #4677 | ✅ Merged |
+
+### Current Architecture
+
+**ActionResultT Production (100% Complete):**
+- All actions produce `ActionResultT`
+- Conversion to `ActionResultProto` happens via `ActionResultProtoConverter.toProto()`
+- No direct `ActionResultProto` construction outside the converter
+
+**ActionResultProto Consumption (Next Target):**
+- `ActionResultProtoApplierImpl` - applies proto results to proto GameState
+- `RoundPhaseAdvancer` - calls converter, passes protos to applier
+- `InMemoryHistory` / `PersistedHistory` - stores proto results
+- Service layer (`GameController`, `GamesManager`, etc.) - uses proto for client communication
+
+---
+
+## Phase 6: Migrate to ActionResultT Consumers
+
+### Objective
+
+Eliminate internal consumption of `ActionResultProto`. Everything inside the engine should work with `ActionResultT`.
+
+### Current Flow (Proto-Heavy)
+```
+Action.execute()
+    → ActionResultT
+    → ActionResultProtoConverter.toProto()
+    → ActionResultProto
+    → ActionResultProtoApplierImpl.applyActionResults()
+    → GameStateProto
+    → GameStateConverter.fromProto()
+    → GameStateC
+```
+
+### Target Flow (T-Types Throughout)
+```
+Action.execute()
+    → ActionResultT
+    → ActionResultApplier.applyActionResults()
+    → GameStateC
+
+    (Proto conversion only at boundaries)
+```
+
+### Key Files to Convert
+
+**Tier 1 - Core Applier:** ✅ **Complete**
+```
+src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplierImpl.scala
+```
+`ActionResultApplier` applies `ActionResultT` directly to Scala `GameState`. The legacy `ActionResultTApplierImpl` wraps it and converts to/from proto for callers that still need proto types.
+
+**Tier 2 - RoundPhaseAdvancer:** ✅ **Complete**
+```
+src/main/scala/net/eagle0/eagle/library/RoundPhaseAdvancer.scala
+```
+Now accepts Scala `GameState` and `ActionResultApplier`. Only converts to proto lazily for `AvailableCommandsFactory` calls.
+
+**Tier 3 - Sequencers:**
+```
+src/main/scala/net/eagle0/eagle/library/actions/impl/common/RandomStateTSequencer.scala
+src/main/scala/net/eagle0/eagle/library/actions/impl/common/RandomStateProtoSequencer.scala
+```
+Modify `RandomStateTSequencer` to thread Scala `GameState` throughout (currently converts to proto internally). Then evaluate whether `RandomStateProtoSequencer` is still needed at all.
+
+**Current State**: `RandomStateTSequencer` accepts Scala `GameState` via its `apply()` method but internally converts to proto. All callback methods (`withRandomActionResult`, `withActionResults`, etc.) pass `GameStateProto` to callers, forcing actions that use the sequencer to work with proto types internally.
+
+**Target State**: Create a fully protoless sequencer where:
+1. `lastState` returns Scala `GameState` (not `lastStateProto`)
+2. All callback methods pass Scala `GameState` to callers
+3. Actions using the sequencer can be fully protoless
+
+**Migration Path**:
+1. Add `lastState: GameState` method alongside `lastStateProto` (non-breaking)
+2. Add parallel callback methods that pass Scala GameState (e.g., `withScalaActionResult`)
+3. Migrate actions one by one to use the new Scala-based callbacks
+4. Once all actions migrated, deprecate/remove proto-based callbacks
+5. Remove `lastStateProto` once no longer used
+
+**RandomStateSequencer Migration Progress** (PR #4679 introduced protoless `RandomStateSequencer`):
+
+| Action | Status |
+|--------|--------|
+| `TruceTurnBackPhaseAction` | ✅ Migrated (PR #4680) |
+| `EndHandleRiotsPhaseAction` | ✅ Migrated (PR #4684) |
+| `PerformVassalCommandsPhaseAction` | ✅ Migrated |
+| `PerformVassalDefenseDecisionsAction` | ✅ Migrated |
+| `EndVassalCommandsPhaseAction` | ✅ Migrated |
+| `PerformReconResolutionAction` | ✅ Migrated |
+| `NewRoundAction` | ✅ Migrated (PR #4698) |
+| `EndBattleAftermathPhaseAction` | ✅ Migrated (PR #4699) |
+| `EndDiplomacyResolutionPhaseAction` | ✅ Migrated |
+| `PerformUnaffiliatedHeroesAction` | ✅ Migrated |
+| `EngineImpl.recursiveTransformT` | ✅ Migrated (PR #4704) |
+| `ProtolessSequentialResultsActionWrapper` | ✅ Migrated (PR #4705) |
+| `LegacyRandomStateTSequencer` | ✅ **Deleted** (PR #4705) |
+
+**TCommandFactory Extraction** (PR #4684):
+
+To enable lightweight mocking of command creation in tests, `TCommandFactory` trait was extracted from `CommandFactory`. This allows tests to mock just the `makeTCommand` method without pulling in all 40+ command dependencies that `CommandFactory` requires.
+
+- `TCommandFactory` - lightweight trait with just `makeTCommand`
+- `CommandFactory extends TCommandFactory` - maintains backward compatibility
+- Actions accepting command factories now use `TCommandFactory` type for better testability
+
+**Tier 4 - History APIs:**
+```
+src/main/scala/net/eagle0/eagle/service/InMemoryHistory.scala
+src/main/scala/net/eagle0/eagle/service/PersistedHistory.scala
+```
+Change APIs to vend Scala `GameState` and `ActionResultT` instead of proto versions. `PersistedHistory` converts to proto internally for disk persistence; `InMemoryHistory` doesn't need proto at all.
+
+### ActionResultProto Consumer Inventory
+
+| File | Usage | Status |
+|------|-------|--------|
+| `ActionResultApplierImpl.scala` | Applies ActionResultT to Scala GameState | ✅ **Complete** |
+| `ActionResultTApplierImpl.scala` | Legacy wrapper - converts to/from proto | Keep until all callers migrated |
+| `RoundPhaseAdvancer.scala` | Uses Scala GameState | ✅ **Complete** |
+| `RandomStateSequencer.scala` | Threads Scala GameState | ✅ **Complete** |
+| `VigorXPApplier.scala` | Has both proto and Scala methods | Scala method exists, delete proto method when unused |
+| `PerformForcedTurnBackAction.scala` | Fully protoless | ✅ **Complete** |
+| `ResolveBattleAction.scala` | Heavy proto usage | Blocked by proto dependencies |
+| `InMemoryHistory.scala` | Stores proto results | Pending - vend Scala types |
+| `PersistedHistory.scala` | Stores proto results | Pending - vend Scala types, convert for disk |
+| `GameController.scala` | Uses proto for client communication | Keep proto (gRPC boundary) |
+
+### Remaining Proto Usage in Actions
+
+The following actions still have proto usage, blocked by utility dependencies:
+
+| Action | Proto Usage | Blocker |
+|--------|-------------|---------|
+| `EndBattleAftermathPhaseAction` | 1 `toProto` call | `ProvinceViewFilter` needs Scala types |
+| `NewRoundAction` | 1 `fromProto` call | `ChronicleEventGenerator` returns proto |
+| `EndHandleRiotsPhaseAction` | 1 `toProto` call | `CommandChoiceHelpers` takes proto GameState |
+| `PerformVassalCommandsPhaseAction` | 1 `toProto` call | `CommandChoiceHelpers` takes proto GameState |
+| `PerformVassalDefenseDecisionsAction` | 1 `toProto` call | `CommandChoiceHelpers` takes proto GameState |
+| `EndVassalCommandsPhaseAction` | 1 `toProto` call | `CommandChoiceHelpers` takes proto GameState |
+| `PerformReconResolutionAction` | Uses `ProvinceViewFilter` | `ProvinceViewFilter` needs Scala types |
+| `ResolveBattleAction` | Heavy proto usage | Large refactor needed |
+
+### Estimated Effort (Remaining)
+
+| Component | Lines | Complexity |
+|-----------|-------|------------|
+| `ProvinceViewFilter` to Scala | ~150 | Medium |
+| `CommandChoiceHelpers` to Scala | ~2000 | High |
+| `ChronicleEventGenerator` to Scala | ~400 | Medium |
+| History API updates | ~100 | Low |
+| **Total Remaining** | **~2650** | |
+
+### Validation
+- [x] `ActionResultApplier` created and tested
+- [x] `RandomStateSequencer` threads Scala GameState throughout
+- [x] `RoundPhaseAdvancer` uses T-types internally
+- [ ] `ProvinceViewFilter` uses Scala types
+- [ ] `CommandChoiceHelpers` uses Scala types
+- [ ] History APIs vend Scala types
+- [ ] No `ActionResultProtoConverter.toProto()` calls except at persistence/gRPC boundaries
+- [ ] All tests pass
+
+---
+
+## Phase 7: Clean Up Legacy Utilities
+
+### Objective
+Remove remaining direct proto imports from utility classes.
+
+### Files to Modify
+
+| File | Status |
+|------|--------|
+| `CommandChoiceHelpers.scala` | Accepts proto `GameState`; blocks full deproto of `PerformVassalCommandsPhaseAction` and `PerformVassalDefenseDecisionsAction` |
+| `LegacyProvinceUtils.scala` | Replace with `ProvinceUtils.scala` - `hasImminentRiot` added (PR #4683) |
+| `LegacyFactionUtils.scala` | Replace proto imports with `FactionT` |
+| `LegacyUnaffiliatedHeroUtils.scala` | Replace proto imports with Scala models |
+| `BattalionTypeLoader.scala` | Keep proto for file loading, convert immediately after |
+| `BeastUtils.scala` | **Complete** - now uses Scala `BeastInfo` only |
+
+### View Filters (Blocking Full Deproto)
+
+The `ProvinceViewFilter` utility currently works entirely with proto types, blocking full deproto of actions that generate province views:
+
+| File | Issue | Needed |
+|------|-------|--------|
+| `ProvinceViewFilter.scala` | Takes proto `Province`/`GameState`, returns proto `ProvinceView` | Scala `ProvinceViewT` model |
+| `GameStateViewFilter.scala` | Uses proto types throughout | Depends on `ProvinceViewT` |
+| `GameStateViewDiffer.scala` | Works with view protos | Depends on `ProvinceViewT` |
+
+**Blocked Actions**:
+- `EndBattleAftermathPhaseAction` - uses `ProvinceViewFilter` for `revelationChange`, requires lazy proto conversion
+- `PerformReconResolutionAction` - uses `ProvinceViewFilter` for reconned provinces
+- `GameStateFactionExtensions` - uses `ProvinceViewFilter` for `updatedReconnedProvinces`
+
+**Solution**: Create Scala `ProvinceViewT` (and possibly `ProvinceViewC`) that mirrors the proto `ProvinceView`. Then create a protoless `ProvinceViewFilter` that operates on Scala types. The proto version can delegate to the Scala version + convert, or we maintain both during transition.
+
+---
+
+## Phase 8: Verify Boundaries
+
+### Objective
+Confirm protos are used correctly at boundaries — and ONLY there.
+
+### Expected Proto Usage (Keep)
+- `EagleServiceImpl.scala` - gRPC boundary
+- `InMemoryHistory.scala` / `PersistedHistory.scala` - Persistence boundary
+- `*Converter.scala` - Explicit conversion utilities
+- `*Loader.scala` - File loading utilities
+
+### Expected No Proto Usage (Verify)
+- `/library/actions/impl/` - Pure Scala models
+- `/library/util/` - Pure Scala models (except loaders)
+- `/model/state/` - Pure Scala models
+
+---
+
+## Open Questions
+
+1. **Persistence Format**: Currently game state is persisted as proto. Should we keep proto for persistence (good for schema evolution) or switch to a different format?
+
+2. **Shardok Integration**: `ResolveBattleAction` communicates with Shardok. Should the Shardok interface use protos (external service) or Scala models?
+
+3. **View Generation**: `GameStateViewDiffer` works with view protos for client updates. Views need Scala models (`ProvinceViewT`, etc.) to allow actions like `EndBattleAftermathPhaseAction` to be fully protoless. The Scala views would be converted to proto only at the gRPC boundary when sending updates to clients.
+
+---
+
+## Success Criteria
+
+### Code Quality
+- [ ] Zero proto imports in `/library/actions/` (except boundaries)
+- [ ] Zero proto imports in `/library/` utilities (except loaders)
+- [ ] `GameStateT` used throughout engine internals
+- [ ] Proto usage limited to: `EagleServiceImpl`, loaders, converters, persistence
+
+### Architecture
+- [ ] Clear separation: Scala models (internal) vs Proto (boundaries)
+- [ ] Converters as the only bridge between domains
+- [ ] No "proto creep" into business logic

go.mod

@@ -9,6 +9,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/config v1.28.10
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.51
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.72.2
+	google.golang.org/grpc v1.68.0
 	google.golang.org/protobuf v1.36.3
 )
 

go.sum

@@ -40,6 +40,8 @@ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/
 golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
 golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
 golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0=
+google.golang.org/grpc v1.68.0/go.mod h1:fmSPC5AsjSBCK54MyHRx48kpOti1/jRfOlwEWywNjWA=
 google.golang.org/protobuf v1.26.0-rc.1 h1:7QnIQpGRHE5RnLKnESfDoxm2dTapTZua5a0kS0A+VXQ=
 google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
 google.golang.org/protobuf v1.36.3 h1:82DV7MYdb8anAVi3qge1wSnMDrnKK7ebr+I0hHRN1BU=

maven_install.json

@@ -1,9 +1,10 @@
 {
   "__AUTOGENERATED_FILE_DO_NOT_MODIFY_THIS_FILE_MANUALLY": "THERE_IS_NO_DATA_ONLY_ZUUL",
-  "__INPUT_ARTIFACTS_HASH": 571423113,
-  "__RESOLVED_ARTIFACTS_HASH": 438039003,
+  "__INPUT_ARTIFACTS_HASH": 289080209,
+  "__RESOLVED_ARTIFACTS_HASH": -131178107,
   "conflict_resolution": {
     "com.google.guava:failureaccess:1.0.1": "com.google.guava:failureaccess:1.0.2",
+    "com.squareup.okio:okio:2.10.0": "com.squareup.okio:okio:3.6.0",
     "io.netty:netty-buffer:4.1.110.Final": "io.netty:netty-buffer:4.1.112.Final",
     "io.netty:netty-codec-http2:4.1.110.Final": "io.netty:netty-codec-http2:4.1.112.Final",
     "io.netty:netty-codec-http:4.1.110.Final": "io.netty:netty-codec-http:4.1.112.Final",
@@ -155,6 +156,18 @@
       },
       "version": "1.4.2"
     },
+    "com.squareup.okhttp3:okhttp": {
+      "shasums": {
+        "jar": "b1050081b14bb7a3a7e55a4d3ef01b5dcfabc453b4573a4fc019767191d5f4e0"
+      },
+      "version": "4.12.0"
+    },
+    "com.squareup.okhttp3:okhttp-sse": {
+      "shasums": {
+        "jar": "bff4fbcaef7aac2d910d4ff46dafaa4e6d15da127df6bac97216da46943a7d4c"
+      },
+      "version": "4.12.0"
+    },
     "com.squareup.okhttp:okhttp": {
       "shasums": {
         "jar": "88ac9fd1bb51f82bcc664cc1eb9c225c90dc4389d660231b4cc737bebfe7d0aa"
@@ -163,9 +176,15 @@
     },
     "com.squareup.okio:okio": {
       "shasums": {
-        "jar": "a27f091d34aa452e37227e2cfa85809f29012a8ef2501a9b5a125a978e4fcbc1"
+        "jar": "8e63292e5c53bb93c4a6b0c213e79f15990fed250c1340f1c343880e1c9c39b5"
       },
-      "version": "2.10.0"
+      "version": "3.6.0"
+    },
+    "com.squareup.okio:okio-jvm": {
+      "shasums": {
+        "jar": "67543f0736fc422ae927ed0e504b98bc5e269fda0d3500579337cb713da28412"
+      },
+      "version": "3.6.0"
     },
     "com.thesamet.scalapb:compilerplugin_3": {
       "shasums": {
@@ -444,15 +463,27 @@
     },
     "org.jetbrains.kotlin:kotlin-stdlib": {
       "shasums": {
-        "jar": "b8ab1da5cdc89cb084d41e1f28f20a42bd431538642a5741c52bbfae3fa3e656"
+        "jar": "55e989c512b80907799f854309f3bc7782c5b3d13932442d0379d5c472711504"
       },
-      "version": "1.4.20"
+      "version": "1.9.10"
     },
     "org.jetbrains.kotlin:kotlin-stdlib-common": {
       "shasums": {
-        "jar": "a7112c9b3cefee418286c9c9372f7af992bd1e6e030691d52f60cb36dbec8320"
+        "jar": "cde3341ba18a2ba262b0b7cf6c55b20c90e8d434e42c9a13e6a3f770db965a88"
       },
-      "version": "1.4.20"
+      "version": "1.9.10"
+    },
+    "org.jetbrains.kotlin:kotlin-stdlib-jdk7": {
+      "shasums": {
+        "jar": "ac6361bf9ad1ed382c2103d9712c47cdec166232b4903ed596e8876b0681c9b7"
+      },
+      "version": "1.9.10"
+    },
+    "org.jetbrains.kotlin:kotlin-stdlib-jdk8": {
+      "shasums": {
+        "jar": "a4c74d94d64ce1abe53760fe0389dd941f6fc558d0dab35e47c085a11ec80f28"
+      },
+      "version": "1.9.10"
     },
     "org.jetbrains:annotations": {
       "shasums": {
@@ -779,12 +810,23 @@
       "org.checkerframework:checker-qual",
       "org.ow2.asm:asm"
     ],
+    "com.squareup.okhttp3:okhttp": [
+      "com.squareup.okio:okio",
+      "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    ],
+    "com.squareup.okhttp3:okhttp-sse": [
+      "com.squareup.okhttp3:okhttp",
+      "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+    ],
     "com.squareup.okhttp:okhttp": [
       "com.squareup.okio:okio"
     ],
     "com.squareup.okio:okio": [
-      "org.jetbrains.kotlin:kotlin-stdlib",
-      "org.jetbrains.kotlin:kotlin-stdlib-common"
+      "com.squareup.okio:okio-jvm"
+    ],
+    "com.squareup.okio:okio-jvm": [
+      "org.jetbrains.kotlin:kotlin-stdlib-common",
+      "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
     ],
     "com.thesamet.scalapb:compilerplugin_3": [
       "com.google.protobuf:protobuf-java",
@@ -992,6 +1034,13 @@
       "org.jetbrains.kotlin:kotlin-stdlib-common",
       "org.jetbrains:annotations"
     ],
+    "org.jetbrains.kotlin:kotlin-stdlib-jdk7": [
+      "org.jetbrains.kotlin:kotlin-stdlib"
+    ],
+    "org.jetbrains.kotlin:kotlin-stdlib-jdk8": [
+      "org.jetbrains.kotlin:kotlin-stdlib",
+      "org.jetbrains.kotlin:kotlin-stdlib-jdk7"
+    ],
     "org.json4s:json4s-ast_3": [
       "org.scala-lang:scala3-library_3"
     ],
@@ -1451,6 +1500,29 @@
     "com.google.truth:truth": [
       "com.google.common.truth"
     ],
+    "com.squareup.okhttp3:okhttp": [
+      "okhttp3",
+      "okhttp3.internal",
+      "okhttp3.internal.authenticator",
+      "okhttp3.internal.cache",
+      "okhttp3.internal.cache2",
+      "okhttp3.internal.concurrent",
+      "okhttp3.internal.connection",
+      "okhttp3.internal.http",
+      "okhttp3.internal.http1",
+      "okhttp3.internal.http2",
+      "okhttp3.internal.io",
+      "okhttp3.internal.platform",
+      "okhttp3.internal.platform.android",
+      "okhttp3.internal.proxy",
+      "okhttp3.internal.publicsuffix",
+      "okhttp3.internal.tls",
+      "okhttp3.internal.ws"
+    ],
+    "com.squareup.okhttp3:okhttp-sse": [
+      "okhttp3.internal.sse",
+      "okhttp3.sse"
+    ],
     "com.squareup.okhttp:okhttp": [
       "com.squareup.okhttp",
       "com.squareup.okhttp.internal",
@@ -1459,7 +1531,7 @@
       "com.squareup.okhttp.internal.io",
       "com.squareup.okhttp.internal.tls"
     ],
-    "com.squareup.okio:okio": [
+    "com.squareup.okio:okio-jvm": [
       "okio",
       "okio.internal"
     ],
@@ -1814,6 +1886,7 @@
       "kotlin.annotation",
       "kotlin.collections",
       "kotlin.collections.builders",
+      "kotlin.collections.jdk8",
       "kotlin.collections.unsigned",
       "kotlin.comparisons",
       "kotlin.concurrent",
@@ -1822,24 +1895,36 @@
       "kotlin.coroutines.cancellation",
       "kotlin.coroutines.intrinsics",
       "kotlin.coroutines.jvm.internal",
+      "kotlin.enums",
       "kotlin.experimental",
       "kotlin.internal",
+      "kotlin.internal.jdk7",
+      "kotlin.internal.jdk8",
       "kotlin.io",
+      "kotlin.io.encoding",
+      "kotlin.io.path",
+      "kotlin.jdk7",
       "kotlin.js",
       "kotlin.jvm",
       "kotlin.jvm.functions",
       "kotlin.jvm.internal",
       "kotlin.jvm.internal.markers",
       "kotlin.jvm.internal.unsafe",
+      "kotlin.jvm.jdk8",
+      "kotlin.jvm.optionals",
       "kotlin.math",
       "kotlin.properties",
       "kotlin.random",
+      "kotlin.random.jdk8",
       "kotlin.ranges",
       "kotlin.reflect",
       "kotlin.sequences",
+      "kotlin.streams.jdk8",
       "kotlin.system",
       "kotlin.text",
-      "kotlin.time"
+      "kotlin.text.jdk8",
+      "kotlin.time",
+      "kotlin.time.jdk8"
     ],
     "org.jetbrains:annotations": [
       "org.intellij.lang.annotations",
@@ -2270,8 +2355,11 @@
       "com.google.protobuf:protobuf-java",
       "com.google.re2j:re2j",
       "com.google.truth:truth",
+      "com.squareup.okhttp3:okhttp",
+      "com.squareup.okhttp3:okhttp-sse",
       "com.squareup.okhttp:okhttp",
       "com.squareup.okio:okio",
+      "com.squareup.okio:okio-jvm",
       "com.thesamet.scalapb:compilerplugin_3",
       "com.thesamet.scalapb:lenses_3",
       "com.thesamet.scalapb:protoc-bridge_2.13",
@@ -2324,6 +2412,8 @@
       "org.hamcrest:hamcrest-core",
       "org.jetbrains.kotlin:kotlin-stdlib",
       "org.jetbrains.kotlin:kotlin-stdlib-common",
+      "org.jetbrains.kotlin:kotlin-stdlib-jdk7",
+      "org.jetbrains.kotlin:kotlin-stdlib-jdk8",
       "org.jetbrains:annotations",
       "org.json4s:json4s-ast_3",
       "org.json4s:json4s-core_3",

scripts/build_mac_plugin.sh

@@ -3,7 +3,8 @@
 set -euxo pipefail
 
 /bin/echo "building darwin bundle"
-bazel build --noincompatible_enable_cc_toolchain_resolution @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
-/usr/bin/unzip -o bazel-bin/external/net_eagle0_unity_godice/darwin/framework/DarwinGodiceBundle.zip -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
+bazel build --config=mactools @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
+ZIP_LOCATION=$(bazel cquery --config=mactools --output=files @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle 2>/dev/null)
+/usr/bin/unzip -o $ZIP_LOCATION -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
 
 /usr/bin/plutil -convert xml1 src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/DarwinGodiceBundle.bundle/Contents/Info.plist

scripts/build_plugins.sh

@@ -5,8 +5,9 @@ set -euxo pipefail
 /bin/echo "build plugins"
 
 /bin/echo "building darwin bundle"
-bazel build --noincompatible_enable_cc_toolchain_resolution @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
-/usr/bin/unzip -o bazel-bin/external/net_eagle0_unity_godice/darwin/framework/DarwinGodiceBundle.zip -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
+bazel build --config=mactools @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle
+ZIP_LOCATION=$(bazel cquery --config=mactools --output=files @net_eagle0_unity_godice//darwin/framework:DarwinGodiceBundle 2>/dev/null)
+/usr/bin/unzip -o $ZIP_LOCATION -d src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/
 
 /usr/bin/plutil -convert xml1 src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Plugins/DarwinGodiceBundle.bundle/Contents/Info.plist
 

scripts/dlSettings.sh

@@ -1,8 +1,10 @@
 #!/usr/bin/env bash
 
-curl -L "https://docs.google.com/spreadsheets/d/1pv-WMXReccddPwev_YG9IXEGznuGHrYjNNEZ0Rb-ZhM/export?gid=0&format=tsv" > src/main/resources/net/eagle0/shardok/settings.tsv
-curl -L "https://docs.google.com/spreadsheets/d/1p6I5nUMcoAPHIcqikVgbBCFVnqN9dpOEVClbS_wOI7M/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/settings.tsv
+curl -L "https://docs.google.com/spreadsheets/d/1pv-WMXReccddPwev_YG9IXEGznuGHrYjNNEZ0Rb-ZhM/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/shardok/settings.tsv
+curl -L "https://docs.google.com/spreadsheets/d/1p6I5nUMcoAPHIcqikVgbBCFVnqN9dpOEVClbS_wOI7M/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/eagle/settings.tsv
 
 bazel run //src/main/go/net/eagle0/build/settings_generator:settings_generator -- \
     ${PWD}/src/main/resources/net/eagle0/eagle/settings.tsv \
     ${PWD}/src/main/scala/net/eagle0/eagle/library/settings/
+bazel run gazelle
+

scripts/downloadTsvs.sh

@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
 
-curl -L "https://docs.google.com/spreadsheets/d/1DHEsiv4cY4gE6AX3sVH82K__mpBD1aznIYCQwQxA_F0/export?gid=0&format=tsv" > /tmp/names.tsv
+curl -L "https://docs.google.com/spreadsheets/d/1DHEsiv4cY4gE6AX3sVH82K__mpBD1aznIYCQwQxA_F0/export?gid=0&format=tsv" | tr -d '\r' > /tmp/names.tsv
 bazel run //src/main/scala/net/eagle0/util:name_list_checker -- /tmp/names.tsv > src/main/resources/net/eagle0/names.tsv
 bazel run //src/main/scala/net/eagle0/util:name_list_json_maker -- /tmp/names.tsv > src/main/resources/net/eagle0/names.json
-curl -L "https://docs.google.com/spreadsheets/d/1NhvG73HKyVE36yGpkV2oJiSIXoNqQOYTr5ArLnucYL0/export?gid=0&format=tsv" > src/main/resources/net/eagle0/shardok/battalionTypes.tsv
-curl -L "https://docs.google.com/spreadsheets/d/1pNWiyxIks2wJ1v7jRLFD24zrKHG2AfhC-nkWmQKQGN4/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/heroes.tsv
-curl -L "https://docs.google.com/spreadsheets/d/1RUguq5eAQprsZwOOqiCc-1dg4Urc_6iJ6awZsFU4MeI/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/beasts.tsv
+curl -L "https://docs.google.com/spreadsheets/d/1NhvG73HKyVE36yGpkV2oJiSIXoNqQOYTr5ArLnucYL0/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/shardok/battalionTypes.tsv
+curl -L "https://docs.google.com/spreadsheets/d/1pNWiyxIks2wJ1v7jRLFD24zrKHG2AfhC-nkWmQKQGN4/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/eagle/heroes.tsv
+curl -L "https://docs.google.com/spreadsheets/d/1RUguq5eAQprsZwOOqiCc-1dg4Urc_6iJ6awZsFU4MeI/export?gid=0&format=tsv" | tr -d '\r' > src/main/resources/net/eagle0/eagle/beasts.tsv
 #curl -L "https://docs.google.com/spreadsheets/d/1Z-60cJ_N1IasvqpVb5awKEkIYznEeR2IZSdli47oW88/export?gid=0&format=tsv" > src/main/resources/net/eagle0/eagle/province_map.tsv
 
 ${PWD}/scripts/dlSettings.sh

scripts/pre-commit-gazelle.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# Pre-commit hook wrapper for gazelle that fails if files are modified.
+# This ensures BUILD files are in canonical format before committing.
+
+set -e
+
+# Run gazelle
+bazel run //:gazelle 2>/dev/null
+
+# Check if any BUILD files were modified
+if ! git diff --quiet -- '*.bazel' '**/BUILD' 'WORKSPACE*'; then
+    echo ""
+    echo "ERROR: gazelle modified BUILD files. Please stage the changes and retry:"
+    echo ""
+    git diff --name-only -- '*.bazel' '**/BUILD' 'WORKSPACE*'
+    echo ""
+    echo "Run: git add -u && git commit"
+    exit 1
+fi

src/main/cpp/net/eagle0/common/SequenceRandomGenerator.hpp

@@ -14,6 +14,14 @@
 
 #include "src/main/cpp/net/eagle0/common/RandomGenerator.hpp"
 
+// A deterministic random generator that returns values from a fixed sequence.
+// Used for testing and MCTS simulation where we want specific, predictable outcomes.
+//
+// Values in the sequence are treated as [0, 1] probabilities that are returned
+// by DoubleZeroToOne(). The normal percentile methods (including open-ended
+// variants) work as usual, so callers must provide appropriate sequences.
+// For example, to get an open-ended low result of -50, provide [0.02, 0.52]
+// which produces: initial=2 (triggers open-ended), accumulated=52, final=2-52=-50
 class SequenceRandomGenerator : public ::RandomGenerator {
 private:
     const std::vector<double> sequence;

src/main/cpp/net/eagle0/common/mcts/abstract/AbstractMCTSAI.cpp

@@ -5,6 +5,7 @@
 #include "AbstractMCTSAI.hpp"
 
 #include <algorithm>
+#include <chrono>
 #include <fstream>
 #include <future>
 #include <iomanip>
@@ -14,6 +15,8 @@
 #include <stdexcept>
 #include <thread>
 
+#include "src/main/cpp/net/eagle0/common/mcts/util/TreeIndentUtil.hpp"
+
 namespace shardok::mcts {
 
 AbstractMCTSAI::AbstractMCTSAI(MCTSPlayerId playerId, MCTSConfig config)
@@ -82,7 +85,7 @@ auto AbstractMCTSAI::Search(
         LogSearchResults(rootNode.get(), bestChild, result);
     }
 
-    // Dump tree if requested
+    // Dump tree if explicitly requested via config
     if (!config_.debugDumpPath.empty()) { DumpTreeToFile(rootNode.get(), config_.debugDumpPath); }
 
     return result;
@@ -127,6 +130,37 @@ auto AbstractMCTSAI::BuildMCTSTree(
     // Initialize action counter
     root->totalActions = rootActions.size();
 
+    // CRITICAL: Do at least one expansion before entering the time-bounded loop.
+    // This ensures we always have at least one child to return, even if the deadline
+    // has already passed (e.g., due to debugger pause, system load, etc.)
+    {
+        auto* selected = MCTSSelection(root.get());
+        const bool selectedIsRoot = (selected == root.get());
+        const size_t childrenBeforeExpansion = root->children.size();
+
+        if (selected) {
+            auto* expanded = MCTSExpansion(selected, engine);
+            const double reward =
+                    MCTSSimulation(engine, *expanded->gameState, playerId_, expanded->playerFlips);
+            MCTSBackpropagation(expanded, reward, config_.backpropagationPolicy);
+        }
+
+        // Verify we actually have at least one child after the initial expansion
+        if (root->children.empty()) {
+            throw MCTSInternalError(
+                    "MCTS BuildMCTSTree: Initial expansion failed to produce any children. "
+                    "totalActions=" +
+                    std::to_string(root->totalActions) +
+                    ", selected=" + (selected ? "non-null" : "null") +
+                    ", selectedIsRoot=" + (selectedIsRoot ? "true" : "false") +
+                    ", childrenBefore=" + std::to_string(childrenBeforeExpansion) +
+                    ", childrenAfter=" + std::to_string(root->children.size()) +
+                    ", root->CanExpand()=" + (root->CanExpand() ? "true" : "false") +
+                    ", root->nextUntriedActionIndex=" +
+                    std::to_string(root->nextUntriedActionIndex));
+        }
+    }
+
     std::atomic<int> iterations{0};
 
     if (config_.useMultithreading && config_.numThreads > 1) {
@@ -203,11 +237,27 @@ auto AbstractMCTSAI::BuildMCTSTree(
 auto AbstractMCTSAI::MCTSSelection(MCTSNode* root) const -> MCTSNode* {
     MCTSNode* current = root;
 
-    while (!current->isTerminal && current->depth < config_.maxTreeDepth) {
+    while (current->depth < config_.maxTreeDepth) {
+        // Check expansion FIRST - allows expanding "terminal" nodes that still have
+        // untried actions (e.g., final round where we need to pick an action)
         if (current->CanExpand()) {
-            return current;  // Node has untried actions
-        } else if (!current->children.empty()) {
-            current = current->GetBestChild(config_.explorationConstant);
+            return current;  // Node has untried actions/outcomes
+        }
+
+        // Only after expansion check: stop if terminal and fully expanded
+        if (current->isTerminal) {
+            break;  // Terminal and no more actions to try
+        }
+
+        if (!current->children.empty()) {
+            // Choose child based on node type
+            if (current->IsChanceNode()) {
+                // Chance nodes: select outcome proportional to probability
+                current = current->GetBestChanceChild();
+            } else {
+                // Decision nodes: select using UCB1
+                current = current->GetBestChild(config_.explorationConstant);
+            }
             if (!current) break;
         } else {
             break;  // Leaf node
@@ -219,10 +269,109 @@ auto AbstractMCTSAI::MCTSSelection(MCTSNode* root) const -> MCTSNode* {
 
 auto AbstractMCTSAI::MCTSExpansion(MCTSNode* node, const MCTSGameEngine& engine) const
         -> MCTSNode* {
-    if (!node->CanExpand() || node->isTerminal) {
+    // Only skip if we truly can't expand. Allow expansion even if "terminal" as long as
+    // there are untried actions (e.g., final round where we need to pick an action).
+    if (!node->CanExpand()) {
         return node;  // Nothing to expand
     }
 
+    // Handle chance node expansion (expanding outcomes)
+    if (node->IsChanceNode()) {
+        // Chance nodes expand their outcome children
+        // This should have been set up when the chance node was created
+        if (node->outcomeProbabilities.empty()) {
+            throw MCTSInternalError(
+                    "Chance node has no outcome probabilities - this indicates a bug");
+        }
+
+        const size_t outcomeIndex = node->nextUntriedActionIndex++;
+        if (outcomeIndex >= node->outcomeProbabilities.size()) {
+            throw MCTSInternalError(
+                    "Chance node outcomeIndex >= outcomeProbabilities.size() - bug in expansion");
+        }
+
+        // The chance node's action should be the binary action
+        if (!node->action) {
+            throw MCTSInternalError("Chance node has no action - this indicates a bug");
+        }
+
+        // Apply the action with the representative roll for this outcome
+        // Outcome 0 = success, Outcome 1 = failure
+        // Use the representative roll for this specific outcome
+        const double representativeRoll = node->outcomeRolls[outcomeIndex];
+        auto newState = engine.applyAction(*node->gameState, *node->action, representativeRoll);
+        if (!newState) {
+            throw MCTSInternalError(
+                    "MCTS expansion: engine.applyAction() returned nullptr for chance node "
+                    "outcome - this indicates a game engine error");
+        }
+
+        // Determine if player changed
+        const MCTSPlayerId newPlayerId = newState->currentPlayerId();
+        const bool playerChanged = (newPlayerId != node->playerId);
+
+        // Calculate player flips and maximizing status
+        const int newPlayerFlips = node->playerFlips + (playerChanged ? 1 : 0);
+        const bool newIsMaximizing = (newPlayerId == playerId_);
+
+        // Create outcome child (decision node)
+        auto outcomeChild = std::make_unique<MCTSNode>(
+                node->action->clone(),
+                std::move(newState),
+                newPlayerId,
+                node->depth + 1,
+                outcomeIndex,
+                newPlayerFlips,
+                newIsMaximizing,
+                node->actionWeight);  // Inherit action weight from chance node
+
+        // Set up outcome child's actions if not terminal
+        const bool shouldExpand =
+                !outcomeChild->isTerminal && node->playerFlips <= config_.maxPlayerFlips;
+        if (shouldExpand) {
+            const auto childActions = engine.getLegalActions(
+                    *outcomeChild->gameState,
+                    playerId_,
+                    newPlayerFlips,
+                    config_.maxPlayerFlips);
+            outcomeChild->totalActions = childActions.size();
+        }
+
+        // Calculate scores
+        outcomeChild->immediateScore = engine.evaluateState(*outcomeChild->gameState, playerId_);
+        outcomeChild->lookaheadScore = outcomeChild->immediateScore;
+
+        // Set parent and add to children
+        outcomeChild->parent = node;
+        node->children.push_back(std::move(outcomeChild));
+
+        // Update chance node's immediate score to expected value of expanded outcomes
+        // This corrects the initial value (which incorrectly used parent state) and ensures
+        // fair UCB comparison with non-chance actions like END_TURN
+        {
+            double expectedImmediate = 0.0;
+            double totalProbability = 0.0;
+            for (size_t i = 0; i < node->children.size(); i++) {
+                const double prob = node->outcomeProbabilities[i];
+                const double childImmediate = node->children[i]->immediateScore;
+                expectedImmediate += prob * childImmediate;
+                totalProbability += prob;
+            }
+            // Normalize by total probability of expanded outcomes
+            if (totalProbability > 0.0) {
+                node->immediateScore = expectedImmediate / totalProbability;
+                // CRITICAL: Always update lookaheadScore to the expected value.
+                // Without this, chance nodes keep their initial lookaheadScore from the parent
+                // state (before the action), while regular actions use the child state (after).
+                // This gives chance nodes an unfair initial UCB advantage.
+                node->lookaheadScore = node->immediateScore;
+            }
+        }
+
+        return node->children.back().get();
+    }
+
+    // Handle decision node expansion (expanding actions)
     // Get next action to expand (sequential order)
     const size_t actionIndex = node->nextUntriedActionIndex++;
 
@@ -250,6 +399,49 @@ auto AbstractMCTSAI::MCTSExpansion(MCTSNode* node, const MCTSGameEngine& engine)
     const double actionWeight =
             actionIndex < actionWeights.size() ? actionWeights[actionIndex] : 1.0;
 
+    // Check if this action requires a chance node
+    if (action->requiresChanceNode()) {
+        // Create intermediate chance node
+        auto chanceNode = std::make_unique<MCTSNode>(
+                action->clone(),
+                node->gameState->clone(),  // Chance node has same state as parent
+                node->playerId,
+                node->depth + 1,
+                actionIndex,
+                node->playerFlips,
+                node->isMaximizingPlayer,
+                actionWeight);
+
+        chanceNode->nodeType = NodeType::CHANCE;
+
+        // Get outcome information from engine
+        const auto outcomeInfo = engine.getBinaryOutcomeInfo(*node->gameState, *action);
+
+        // Set up outcome metadata (2 outcomes for binary actions)
+        chanceNode->outcomeProbabilities = outcomeInfo.getProbabilities();
+        chanceNode->outcomeRolls = outcomeInfo.getRepresentativeRolls();
+        chanceNode->totalActions = 2;  // Binary: success and failure
+
+        // Chance node immediate score will be computed as expected value during backpropagation
+        // For now, initialize to parent's score as a reasonable default
+        chanceNode->immediateScore = engine.evaluateState(*node->gameState, playerId_);
+        chanceNode->lookaheadScore = chanceNode->immediateScore;
+
+        // Set parent and add to children
+        chanceNode->parent = node;
+        node->children.push_back(std::move(chanceNode));
+
+        // CRITICAL: Immediately expand the first outcome and return that instead.
+        // If we returned the chance node itself, MCTSSimulation would run on the parent state
+        // (since chance nodes have parent's gameState), which is wrong. We need to simulate
+        // from an actual outcome state.
+        //
+        // Note: This recursion is bounded because outcome children are decision nodes,
+        // not chance nodes, so the recursion goes exactly one level deep.
+        return MCTSExpansion(node->children.back().get(), engine);
+    }
+
+    // Regular (non-chance) action: create decision node directly
     auto newState = engine.applyAction(*node->gameState, *action);
     if (!newState) {
         throw MCTSInternalError(
@@ -405,8 +597,45 @@ auto AbstractMCTSAI::MCTSBackpropagation(
         node->totalReward += reward;
         node->averageReward = node->totalReward / node->visitCount;
 
-        // Update lookahead score based on strategy
-        if (useMinimaxBackup && !node->children.empty()) {
+        // Update lookahead score based on node type and strategy
+        if (node->IsChanceNode() && !node->children.empty()) {
+            // Chance nodes: compute expected value (weighted average of outcomes)
+            // lookaheadScore = sum(probability[i] * childValue[i])
+            double expectedValue = 0.0;
+            double totalProbability = 0.0;
+            int visitedChildCount = 0;
+
+            for (size_t i = 0; i < node->children.size(); i++) {
+                const auto& child = node->children[i];
+                if (child->visitCount == 0) continue;  // Unvisited outcomes don't contribute
+
+                const double probability = node->outcomeProbabilities[i];
+                const double childValue = child->lookaheadScore;
+                expectedValue += probability * childValue;
+                totalProbability += probability;
+                visitedChildCount++;
+            }
+
+            // Use expected value if we have visited outcomes, else use average
+            if (visitedChildCount > 0) {
+                // CRITICAL: Normalize by total probability to get correct expected value
+                // when not all outcomes have been visited yet
+                if (totalProbability > 0.0 && totalProbability < 1.0) {
+                    // Normalize to account for unvisited outcomes
+                    // This gives the correct expected value among visited outcomes
+                    expectedValue /= totalProbability;
+                }
+                node->lookaheadScore = expectedValue;
+            } else {
+                // No outcomes visited yet, fall back to average
+                if (node->visitCount == 1) {
+                    node->lookaheadScore = reward;
+                } else {
+                    const double alpha = 1.0 / node->visitCount;
+                    node->lookaheadScore = (1.0 - alpha) * node->lookaheadScore + alpha * reward;
+                }
+            }
+        } else if (useMinimaxBackup && !node->children.empty()) {
             // Minimax backup: use best/worst child value for adversarial games
             // The operation (MAX or MIN) depends on whose turn it is at THIS node
             // - If this node is root player's turn: root chooses MAX (best for root)
@@ -687,24 +916,6 @@ auto AbstractMCTSAI::LogSearchResults(
            result.nodesEvaluated,
            rootNode->visitCount);
 
-    // Helper to check if a node is a "chance parent" - all children have the same action
-    // This indicates the children represent different probabilistic outcomes of the same action
-    auto isChanceParent = [](const MCTSNode* node) -> bool {
-        if (!node || node->children.size() < 2) return false;
-        const std::string* firstDesc = nullptr;
-        for (const auto& child : node->children) {
-            if (child->isRedundant) continue;
-            if (!child->action) return false;
-            const auto& desc = child->action->getDescription();
-            if (!firstDesc) {
-                firstDesc = &desc;
-            } else if (*firstDesc != desc) {
-                return false;  // Different actions = not a chance node
-            }
-        }
-        return true;
-    };
-
     // Log best sequence from chosen action (following most-visited path)
     std::vector<const MCTSNode*> bestSequence;
     bestSequence.reserve(10);
@@ -734,34 +945,26 @@ auto AbstractMCTSAI::LogSearchResults(
         for (size_t i = 0; i < bestSequence.size(); ++i) {
             const auto* node = bestSequence[i];
 
-            // Check if this node's parent was a chance node - if so, skip displaying this
-            // outcome node separately since we already consolidated it with the action
-            if (i > 0 && node->parent && isChanceParent(node->parent)) {
-                // This is an outcome of a chance node - already displayed, skip
-                continue;
-            }
+            // Skip outcome nodes (children of chance nodes) - they're displayed with their parent
+            if (i > 0 && node->parent && node->parent->IsChanceNode()) { continue; }
 
             displayedStep++;
             printf("  %d.", displayedStep);
             if (node->action) { printf(" %s", node->action->getDescription().c_str()); }
 
-            // Check if this node is a chance parent (has multiple outcome children)
-            if (isChanceParent(node)) {
-                // Collect outcome information
-                std::vector<std::pair<double, double>> outcomes;  // (weight, lookahead)
-                double totalWeight = 0;
-                for (const auto& child : node->children) {
-                    if (child->isRedundant) continue;
-                    outcomes.emplace_back(child->actionWeight, child->lookaheadScore);
-                    totalWeight += child->actionWeight;
+            // If this is a chance node, display outcome probabilities and scores
+            if (node->IsChanceNode() && !node->outcomeProbabilities.empty()) {
+                printf(" [");
+                for (size_t j = 0; j < node->outcomeProbabilities.size(); ++j) {
+                    if (j > 0) printf(", ");
+                    const double prob = node->outcomeProbabilities[j] * 100;
+                    // Show lookahead score for each outcome if child exists
+                    if (j < node->children.size() && node->children[j]->visitCount > 0) {
+                        printf("%.0f%%->%.1f", prob, node->children[j]->lookaheadScore);
+                    } else {
+                        printf("%.0f%%->?", prob);
+                    }
                 }
-                printf(" [%zu outcomes:", outcomes.size());
-                for (size_t j = 0; j < std::min(outcomes.size(), size_t(3)); ++j) {
-                    const double pct =
-                            totalWeight > 0 ? (outcomes[j].first / totalWeight * 100) : 0;
-                    printf(" %.0f%%->%.1f", pct, outcomes[j].second);
-                }
-                if (outcomes.size() > 3) printf(" ...");
                 printf("]");
             }
 
@@ -771,9 +974,10 @@ auto AbstractMCTSAI::LogSearchResults(
                    node->lookaheadScore);
 
             // For non-root nodes in the sequence, show what the top alternatives were
-            // Skip showing alternatives for chance outcome nodes (parent was chance)
+            // Skip showing alternatives for chance nodes (they have outcome children, not action
+            // alternatives)
             if (i > 0 && node->parent && !node->parent->children.empty() &&
-                !isChanceParent(node->parent)) {
+                !node->parent->IsChanceNode()) {
                 // Collect all siblings (including this node) and sort by visit count
                 std::vector<const MCTSNode*> siblings;
                 siblings.reserve(node->parent->children.size());
@@ -849,17 +1053,14 @@ auto AbstractMCTSAI::DumpNodeRecursive(
     if (!node) return;
 
     // Create indent string
-    std::string indent;
-    for (int i = 0; i < indentLevel; ++i) {
-        if (i == indentLevel - 1) {
-            indent += isLastChild ? "└─ " : "├─ ";
-        } else {
-            indent += "   ";
-        }
-    }
+    const std::string indent = ::mcts::util::BuildTreeIndent(indentLevel, isLastChild);
 
     // Write node information
     out << indent;
+
+    // Show node type for chance nodes
+    if (node->IsChanceNode()) { out << "[CHANCE] "; }
+
     if (node->action) {
         out << node->action->getDescription();
     } else {
@@ -878,6 +1079,21 @@ auto AbstractMCTSAI::DumpNodeRecursive(
     if (node->isTerminal) { out << ", TERMINAL"; }
     out << ")\n";
 
+    // Show outcome probabilities and rolls for chance nodes
+    if (node->IsChanceNode() && !node->outcomeProbabilities.empty()) {
+        const std::string outcomeIndent = ::mcts::util::ConvertBranchToContinuation(indent);
+        out << outcomeIndent << "  Outcomes: ";
+        for (size_t i = 0; i < node->outcomeProbabilities.size(); ++i) {
+            if (i > 0) out << ", ";
+            out << "[" << i << "] p=" << std::fixed << std::setprecision(3)
+                << node->outcomeProbabilities[i];
+            if (i < node->outcomeRolls.size()) {
+                out << " roll=" << std::fixed << std::setprecision(1) << node->outcomeRolls[i];
+            }
+        }
+        out << "\n";
+    }
+
     // Recursively dump children
     if (!node->children.empty()) {
         for (size_t i = 0; i < node->children.size(); ++i) {

src/main/cpp/net/eagle0/common/mcts/abstract/BUILD.bazel

@@ -86,6 +86,7 @@ cc_library(
         ":mcts_game_state",
         ":mcts_node",
         ":mcts_types",
+        "//src/main/cpp/net/eagle0/common/mcts/util:tree_indent_util",
     ],
 )
 

src/main/cpp/net/eagle0/common/mcts/abstract/MCTSAction.hpp

@@ -27,6 +27,11 @@ public:
 
     // Check if two actions are equivalent
     [[nodiscard]] virtual bool equals(const MCTSAction& other) const = 0;
+
+    // Check if this action requires a chance node (binary success/failure outcome)
+    // Examples: START_FIRE, RAISE_DEAD, EXTINGUISH_FIRE
+    // If true, the game engine should provide outcome probabilities
+    [[nodiscard]] virtual bool requiresChanceNode() const = 0;
 };
 
 }  // namespace mcts

src/main/cpp/net/eagle0/common/mcts/abstract/MCTSGameEngine.hpp

@@ -16,15 +16,50 @@
 namespace shardok {
 namespace mcts {
 
+// Information about chance outcomes (supports both binary and multi-outcome)
+struct ChanceOutcomeInfo {
+    std::vector<double> probabilities;  // Probability of each outcome (must sum to 1.0)
+    std::vector<double> rolls;          // Roll values for each outcome
+
+    // Factory for binary success/failure outcomes (e.g., START_FIRE)
+    [[nodiscard]] static ChanceOutcomeInfo binary(double successProbability) {
+        // -100: triggers open-ended low sequence, succeeds against any threshold
+        // 150: triggers open-ended high sequence, fails against any threshold
+        return {{successProbability, 1.0 - successProbability}, {-100.0, 150.0}};
+    }
+
+    // Factory for multi-outcome with fixed seeds (e.g., END_TURN)
+    // Uses uniformly distributed roll values to sample different random outcomes
+    [[nodiscard]] static ChanceOutcomeInfo multiOutcome(int numOutcomes) {
+        std::vector<double> probs(numOutcomes, 1.0 / numOutcomes);
+        std::vector<double> rollValues;
+        rollValues.reserve(numOutcomes);
+        // Spread rolls across the percentile range: 10, 30, 50, 70, 90 for 5 outcomes
+        for (int i = 0; i < numOutcomes; ++i) {
+            rollValues.push_back(10.0 + (80.0 * i) / (numOutcomes - 1));
+        }
+        return {probs, rollValues};
+    }
+
+    [[nodiscard]] const std::vector<double>& getRepresentativeRolls() const { return rolls; }
+
+    [[nodiscard]] const std::vector<double>& getProbabilities() const { return probabilities; }
+};
+
+// Backward compatibility alias
+using BinaryOutcomeInfo = ChanceOutcomeInfo;
+
 // Abstract interface for game engines
 class MCTSGameEngine {
 public:
     virtual ~MCTSGameEngine() = default;
 
     // Apply an action to a state and return the resulting state
+    // If deterministicRoll is provided (0.0-100.0), use that for any random outcomes
     [[nodiscard]] virtual std::unique_ptr<MCTSGameState> applyAction(
             const MCTSGameState& state,
-            const MCTSAction& action) const = 0;
+            const MCTSAction& action,
+            double deterministicRoll = -1.0) const = 0;
 
     // Apply an action to a mutable state in-place (for efficient simulation)
     // Default: clone, apply, and move the result back
@@ -111,6 +146,13 @@ public:
         (void)state;  // Suppress unused parameter warning
         return filteredIndex;
     }
+
+    // Get binary outcome information for an action that requires a chance node
+    // Only called for actions where action.requiresChanceNode() returns true
+    // Returns success probability for binary success/failure actions
+    [[nodiscard]] virtual BinaryOutcomeInfo getBinaryOutcomeInfo(
+            const MCTSGameState& state,
+            const MCTSAction& action) const = 0;
 };
 
 }  // namespace mcts

src/main/cpp/net/eagle0/common/mcts/abstract/MCTSNode.hpp

@@ -17,8 +17,16 @@
 namespace shardok {
 namespace mcts {
 
+// Node type for MCTS tree
+enum class NodeType {
+    DECISION,  // Player chooses an action (standard MCTS node)
+    CHANCE     // Nature determines outcome (for probabilistic actions)
+};
+
 // Abstract MCTS Node structure
 struct MCTSNode {
+    // Node type
+    NodeType nodeType = NodeType::DECISION;
     // Action information
     std::unique_ptr<MCTSAction> action;  // The action that led to this node (null for root)
     size_t actionIndex = SIZE_MAX;       // Index in the original actions array (SIZE_MAX for root)
@@ -43,6 +51,10 @@ struct MCTSNode {
     size_t totalActions = 0;            // Total number of available actions
     MCTSNode* parent = nullptr;
 
+    // Chance node specific fields (only used when nodeType == CHANCE)
+    std::vector<double> outcomeProbabilities;  // Probability of each outcome
+    std::vector<double> outcomeRolls;          // Representative roll for each outcome
+
     // Game context
     MCTSPlayerId playerId;
     int depth = 0;
@@ -136,6 +148,40 @@ struct MCTSNode {
     // Check if this node can be expanded
     [[nodiscard]] bool CanExpand() const { return nextUntriedActionIndex < totalActions; }
 
+    // Check if this is a chance node
+    [[nodiscard]] bool IsChanceNode() const { return nodeType == NodeType::CHANCE; }
+
+    // Check if this is a decision node
+    [[nodiscard]] bool IsDecisionNode() const { return nodeType == NodeType::DECISION; }
+
+    // Get best child from chance node (probability-weighted selection)
+    // For chance nodes, we want to explore outcomes proportionally to their probability
+    [[nodiscard]] MCTSNode* GetBestChanceChild() const {
+        if (children.empty() || !IsChanceNode()) return nullptr;
+
+        // Find the outcome that is most under-explored relative to its probability
+        // Expected visits for outcome i: total_visits * probability[i]
+        // Actual visits: child[i]->visitCount
+        // Deficit: expected - actual
+        size_t bestIndex = 0;
+        double bestDeficit = -std::numeric_limits<double>::max();
+
+        for (size_t i = 0; i < children.size(); i++) {
+            if (!children[i] || children[i]->isRedundant) continue;
+
+            const double expectedVisits = visitCount * outcomeProbabilities[i];
+            const double actualVisits = static_cast<double>(children[i]->visitCount);
+            const double deficit = expectedVisits - actualVisits;
+
+            if (deficit > bestDeficit) {
+                bestDeficit = deficit;
+                bestIndex = i;
+            }
+        }
+
+        return children[bestIndex].get();
+    }
+
     // Get best child based on UCB1
     [[nodiscard]] MCTSNode* GetBestChild(const double explorationConstant) const {
         if (children.empty()) return nullptr;

src/main/cpp/net/eagle0/common/mcts/util/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+cc_library(
+    name = "tree_indent_util",
+    srcs = ["TreeIndentUtil.cpp"],
+    hdrs = ["TreeIndentUtil.hpp"],
+    visibility = ["//visibility:public"],
+)

src/main/cpp/net/eagle0/common/mcts/util/TreeIndentUtil.cpp

@@ -0,0 +1,53 @@
+//
+// Utility functions for processing tree indentation with UTF-8 box drawing characters
+//
+
+#include "TreeIndentUtil.hpp"
+
+namespace mcts::util {
+
+namespace {
+// Box drawing characters for tree visualization
+constexpr const char* kBranch = "\xE2\x94\x9C";      // ├
+constexpr const char* kCorner = "\xE2\x94\x94";      // └
+constexpr const char* kVertical = "\xE2\x94\x82";    // │
+constexpr const char* kHorizontal = "\xE2\x94\x80";  // ─
+}  // namespace
+
+std::string BuildTreeIndent(int indentLevel, bool isLastChild) {
+    std::string indent;
+
+    for (int i = 0; i < indentLevel; ++i) {
+        if (i == indentLevel - 1) {
+            indent += isLastChild ? kCorner : kBranch;
+            indent += kHorizontal;
+            indent += " ";
+        } else {
+            indent += "   ";
+        }
+    }
+
+    return indent;
+}
+
+std::string ConvertBranchToContinuation(const std::string& indent) {
+    std::string result = indent;
+
+    const std::string replacement = std::string(kVertical) + "  ";
+
+    // Replace ├ and └ with │
+    size_t pos = 0;
+    while ((pos = result.find(kBranch, pos)) != std::string::npos) {
+        result.replace(pos, 3, replacement);  // UTF-8 chars are 3 bytes
+        pos += replacement.size();
+    }
+    pos = 0;
+    while ((pos = result.find(kCorner, pos)) != std::string::npos) {
+        result.replace(pos, 3, replacement);
+        pos += replacement.size();
+    }
+
+    return result;
+}
+
+}  // namespace mcts::util

src/main/cpp/net/eagle0/common/mcts/util/TreeIndentUtil.hpp

@@ -0,0 +1,22 @@
+//
+// Utility functions for processing tree indentation with UTF-8 box drawing characters
+//
+
+#ifndef EAGLE0_TREE_INDENT_UTIL_HPP
+#define EAGLE0_TREE_INDENT_UTIL_HPP
+
+#include <string>
+
+namespace mcts::util {
+
+// Builds tree indentation string for a node at a given depth
+// Returns string like "   ├─ " or "   └─ " with proper spacing
+std::string BuildTreeIndent(int indentLevel, bool isLastChild);
+
+// Converts tree branch characters (├ and └) to continuation lines (│) for sub-content
+// This preserves the tree structure when displaying additional info below a node
+std::string ConvertBranchToContinuation(const std::string& indent);
+
+}  // namespace mcts::util
+
+#endif  // EAGLE0_TREE_INDENT_UTIL_HPP

src/main/cpp/net/eagle0/shardok/ai/ShardokAIClient.cpp

@@ -10,6 +10,16 @@
 
 #define DEBUG_FLEE_DECISIONS
 
+// Enable to dump game state and debug tree to /tmp for debugging
+// #define ENABLE_MCTS_DEBUG_DUMP
+
+#ifdef ENABLE_MCTS_DEBUG_DUMP
+#include <chrono>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+#endif
+
 #include "AIAttackerStrategySelector.hpp"
 #include "AIConfig.hpp"
 #include "AIDefenderStrategySelector.hpp"
@@ -208,6 +218,37 @@ auto ShardokAIClient::StandardChooseCommandIndex(
     IterativeDeepeningAI::SearchResult search_result;
 
     if (aiAlgorithmType == AIAlgorithmType::MCTS) {
+#ifdef ENABLE_MCTS_DEBUG_DUMP
+        // Set unique debug dump path for each action using timestamp
+        const auto now = std::chrono::system_clock::now();
+        const auto nowTime = std::chrono::system_clock::to_time_t(now);
+        const auto nowMs =
+                std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) %
+                1000;
+
+        std::ostringstream pathStream;
+        pathStream << "/tmp/shardok_debug_"
+                   << std::put_time(std::localtime(&nowTime), "%Y%m%d_%H%M%S") << "_"
+                   << std::setfill('0') << std::setw(3) << nowMs.count() << "_p"
+                   << static_cast<int>(playerId) << ".txt";
+        adjustedMCTSConfig.debugDumpPath = pathStream.str();
+
+        // Also dump the game state to a file for reproduction
+        std::ostringstream statePathStream;
+        statePathStream << "/tmp/shardok_state_"
+                        << std::put_time(std::localtime(&nowTime), "%Y%m%d_%H%M%S") << "_"
+                        << std::setfill('0') << std::setw(3) << nowMs.count() << "_p"
+                        << static_cast<int>(playerId) << ".bin";
+        const std::string statePath = statePathStream.str();
+
+        // Write the flatbuffer game state to file using SaveTo method
+        if (guessedState.SaveTo(statePath)) {
+            printf("Game state dumped to: %s\n", statePath.c_str());
+        } else {
+            printf("Failed to dump game state to: %s\n", statePath.c_str());
+        }
+#endif  // ENABLE_MCTS_DEBUG_DUMP
+
         // Using Monte Carlo Tree Search AI (with abstraction layer)
         ShardokMCTSAI ai(
                 playerId,

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/BUILD.bazel

@@ -32,6 +32,7 @@ cc_library(
         "//src/main/cpp/net/eagle0/shardok/library:engine",
         "//src/main/cpp/net/eagle0/shardok/library:game_state_w",
         "//src/main/cpp/net/eagle0/shardok/library/settings:game_settings",
+        "//src/main/protobuf/net/eagle0/shardok/common:command_type_cc_proto",
     ],
 )
 

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokAction.cpp

@@ -20,13 +20,15 @@ ShardokAction::ShardokAction(
         PlayerId player,
         int actorId,
         int targetRow,
-        int targetCol)
+        int targetCol,
+        bool hasOdds)
     : commandIndex_(index),
       type_(type),
       player_(player),
       actorId_(actorId),
       targetRow_(targetRow),
-      targetCol_(targetCol) {}
+      targetCol_(targetCol),
+      hasOdds_(hasOdds) {}
 
 std::string ShardokAction::getDescription() const {
     std::stringstream ss;
@@ -52,7 +54,8 @@ std::unique_ptr<MCTSAction> ShardokAction::clone() const {
             player_,
             actorId_,
             targetRow_,
-            targetCol_);
+            targetCol_,
+            hasOdds_);
 }
 
 bool ShardokAction::equals(const MCTSAction& other) const {
@@ -63,4 +66,23 @@ bool ShardokAction::equals(const MCTSAction& other) const {
     return commandIndex_ == shardokOther->commandIndex_;
 }
 
+bool ShardokAction::requiresChanceNode() const {
+    // Actions with probabilistic outcomes require chance nodes:
+    // 1. Binary success/failure actions (hasOdds_): START_FIRE, FEAR, etc.
+    // 2. END_TURN: random effects (fire spread, weather changes)
+    // 3. Combat actions: roll affects damage dealt (MELEE, ARCHERY, CHARGE, DUEL)
+    if (hasOdds_) { return true; }
+
+    using namespace net::eagle0::shardok::common;
+    switch (type_) {
+        case END_TURN_COMMAND:
+        case MELEE_COMMAND:
+        case ARCHERY_COMMAND:
+        case CHARGE_COMMAND:
+        case CHALLENGE_DUEL_COMMAND:
+        case REDUCE_COMMAND: return true;
+        default: return false;
+    }
+}
+
 }  // namespace shardok::mcts

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokAction.hpp

@@ -29,13 +29,15 @@ public:
             PlayerId player,
             int actorId,
             int targetRow,
-            int targetCol);
+            int targetCol,
+            bool hasOdds);
 
     // MCTSAction interface implementation
     [[nodiscard]] size_t getIndex() const override { return commandIndex_; }
     [[nodiscard]] std::string getDescription() const override;
     [[nodiscard]] std::unique_ptr<MCTSAction> clone() const override;
     [[nodiscard]] bool equals(const MCTSAction& other) const override;
+    [[nodiscard]] bool requiresChanceNode() const override;
 
     // Shardok-specific accessors (O(1), no allocations)
     [[nodiscard]] int getType() const { return static_cast<int>(type_); }
@@ -44,13 +46,14 @@ public:
     [[nodiscard]] std::pair<int, int> getTarget() const { return {targetRow_, targetCol_}; }
 
 private:
-    // Store only essential fields (~24 bytes, all POD, cache-friendly)
+    // Store only essential fields (~25 bytes, all POD, cache-friendly)
     size_t commandIndex_;
     CommandType type_;
     PlayerId player_;
     int actorId_;    // -1 if no actor
     int targetRow_;  // -1 if no target
     int targetCol_;  // -1 if no target
+    bool hasOdds_;   // true if command has probabilistic outcome
 };
 
 }  // namespace shardok::mcts

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameEngine.cpp

@@ -10,11 +10,13 @@
 
 #include "ShardokAction.hpp"
 #include "ShardokGameState.hpp"
+#include "src/main/cpp/net/eagle0/common/SequenceRandomGenerator.hpp"
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSTypes.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AICommandFilter.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIHeuristicWeighting.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/score/AIScoreCalculator.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/ShardokException.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
 
 namespace shardok::mcts {
@@ -60,7 +62,8 @@ ShardokGameEngine::ShardokGameEngine(
 
 std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
         const MCTSGameState& state,
-        const MCTSAction& action) const {
+        const MCTSAction& action,
+        double deterministicRoll) const {
     const auto* shardokState = dynamic_cast<const ShardokGameState*>(&state);
     const auto* shardokAction = dynamic_cast<const ShardokAction*>(&action);
 
@@ -90,9 +93,54 @@ std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
         engine = std::make_shared<ShardokEngine>(*engine);
     }
 
-    engine->PostCommand(currentPlayer, shardokAction->getIndex(), nullptr);
+    // Create deterministic random generator if a specific roll is requested
+    // deterministicRoll of -1.0 (default) means use random generator
+    // Any other value (including negative) creates a deterministic generator
+    // For open-ended percentile commands, we compute a sequence of values that will
+    // produce the desired final result through the normal open-ended mechanics
+    std::shared_ptr<::RandomGenerator> randomGen = nullptr;
+    constexpr double kNoRollSentinel = -1.0;
+    if (deterministicRoll != kNoRollSentinel) {
+        std::vector<double> sequence;
 
-    // Create and return the new state (don't cache the mutated engine)
+        if (deterministicRoll >= 5.0 && deterministicRoll <= 95.0) {
+            // Normal range: single value works directly
+            sequence = {deterministicRoll / 100.0};
+        } else if (deterministicRoll < 5.0) {
+            // Need open-ended LOW result (e.g., -100 for guaranteed success)
+            // OpenEndedPercentile: if initial < 5, returns initial - OpenEndedHighImpl(0, 4)
+            // We want: initial - accumulated = deterministicRoll
+            // Use initial = 2 (clearly < 5), so accumulated = 2 - deterministicRoll
+            constexpr double kInitialLow = 2.0;
+            sequence = {kInitialLow / 100.0};
+            // OpenEndedHighImpl accumulates rolls until one < 95
+            // Split accumulated into rolls: 96 (continues) + remaining (stops)
+            double remaining = kInitialLow - deterministicRoll;
+            while (remaining > 95.0) {
+                sequence.push_back(0.96);  // 96 > 95, continues accumulation
+                remaining -= 96.0;
+            }
+            sequence.push_back(remaining / 100.0);  // Final roll < 95, stops
+        } else {
+            // Need open-ended HIGH result (e.g., 150 for guaranteed failure)
+            // OpenEndedPercentile: if initial > 95, returns OpenEndedHighImpl(initial, 4)
+            // OpenEndedHighImpl accumulates rolls until one < 95
+            constexpr double kInitialHigh = 96.0;
+            sequence = {kInitialHigh / 100.0};
+            double remaining = deterministicRoll - kInitialHigh;
+            while (remaining > 95.0) {
+                sequence.push_back(0.96);
+                remaining -= 96.0;
+            }
+            sequence.push_back(remaining / 100.0);
+        }
+
+        randomGen = std::make_shared<::SequenceRandomGenerator>(sequence);
+    }
+
+    engine->PostCommand(currentPlayer, shardokAction->getIndex(), randomGen);
+
+    // Create and return the new state
     auto newState = std::make_unique<ShardokGameState>(
             engine->GetCurrentGameState(),
             scoreCalculator_,
@@ -104,6 +152,11 @@ std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
             *alCache_,
             criticalTileCoords_);
 
+    // Cache the engine on the new state so score() can use it for END_TURN normalization
+    // The engine's command list may be stale after the action was applied, but that's OK -
+    // we'll refresh it when we call GetAvailableCommandsForAIPlayer() in score()
+    newState->setCachedEngine(engine);
+
     // Don't pre-compute hash - let it be computed lazily on first use
     // Many states (especially in simulation) never need their hash computed
     return newState;
@@ -203,7 +256,8 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
                         cmd->GetPlayerId(),
                         cmd->GetActorUnitId(),
                         cmd->GetTargetRow(),
-                        cmd->GetTargetColumn()));
+                        cmd->GetTargetColumn(),
+                        cmd->HasOdds()));
             }
         }
 
@@ -272,7 +326,8 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
                     cmd->GetPlayerId(),
                     cmd->GetActorUnitId(),
                     cmd->GetTargetRow(),
-                    cmd->GetTargetColumn()));
+                    cmd->GetTargetColumn(),
+                    cmd->HasOdds()));
         }
     }
 
@@ -488,6 +543,83 @@ void ShardokGameEngine::resetCacheStatistics() {
     timeInLegalActionsComputation_.store(0, std::memory_order_relaxed);
 }
 
+ChanceOutcomeInfo ShardokGameEngine::getBinaryOutcomeInfo(
+        const MCTSGameState& state,
+        const MCTSAction& action) const {
+    const auto* shardokState = dynamic_cast<const ShardokGameState*>(&state);
+    const auto* shardokAction = dynamic_cast<const ShardokAction*>(&action);
+
+    if (!shardokState || !shardokAction) {
+        throw ShardokInternalErrorException("Invalid state or action type in getBinaryOutcomeInfo");
+    }
+
+    // Check for multi-outcome commands (roll affects outcome quality, not just success/failure)
+    // These use multiOutcome() with fixed seeds to sample the range of possible results
+    using namespace net::eagle0::shardok::common;
+    const auto commandType = static_cast<CommandType>(shardokAction->getType());
+
+    switch (commandType) {
+        case END_TURN_COMMAND:
+            // END_TURN has random effects (fire spread, weather changes)
+            return ChanceOutcomeInfo::multiOutcome(5);
+
+        case MELEE_COMMAND:
+        case ARCHERY_COMMAND:
+        case CHARGE_COMMAND:
+        case REDUCE_COMMAND:
+            // Combat/siege commands: OpenEndedPercentile roll affects damage dealt
+            // Use 5 outcomes to sample the roll distribution
+            return ChanceOutcomeInfo::multiOutcome(5);
+
+        case CHALLENGE_DUEL_COMMAND:
+            // Duels have multiple combat rounds with rolls, so outcomes vary significantly
+            return ChanceOutcomeInfo::multiOutcome(5);
+
+        default:
+            // Continue to binary outcome handling below
+            break;
+    }
+
+    const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
+
+    // Get or create the engine for this state
+    std::shared_ptr<ShardokEngine> engine;
+    if (auto cachedEngine = shardokState->getCachedEngine()) {
+        engine = cachedEngine;
+    } else {
+        engine = std::make_shared<ShardokEngine>(
+                gameSettings_,
+                shardokState->getShardokState(),
+                criticalTileCoords_,
+                0,
+                false);
+        // Populate command cache
+        [[maybe_unused]] const auto commands =
+                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
+        shardokState->setCachedEngine(engine);
+    }
+
+    // Get command descriptors
+    const auto descriptors = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
+    const size_t actionIndex = shardokAction->getIndex();
+
+    if (actionIndex >= descriptors->size()) {
+        throw ShardokInternalErrorException("Action index out of range in getBinaryOutcomeInfo");
+    }
+
+    const auto& descriptor = descriptors->at(actionIndex);
+
+    // Get success probability for binary outcome actions
+    if (!descriptor->HasOdds()) {
+        throw ShardokInternalErrorException("Action does not have odds in getBinaryOutcomeInfo");
+    }
+
+    const auto successChancePercentile = descriptor->GetOddsPercentile();
+    const double successProbability = static_cast<double>(successChancePercentile) / 100.0;
+
+    return ChanceOutcomeInfo::binary(successProbability);
+}
+
 void ShardokGameEngine::clearLegalActionsCache() { legalActionsCache_.clear(); }
 
 // Extern-linkage function for testing

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameEngine.hpp

@@ -47,7 +47,8 @@ public:
     // MCTSGameEngine interface implementation
     [[nodiscard]] std::unique_ptr<MCTSGameState> applyAction(
             const MCTSGameState& state,
-            const MCTSAction& action) const override;
+            const MCTSAction& action,
+            double deterministicRoll = -1.0) const override;
 
     void applyActionMutable(std::unique_ptr<MCTSGameState>& state, const MCTSAction& action)
             const override;
@@ -85,6 +86,10 @@ public:
             size_t filteredIndex,
             const MCTSGameState& state) const override;
 
+    [[nodiscard]] BinaryOutcomeInfo getBinaryOutcomeInfo(
+            const MCTSGameState& state,
+            const MCTSAction& action) const override;
+
     // Report transposition table statistics
     void reportCacheStatistics() const;
 

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokGameState.cpp

@@ -64,7 +64,7 @@ double ShardokGameState::score(MCTSPlayerId playerId) const {
     const bool scoreFromDefenderPerspective =
             foundDefender ? requestedPlayerIsDefender : isDefender_;
 
-    // Call score calculator with correct perspective for the requested player
+    // Score the current state directly
     return scoreCalculator_
             ->GuessedStateScore(scoreFromDefenderPerspective, state_, strategy_, castleCoords_);
 }

src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokMCTSFactory.cpp

@@ -72,7 +72,8 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokMCTSFactory::createActionsFromCo
                 cmd->GetPlayerId(),
                 cmd->GetActorUnitId(),
                 cmd->GetTargetRow(),
-                cmd->GetTargetColumn()));
+                cmd->GetTargetColumn(),
+                cmd->HasOdds()));
     }
 
     return actions;

src/main/cpp/net/eagle0/shardok/controller/ShardokGameController.cpp

@@ -73,6 +73,7 @@ vector<shared_ptr<ShardokAIClient>> ShardokGameController::MakeAIClients(
     mctsConfig.maxPlayerFlips = 1;
     mctsConfig.maxSimulationFlips = 1;
     mctsConfig.simulationPolicy = mcts::MCTSSimulationPolicy::WEIGHTED_HEURISTIC;
+
     for (const auto &pi : e->GetPlayerInfos()) {
         if (pi.is_ai()) {
             auto newClient = std::make_shared<ShardokAIClient>(
@@ -80,7 +81,7 @@ vector<shared_ptr<ShardokAIClient>> ShardokGameController::MakeAIClients(
                     pi.is_defender(),
                     e->GetCurrentGameState()->hex_map(),
                     e->GetGameSettings()->GetGetter(),
-                    AIAlgorithmType::MCTS,
+                    AIAlgorithmType::ITERATIVE_DEEPENING,
                     ScoringCalculatorType::MCTS_OPTIMIZED,
                     mctsConfig);
 

src/main/cpp/net/eagle0/shardok/library/AvailableCommandsFactory.cpp

@@ -189,7 +189,7 @@ auto AvailableCommandsFactoryImpl::GetAvailableCommands(
     if (!std::ranges::any_of(commands, [](const CommandSPtr &command) {
             return command->IsRequiredToEndTurn();
         })) {
-        commands.push_back(std::make_shared<EndTurnCommand>(playerId, gameState, settings));
+        commands.push_back(std::make_shared<EndTurnCommand>(playerId, settings));
     }
 
     // If we want follow-ups, make a copy of what this user believes to be the state of the game

src/main/cpp/net/eagle0/shardok/library/FireUtils.cpp

@@ -8,6 +8,8 @@
 
 #include "FireUtils.hpp"
 
+#include <algorithm>
+
 #include "src/main/cpp/net/eagle0/shardok/library/map/TileModifier.hpp"
 
 namespace shardok {
@@ -71,10 +73,13 @@ auto GetFireDamage(
         const double openEndedPercentileRoll1,
         const double openEndedPercentileRoll2) -> CombatDamage {
     double randomSwing = 1.0 + (2 * openEndedPercentileRoll1 - 100.0) * RANDOMNESS_FACTOR / 100.0;
-    const double basicDamage = BASE_FIRE_DAMAGE_PER_TROOP * randomSwing * troops;
+    // Clamp damage to minimum 0 to prevent negative damage from extreme open-ended rolls.
+    // Open-ended percentile rolls can theoretically go as low as -475 (with max roll depth).
+    const double basicDamage = std::max(0.0, BASE_FIRE_DAMAGE_PER_TROOP * randomSwing * troops);
 
     randomSwing = 1.0 + (2 * openEndedPercentileRoll2 - 100.0) * RANDOMNESS_FACTOR / 100.0;
-    const double penetratingDamage = BASE_PENETRATING_FIRE_DAMAGE_PER_TROOP * randomSwing * troops;
+    const double penetratingDamage =
+            std::max(0.0, BASE_PENETRATING_FIRE_DAMAGE_PER_TROOP * randomSwing * troops);
 
     return CombatDamage::Builder()
             .SetFire(basicDamage)

src/main/cpp/net/eagle0/shardok/library/action_factories/MeteorCastActionFactory.cpp

@@ -16,10 +16,9 @@ namespace shardok {
 
 MeteorCastActionFactory::MeteorCastActionFactory(const SettingsGetter &getter) : settings(getter) {}
 
-auto MeteorCastActionFactory::MakeMeteorCastAction(
-        const GameStateW &gameState,
-        const vector<UnitId> &actors) const -> ActionSPtr {
-    return std::make_shared<MeteorCastAction>(gameState, actors, settings);
+auto MeteorCastActionFactory::MakeMeteorCastAction(const vector<UnitId> &actors) const
+        -> ActionSPtr {
+    return std::make_shared<MeteorCastAction>(actors, settings);
 }
 
 }  // namespace shardok

src/main/cpp/net/eagle0/shardok/library/action_factories/MeteorCastActionFactory.hpp

@@ -21,9 +21,7 @@ private:
 public:
     explicit MeteorCastActionFactory(const SettingsGetter &getter);
 
-    [[nodiscard]] auto MakeMeteorCastAction(
-            const GameStateW &gameState,
-            const vector<UnitId> &actors) const -> ActionSPtr;
+    [[nodiscard]] auto MakeMeteorCastAction(const vector<UnitId> &actors) const -> ActionSPtr;
 };
 }  // namespace shardok
 

src/main/cpp/net/eagle0/shardok/library/actions/MeteorCastAction.cpp

@@ -154,12 +154,12 @@ auto MeteorTileDamageAction::InternalExecute(
 }
 
 auto MeteorCastAction::InternalExecute(
-        const GameStateW & /*currentState*/,
+        const GameStateW &currentState,
         const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
     vector<ActionResultProto> allResults{};
-    auto runningGameState = startingGameState;
+    auto runningGameState = currentState;
     for (const UnitId &actorId : actorIds) {
-        const Unit *actorBefore = startingGameState->units()->Get(actorId);
+        const Unit *actorBefore = currentState->units()->Get(actorId);
         runningGameState =
                 PerformOneActorCast(allResults, actorBefore, runningGameState, generator);
     }
@@ -183,15 +183,14 @@ auto MeteorCastAction::PerformOneActorCast(
     results.push_back(mainResult);
 
     const Coords target = actorBefore->attached_hero().profession_info().cast_target();
-    const Unit *possibleOccupant = runningGameState.GetOccupant(target);
-    const Terrain *targetTerrain = GetTerrain(startingGameState->hex_map(), target);
-    if (possibleOccupant) {
-        // Direct damage action
+    if (const Unit *possibleOccupant = runningGameState.GetOccupant(target)) {
+        // Direct damage action - fetch terrain before it might be invalidated
+        const Terrain *targetTerrainForDamage = GetTerrain(runningGameState->hex_map(), target);
         MeteorUnitDamageAction unitDamageAction(
                 settings,
                 possibleOccupant,
                 actorIntelligence,
-                *targetTerrain,
+                *targetTerrainForDamage,
                 MeteorBaseDamage(),
                 1.0);
 
@@ -205,6 +204,8 @@ auto MeteorCastAction::PerformOneActorCast(
                 std::end(directDamageResults));
     }
 
+    // Re-fetch terrain from current state (may have been invalidated by ApplyResults)
+    const Terrain *targetTerrain = GetTerrain(runningGameState->hex_map(), target);
     CoordsSet destroyedBridgeOrIceTiles(runningGameState->hex_map());
     auto weatherPropensity = settings.GetFirePropensityByWeatherConditions(
             runningGameState->weather()->conditions());
@@ -246,15 +247,16 @@ auto MeteorCastAction::PerformOneActorCast(
     const CoordsSet adjacentCoords =
             HexMapUtils::GetAdjacentCoords(runningGameState->hex_map(), target);
     for (const Coords &splashCoords : adjacentCoords) {
-        const auto &splashTerrain = GetTerrain(runningGameState->hex_map(), splashCoords);
-
         const Unit *splashOccupant = runningGameState.GetOccupant(splashCoords);
         if (splashOccupant) {
+            // Fetch terrain before it might be invalidated by ApplyResults
+            const auto *splashTerrainForDamage =
+                    GetTerrain(runningGameState->hex_map(), splashCoords);
             MeteorUnitDamageAction splashUnitDamageAction(
                     settings,
                     splashOccupant,
                     actorIntelligence,
-                    *splashTerrain,
+                    *splashTerrainForDamage,
                     MeteorBaseDamage(),
                     MeteorSplashFactor());
 
@@ -268,6 +270,9 @@ auto MeteorCastAction::PerformOneActorCast(
                     std::end(splashDamageResults));
         }
 
+        // Re-fetch terrain from current state (may have been invalidated by ApplyResults)
+        const auto *splashTerrain = GetTerrain(runningGameState->hex_map(), splashCoords);
+
         PercentileRollOdds splashFireOdds = MakeOdds(
                 MeteorSplashFireBaseChance(),
                 PropensityByTerrain(splashTerrain, settings),

src/main/cpp/net/eagle0/shardok/library/actions/MeteorCastAction.hpp

@@ -34,7 +34,6 @@ private:
             -> vector<ActionResult> override;
 
     const vector<UnitId> actorIds;
-    const GameStateW startingGameState;
     const SettingsGetter settings;
     [[nodiscard]] auto MeteorBaseDamage() const -> double {
         return settings.Backing().meteor_base_damage();
@@ -66,9 +65,8 @@ private:
     }
 
 public:
-    MeteorCastAction(GameStateW gameState, vector<UnitId> actors, const SettingsGetter& settings)
+    MeteorCastAction(vector<UnitId> actors, const SettingsGetter& settings)
         : actorIds(std::move(actors)),
-          startingGameState(std::move(gameState)),
           settings(settings){};
 };
 }  // namespace shardok

src/main/cpp/net/eagle0/shardok/library/command_factories/MoveCommandFactory.cpp

@@ -97,12 +97,11 @@ void MoveCommandFactory::AddAvailableMoveCommands(
     for (const auto &destInfo : destinations) {
         auto cmd = std::make_shared<MoveCommand>(
                 destInfo.pointCost,
-                movingUnit,
+                movingUnit->player_id(),
+                movingUnit->unit_id(),
                 settings,
                 destInfo.targets,
-                units,
                 allyPids,
-                hexMap,
                 destInfo.willUnhide,
                 zocCoords);
 

src/main/cpp/net/eagle0/shardok/library/command_factories/StartFireCommandFactory.cpp

@@ -15,7 +15,13 @@ auto StartFireCommandFactory::MakeStartFireCommand(
         const Coords &coords,
         const Terrain &targetTerrain,
         const PercentileRollOdds &odds) const -> shardok::CommandSPtr {
-    return std::make_shared<StartFireCommand>(settings, unit, coords, targetTerrain, odds);
+    return std::make_shared<StartFireCommand>(
+            settings,
+            unit->player_id(),
+            unit->unit_id(),
+            coords,
+            targetTerrain,
+            odds);
 }
 
 StartFireCommandFactory::StartFireCommandFactory(const shardok::SettingsGetter &getter)

src/main/cpp/net/eagle0/shardok/library/commands/EndTurnCommand.cpp

@@ -38,15 +38,15 @@ auto ApplyAndAdd(
 }
 
 auto EndTurnCommand::InternalExecute(
-        const GameStateW & /*currentState*/,
+        const GameStateW &currentState,
         const std::shared_ptr<RandomGenerator> &generator) const -> vector<ActionResultProto> {
-    if (GetPlayerId() != gameState->current_player()) {
+    if (GetPlayerId() != currentState->current_player()) {
         throw ShardokInternalErrorException(
                 "Trying to end turn for player " + std::to_string(GetPlayerId()) +
-                ", but turn belongs to " + std::to_string(gameState->current_player()));
+                ", but turn belongs to " + std::to_string(currentState->current_player()));
     }
 
-    GameStateW runningGameState = gameState;
+    GameStateW runningGameState = currentState;
     vector<ActionResultProto> allResults{};
 
     vector<UnitId> castingUnitIds{};
@@ -65,7 +65,7 @@ auto EndTurnCommand::InternalExecute(
     };
 
     MeteorCastActionFactory factory(settings);
-    ActionSPtr meteorCastAction = factory.MakeMeteorCastAction(runningGameState, castingUnitIds);
+    ActionSPtr meteorCastAction = factory.MakeMeteorCastAction(castingUnitIds);
 
     auto meteorCastResults = meteorCastAction->Execute(runningGameState, generator);
     runningGameState = ApplyAndAdd(runningGameState, meteorCastResults, allResults, settings);
@@ -109,7 +109,7 @@ auto EndTurnCommand::InternalExecute(
     ActionResultProto endTurnResult{};
     endTurnResult.set_type(ActionType::END_TURN);
     endTurnResult.mutable_player()->set_value(GetPlayerId());
-    endTurnResult.mutable_next_player()->set_value(NextPlayerId(gameState, GetPlayerId()));
+    endTurnResult.mutable_next_player()->set_value(NextPlayerId(currentState, GetPlayerId()));
 
     const auto unitsAtEndOfRoundCount = runningGameState->units()->size();
     for (size_t i = 0; i < unitsAtEndOfRoundCount; i++) {

src/main/cpp/net/eagle0/shardok/library/commands/EndTurnCommand.hpp

@@ -7,7 +7,6 @@
 
 #include <utility>
 
-#include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokCommand.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_factories/MeteorCastActionFactory.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
@@ -21,16 +20,11 @@ protected:
             const std::shared_ptr<RandomGenerator>& generator) const
             -> vector<ActionResult> override;
 
-    const GameStateW& gameState;
     const SettingsGetter settings;
 
 public:
-    EndTurnCommand(
-            const PlayerId pid,
-            const GameStateW& gameState,
-            const SettingsGetter& settingsGetter)
+    EndTurnCommand(const PlayerId pid, const SettingsGetter& settingsGetter)
         : ShardokCommand(pid),
-          gameState(gameState),
           settings(settingsGetter){};
 
     ~EndTurnCommand() override = default;

src/main/cpp/net/eagle0/shardok/library/commands/MoveCommand.cpp

@@ -18,29 +18,31 @@ namespace shardok {
 
 MoveCommand::MoveCommand(
         const ActionPoints pointCost,
-        const Unit* mover,
+        const PlayerId playerId,
+        const UnitId moverId,
         const SettingsGetter& settingsGetter,
         vector<Coords> interimTargets,
-        const Units* units,
         vector<PlayerId> allyPids,
-        const HexMap* inMap,
         const bool unhide,
         const CoordsSet& enemyZocCoords)
-    : ShardokCommand(mover->player_id()),
+    : ShardokCommand(playerId),
       pointCost(pointCost),
-      moverBefore(mover),
+      moverId(moverId),
       settings(settingsGetter),
       interimTargets(std::move(interimTargets)),
-      allUnits(units),
       allyPids(std::move(allyPids)),
-      map(inMap),
       willUnhide(unhide),
       enemyZocCoords(enemyZocCoords) {}
 
 auto shardok::MoveCommand::InternalExecute(
         const GameStateW& currentState,
         const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
+    // Get map and units from currentState
+    const auto* map = currentState->hex_map();
+    const auto* allUnits = currentState->units();
+
     // HANDLE INTERIM TARGETS
+    const auto* moverBefore = allUnits->Get(moverId);
     auto mover = *moverBefore;
     mover.mutate_fortified(false);
     const auto& moverBattalionType = settings.GetBattalionType(mover.battalion().type());
@@ -187,7 +189,7 @@ auto MoveCommand::GetCommandProto() const -> CommandProto {
     proto.set_player(GetPlayerId());
     proto.set_type(net::eagle0::shardok::common::MOVE_COMMAND);
     proto.mutable_action_points()->set_value(pointCost);
-    proto.mutable_actor()->set_value(moverBefore->unit_id());
+    proto.mutable_actor()->set_value(moverId);
     *proto.mutable_target() = ToCoordsProto(interimTargets.back());
     for (const auto& fup : followUpCommandTypes) { proto.add_follow_up_command_types(fup); }
     proto.set_will_unhide(willUnhide);

src/main/cpp/net/eagle0/shardok/library/commands/MoveCommand.hpp

@@ -25,12 +25,10 @@ protected:
             -> vector<ActionResult> override;
 
     const ActionPoints pointCost;
-    const Unit* moverBefore;
+    const UnitId moverId;
     const SettingsGetter settings;
     const vector<Coords> interimTargets;
-    const Units* allUnits;
     const vector<PlayerId> allyPids;
-    const HexMap* map;
     std::unordered_set<CommandType> followUpCommandTypes;
     const bool willUnhide;
     const CoordsSet enemyZocCoords;
@@ -38,12 +36,11 @@ protected:
 public:
     MoveCommand(
             ActionPoints pointCost,
-            const Unit* mover,
+            PlayerId playerId,
+            UnitId moverId,
             const SettingsGetter& settingsGetter,
             vector<Coords> interimTargets,
-            const Units* units,
             vector<PlayerId> allyPids,
-            const HexMap* inMap,
             bool unhide,
             const CoordsSet& enemyZocCoords);
 
@@ -60,7 +57,7 @@ public:
 
     void AddFollowUpCommandTypes(const std::unordered_set<CommandType>& newTypes) override;
 
-    [[nodiscard]] int GetActorUnitId() const override { return moverBefore->unit_id(); }
+    [[nodiscard]] int GetActorUnitId() const override { return moverId; }
     [[nodiscard]] MapIndex GetTargetRow() const override {
         return interimTargets.empty() ? -1 : interimTargets.back().row();
     }

src/main/cpp/net/eagle0/shardok/library/commands/StartFireCommand.cpp

@@ -14,24 +14,30 @@ namespace shardok {
 
 StartFireCommand::StartFireCommand(
         const SettingsGetter& getter,
-        const Unit* actor,
+        const PlayerId playerId,
+        const UnitId actorId,
         Coords target,
         Terrain targetTerrain,
         PercentileRollOdds odds)
-    : ShardokCommand(actor->player_id()),
+    : ShardokCommand(playerId),
       settings(getter),
-      actor(actor),
+      actorId(actorId),
       target(target),
       targetTerrain(std::move(targetTerrain)),
       odds(std::move(odds)){};
 
 auto StartFireCommand::InternalExecute(
-        const GameStateW& /*currentState*/,
+        const GameStateW& currentState,
         const std::shared_ptr<RandomGenerator>& generator) const -> vector<ActionResult> {
-    return ExecuteWithRoll(generator->Percentile());
+    // Use OpenEndedPercentile to match FreezeWaterCommand and how GetSuccessChance calculates
+    // the displayed success probability. With negative totalOdds, only open-ended rolls
+    // can achieve success by rolling below 0.
+    return ExecuteWithRoll(currentState, generator->OpenEndedPercentile());
 }
 
-[[nodiscard]] auto StartFireCommand::ExecuteWithRoll(double roll) const -> vector<ActionResult> {
+[[nodiscard]] auto StartFireCommand::ExecuteWithRoll(const GameStateW& currentState, double roll)
+        const -> vector<ActionResult> {
+    const auto* actor = currentState->units()->Get(actorId);
     if (!actor->has_attached_hero()) { throw ActionRequiresHeroException("start fire"); }
 
     auto actorAfter = *actor;
@@ -70,7 +76,7 @@ auto StartFireCommand::GetCommandProto() const -> CommandProto {
 
     proto.set_player(GetPlayerId());
     proto.set_type(net::eagle0::shardok::common::START_FIRE_COMMAND);
-    proto.mutable_actor()->set_value(actor->unit_id());
+    proto.mutable_actor()->set_value(actorId);
     *proto.mutable_target() = ToCoordsProto(target);
     *proto.mutable_odds() = OddsFilteredForPlayer(odds, GetPlayerId());
 

src/main/cpp/net/eagle0/shardok/library/commands/StartFireCommand.hpp

@@ -10,16 +10,15 @@
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokCommand.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/Coordinates.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
-#include "src/main/flatbuffer/net/eagle0/shardok/storage/unit.hpp"
 
 namespace shardok {
 
 using Terrain = net::eagle0::shardok::storage::fb::Terrain;
-using Unit = net::eagle0::shardok::storage::fb::Unit;
 
 class StartFireCommand : public ShardokCommand {
 private:
-    [[nodiscard]] auto ExecuteWithRoll(double roll) const -> vector<ActionResult>;
+    [[nodiscard]] auto ExecuteWithRoll(const GameStateW& currentState, double roll) const
+            -> vector<ActionResult>;
 
 protected:
     [[nodiscard]] auto InternalExecute(
@@ -28,7 +27,7 @@ protected:
             -> vector<ActionResult> override;
 
     const SettingsGetter settings;
-    const Unit* actor;
+    const UnitId actorId;
     const Coords target;
     const Terrain targetTerrain;
     const PercentileRollOdds odds;
@@ -36,7 +35,8 @@ protected:
 public:
     StartFireCommand(
             const SettingsGetter& getter,
-            const Unit* actor,
+            PlayerId playerId,
+            UnitId actorId,
             Coords target,
             Terrain targetTerrain,
             PercentileRollOdds odds);
@@ -58,7 +58,7 @@ public:
     [[nodiscard]] auto HasOdds() const -> bool override { return true; }
     [[nodiscard]] auto GetOddsPercentile() const -> int32_t override;
 
-    [[nodiscard]] int GetActorUnitId() const override { return actor->unit_id(); }
+    [[nodiscard]] int GetActorUnitId() const override { return actorId; }
     [[nodiscard]] MapIndex GetTargetRow() const override { return target.row(); }
     [[nodiscard]] MapIndex GetTargetColumn() const override { return target.column(); }
 };

src/main/cpp/net/eagle0/shardok/library/unit/Battalion.cpp

@@ -10,6 +10,8 @@
 
 #include <algorithm>
 
+#include "src/main/cpp/net/eagle0/shardok/library/ShardokException.hpp"
+
 namespace shardok {
 
 auto MutatingMaybeSetMorale(Battalion *battalion, double newVal, const BattalionTypeSPtr &type)
@@ -147,6 +149,12 @@ int32_t MutatingInternalTakeDamage(
     int32_t newNumber;
     const int32_t casualties = (int32_t)(takenDamage * baseDeadliness);
 
+    if (casualties < 0) {
+        throw ShardokInternalErrorException(
+                "Negative casualties in MutatingInternalTakeDamage: " + std::to_string(casualties) +
+                " (takenDamage=" + std::to_string(takenDamage) + ")");
+    }
+
     if (battalion->size() > casualties) {
         newNumber = battalion->size() - casualties;
     } else {

src/main/cpp/net/eagle0/shardok/library/view_filters/BUILD.bazel

@@ -104,6 +104,7 @@ cc_library(
         "//src/main/cpp/net/eagle0/shardok/library/fb_helpers:game_state_helpers",
         "//src/main/cpp/net/eagle0/shardok/library/map:coordinates",
         "//src/main/cpp/net/eagle0/shardok/library/settings:game_settings",
+        "//src/main/cpp/net/eagle0/shardok/library/util:hex_cube_utils",
         "//src/main/cpp/net/eagle0/shardok/library/util:hex_map_utils",
         "//src/main/flatbuffer/net/eagle0/shardok/storage:game_state_cc_fbs",
         "//src/main/protobuf/net/eagle0/shardok/api:game_state_view_cc_proto",

src/main/cpp/net/eagle0/shardok/library/view_filters/GameStateGuesser.cpp

@@ -4,11 +4,13 @@
 
 #include "src/main/cpp/net/eagle0/shardok/library/view_filters/GameStateGuesser.hpp"
 
+#include <optional>
 #include <vector>
 
 #include "src/main/cpp/net/eagle0/shardok/library/fb_helpers/GameStateHelpers.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/fb_helpers/HexMapHelpers.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/Coordinates.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/util/HexCubeUtils.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
 
 namespace shardok {
@@ -32,6 +34,86 @@ constexpr int8_t kGuessedHeroStat = 75;
 constexpr int8_t kGuessedBattalionStat = 0;
 constexpr int8_t kGuessedMorale = 50;
 
+// Helper to check if coords are valid within the hex map bounds
+auto CoordsAreValidProto(const HexMapProto &hexMap, const Coords &coords) -> bool {
+    return coords.row() >= 0 && coords.row() < hexMap.row_count() && coords.column() >= 0 &&
+           coords.column() < hexMap.column_count();
+}
+
+// Guess where an enemy mage might be targeting with their meteor.
+// Priority: (1) largest unit of targetPlayerId, (2) any unit of targetPlayerId,
+// (3) any castle not occupied by the caster's player, (4) random valid tile in range.
+auto GuessMeteorTarget(
+        const SettingsGetter &settings,
+        const HexMapProto &hexMap,
+        const Coords &mageLocation,
+        PlayerId targetPlayerId,
+        PlayerId casterPlayerId,
+        const google::protobuf::RepeatedPtrField<UnitViewProto> &units) -> std::optional<Coords> {
+    const int meteorRange = settings.Backing().meteor_range();
+    const Cube mageCube = OffsetToCube(mageLocation);
+
+    // Build a set of valid coords within meteor range
+    std::vector<Coords> validCoordsInRange;
+    for (const Cube &cube : CubesWithinDistance(mageCube, meteorRange)) {
+        Coords coords = CubeToOffset(cube);
+        if (CoordsAreValidProto(hexMap, coords) && coords != mageLocation) {
+            validCoordsInRange.push_back(coords);
+        }
+    }
+
+    if (validCoordsInRange.empty()) { return std::nullopt; }
+
+    // Priority 1 & 2: Find the largest unit of the target player within range
+    const UnitViewProto *largestTargetUnit = nullptr;
+    int largestSize = 0;
+
+    for (const auto &unit : units) {
+        if (unit.player_id() != targetPlayerId) continue;
+
+        Coords unitCoords = FromCoordsProto(unit.location());
+        if (IsUnplaced(unitCoords)) continue;
+
+        // Check if unit is within meteor range
+        const int distance = CubeDistance(mageCube, OffsetToCube(unitCoords));
+        if (distance > meteorRange) continue;
+
+        const int size = unit.battalion().size();
+        if (size > largestSize) {
+            largestSize = size;
+            largestTargetUnit = &unit;
+        }
+    }
+
+    if (largestTargetUnit != nullptr) { return FromCoordsProto(largestTargetUnit->location()); }
+
+    // Priority 3: Find a castle not occupied by the caster's player
+    // Build set of occupied coords by caster's player
+    std::unordered_set<int> casterOccupiedIndices;
+    for (const auto &unit : units) {
+        if (unit.player_id() == casterPlayerId) {
+            Coords loc = FromCoordsProto(unit.location());
+            if (!IsUnplaced(loc)) {
+                casterOccupiedIndices.insert(loc.row() * hexMap.column_count() + loc.column());
+            }
+        }
+    }
+
+    for (const auto &coords : validCoordsInRange) {
+        const int index = coords.row() * hexMap.column_count() + coords.column();
+        if (index < 0 || index >= hexMap.terrain_size()) continue;
+
+        const auto &terrain = hexMap.terrain(index);
+        if (terrain.modifier().has_castle() &&
+            casterOccupiedIndices.find(index) == casterOccupiedIndices.end()) {
+            return coords;
+        }
+    }
+
+    // Priority 4: Return the first valid coord in range (deterministic "random")
+    return validCoordsInRange[0];
+}
+
 auto GuessedUnit(
         const SettingsGetter &settings,
         const UnitViewProto &uv,
@@ -235,6 +317,43 @@ auto GameStateGuesser::GuessedState(
         unitsVec.push_back(reservedSlot);
     }
 
+    // Post-process: guess meteor targets for enemy mages who are casting but whose target is
+    // unknown
+    for (auto &unit : unitsVec) {
+        if (!unit.has_attached_hero()) continue;
+        if (unit.player_id() == pid) continue;  // Only guess for enemy mages
+
+        const auto castState = unit.attached_hero().profession_info().meteor_cast_state();
+        // Mage has targeted or is ready to cast, but we don't know the target
+        if (castState != net::eagle0::shardok::storage::fb::MultiroundMagicState_TARGET &&
+            castState != net::eagle0::shardok::storage::fb::MultiroundMagicState_CAST) {
+            continue;
+        }
+
+        const auto &castTarget = unit.attached_hero().profession_info().cast_target();
+        if (castTarget.row() >= 0 && castTarget.column() >= 0) {
+            continue;  // Already has a valid target
+        }
+
+        // Guess a target: assume mage is targeting us (the viewing player)
+        auto guessedTarget = GuessMeteorTarget(
+                settings,
+                gameStateView.hex_map(),
+                unit.location(),
+                pid,
+                unit.player_id(),
+                gameStateView.units());
+
+        if (guessedTarget.has_value()) {
+            unit.mutable_attached_hero().mutable_profession_info().mutable_cast_target().mutate_row(
+                    guessedTarget->row());
+            unit.mutable_attached_hero()
+                    .mutable_profession_info()
+                    .mutable_cast_target()
+                    .mutate_column(guessedTarget->column());
+        }
+    }
+
     auto unitsOffset = fbb.CreateVectorOfSortedStructs(&unitsVec);
 
     auto chargeeIdsVec = std::vector<UnitId>(

src/main/cpp/net/eagle0/shardok/library/view_filters/GameStateGuesser.hpp

@@ -5,15 +5,20 @@
 #ifndef EAGLE0_GAMESTATEGUESSER_HPP
 #define EAGLE0_GAMESTATEGUESSER_HPP
 
+#include <optional>
 #include <unordered_map>
 
 #include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/map/Coordinates.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
 #include "src/main/protobuf/net/eagle0/shardok/api/game_state_view.pb.h"
+#include "src/main/protobuf/net/eagle0/shardok/common/hex_map.pb.h"
 
 namespace shardok {
 
 using GameStateView = net::eagle0::shardok::api::GameStateView;
+using HexMapProto = net::eagle0::shardok::common::HexMap;
+using UnitViewProto = net::eagle0::shardok::api::UnitView;
 
 struct AverageStats {
     double armament;
@@ -23,6 +28,17 @@ struct AverageStats {
 auto KnownUnitStats(const GameStateView &gameStateView)
         -> std::unordered_map<PlayerId, AverageStats>;
 
+// Guess where an enemy mage might be targeting with their meteor.
+// Priority: (1) largest unit of targetPlayerId, (2) any unit of targetPlayerId,
+// (3) any castle not occupied by the caster's player, (4) first valid tile in range.
+auto GuessMeteorTarget(
+        const SettingsGetter &settings,
+        const HexMapProto &hexMap,
+        const Coords &mageLocation,
+        PlayerId targetPlayerId,
+        PlayerId casterPlayerId,
+        const google::protobuf::RepeatedPtrField<UnitViewProto> &units) -> std::optional<Coords>;
+
 class GameStateGuesser {
 public:
     [[nodiscard]] static auto GuessedState(

src/main/cpp/net/eagle0/shardok/library/view_filters/UnitFilter.cpp

@@ -19,7 +19,13 @@ using net::eagle0::shardok::api::UnitView;
 using net::eagle0::shardok::common::CommandType;
 using std::vector;
 
-auto UnknownUnit(UnitId uid, PlayerId pid, BattalionTypeId bt, int size, bool hidden) -> UnitView;
+auto UnknownUnit(
+        UnitId uid,
+        PlayerId pid,
+        BattalionTypeId bt,
+        int size,
+        bool hidden,
+        int8_t startingPositionIndex) -> UnitView;
 
 [[nodiscard]] auto UnitFilteredForPlayer(
         const SettingsGetter &settings,
@@ -36,7 +42,8 @@ auto UnknownUnit(UnitId uid, PlayerId pid, BattalionTypeId bt, int size, bool hi
                 unit->player_id(),
                 unit->battalion().type(),
                 unit->battalion().size(),
-                true);
+                true,
+                unit->starting_position_index());
     }
     if (IsUnplaced(unit->location()) && !visibleToAsker) {
         return UnknownUnit(
@@ -44,7 +51,8 @@ auto UnknownUnit(UnitId uid, PlayerId pid, BattalionTypeId bt, int size, bool hi
                 unit->player_id(),
                 unit->battalion().type(),
                 unit->battalion().size(),
-                false);
+                false,
+                unit->starting_position_index());
     }
 
     UnitView filtered{};
@@ -142,7 +150,8 @@ auto UnknownUnit(
         const PlayerId pid,
         BattalionTypeId bt,
         const int size,
-        const bool hidden) -> UnitView {
+        const bool hidden,
+        const int8_t startingPositionIndex) -> UnitView {
     UnitView uv;
     uv.set_unit_id(uid);
     uv.set_player_id(pid);
@@ -154,6 +163,11 @@ auto UnknownUnit(
     uv.mutable_battalion()->set_size(size);
     uv.set_hidden(hidden);
 
+    // starting_position_index is public info - defenders know attacker spawn directions
+    if (startingPositionIndex != -1) {
+        uv.mutable_starting_position_index()->set_value(startingPositionIndex);
+    }
+
     uv.set_my_knowledge(0);
 
     return uv;

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/ConnectionHandler/CustomBattleHandler.cs

@@ -101,7 +101,7 @@ public class CustomBattleHandler : MonoBehaviour, IClientConnectionSubscriber {
                 locationName: "Custom Map",
                 month: _gameRequest.Month,
                 players: players,
-                heroNames: _heroNames,
+                heroNameTextIds: _heroNames,
                 heroImages: _heroImages,
                 battalionNames: new Dictionary<int, string> { { 0, "no name" } },
                 rollFetcher: rollPanelController);
@@ -174,7 +174,8 @@ public class CustomBattleHandler : MonoBehaviour, IClientConnectionSubscriber {
         });
     }
 
-    private void Register() { _persistentClientConnection.Subscribe(this); }
+    // Fire-and-forget - subscription is awaited internally and failures are logged
+    private void Register() { _ = _persistentClientConnection.Subscribe(this); }
 
     public GameId? CurrentShardokToken(string shardokGameId) { return _shardokModel.History.Count; }
 
@@ -187,9 +188,14 @@ public class CustomBattleHandler : MonoBehaviour, IClientConnectionSubscriber {
                 case GameUpdate.GameUpdateDetailsOneofCase.ShardokActionResultResponse:
                     foreach (var resp in gameUpdate.ShardokActionResultResponse
                                      .ShardokGameResponses) {
-                        _shardokModel.HandleUpdates(
+                        var updatesOk = _shardokModel.HandleUpdates(
                                 resp.ActionResultViews,
                                 resp.NewResultViewCount);
+                        if (!updatesOk) {
+                            // In custom battle mode, just clear and continue
+                            _shardokModel.History.Clear();
+                            continue;
+                        }
                         _shardokModel.HandleAvailableCommands(resp.AvailableCommands);
                     }
 
@@ -443,4 +449,7 @@ public class CustomBattleHandler : MonoBehaviour, IClientConnectionSubscriber {
             } };
 
     public List<IClientConnectionSubscriber.StreamingTextStatus> StreamingTextStatuses => new();
+
+    // CustomBattleHandler only handles Shardok updates, not Eagle, so no count to update
+    public void UpdateResultCounts(GameUpdate update) {}
 }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/ConnectionHandler/RunningGameItem.cs

@@ -24,9 +24,11 @@ public class RunningGameItem : MonoBehaviour {
         this.gameId = gameId;
 
         gameIdField.text = string.Format("{0:X}", gameId);
+        var textEntry = ClientTextProvider.Provider.GetTextEntry(leader.NameTextId);
+        var leaderName = textEntry != null ? textEntry.Text : "Hero";
         leaderField.text = string.Format(
                 "{0} ({1})",
-                ClientTextProvider.Provider.GetTextEntry(leader.NameTextId).Text,
+                leaderName,
                 DisplayNames.ProfessionNames[leader.Profession]);
     }
 }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/ConnectionHandler/WaitingGameItem.cs

@@ -16,9 +16,11 @@ public class WaitingGameItem : MonoBehaviour {
         gameIdField.text = string.Format("{0:X}", gameId);
         playerCountField.text = playersString;
 
+        var textEntry = ClientTextProvider.Provider.GetTextEntry(leader.NameTextId);
+        var leaderName = textEntry != null ? textEntry.Text : "Hero";
         leaderField.text = string.Format(
                 "{0} ({1})",
-                ClientTextProvider.Provider.GetTextEntry(leader.NameTextId).Text,
+                leaderName,
                 DisplayNames.ProfessionNames[leader.Profession]);
     }
 }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/ChronicleCanvasController.cs

@@ -24,7 +24,7 @@ namespace eagle {
 
         public void OnTextUpdate(string text, bool completed) { SetUp(); }
 
-        public string TextId() { return CurrentEntry.GeneratedTextId; }
+        public string TextId() { return _entries.Count > 0 ? CurrentEntry.GeneratedTextId : null; }
 
         private void OnEnable() {
             ClientTextProvider.Provider.AddListener(this);
@@ -41,11 +41,13 @@ namespace eagle {
         public IList<ChronicleEntry> Entries {
             get => _entries;
             set {
+                var wasEmpty = _entries.Count == 0;
                 _entries = value != null ? value.ToList() : new List<ChronicleEntry>();
 
                 if (_entries.Count == 0) return;
 
-                if (!gameObject.activeSelf) {
+                // Jump to the last entry when first populating, or if not currently viewing
+                if (wasEmpty || !gameObject.activeSelf) {
                     _currentIndex = _entries.Count - 1;
 
                     ScrollToTop();
@@ -60,6 +62,8 @@ namespace eagle {
 
         private const string TitleSplitPattern = @"\n\s*=====\s*\n";
         private void SetUp() {
+            if (_entries.Count == 0) return;
+
             previousButton.interactable = _currentIndex > 0;
             nextButton.interactable = _currentIndex < _entries.Count - 1;
 
@@ -104,8 +108,8 @@ namespace eagle {
             TextEditor editor = (TextEditor)GUIUtility.GetStateObject(
                     typeof(TextEditor),
                     GUIUtility.keyboardControl);
-            editor.text =
-                    ClientTextProvider.Provider.GetTextEntry(CurrentEntry.GeneratedTextId).Text;
+            var textEntry = ClientTextProvider.Provider.GetTextEntry(CurrentEntry.GeneratedTextId);
+            editor.text = textEntry != null ? textEntry.Text : "";
             editor.SelectAll();
             editor.Copy();
         }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/ClientTextProvider.cs

@@ -19,35 +19,86 @@ namespace eagle {
         }
     }
 
+    /// <summary>
+    /// Thread-safe provider for streaming LLM text content.
+    ///
+    /// HandleNewStreamingText can be called from any thread (e.g., gRPC thread).
+    /// ProcessPendingUpdates must be called from the main thread (once per frame)
+    /// to notify listeners of changes.
+    /// </summary>
     public class ClientTextProvider {
         public static readonly ClientTextProvider Provider = new();
 
+        // Lock for thread-safe access to text dictionary
+        // Using a lock instead of ConcurrentDictionary because HandleNewStreamingText
+        // does a read-modify-write that must be atomic
+        private readonly object _lock = new();
         private readonly Dictionary<String, TextEntry> _streamingTexts = new();
 
+        // Track which text IDs have pending updates
+        private readonly HashSet<String> _pendingUpdates = new();
+
+        // Listeners are only added/removed from main thread
         private readonly HashSet<IClientTextListener> _listeners = new();
 
-        public void Clear() { _streamingTexts.Clear(); }
-
-        public Dictionary<String, TextEntry> All() {
-            return new Dictionary<string, TextEntry>(_streamingTexts);
+        public void Clear() {
+            lock (_lock) {
+                _streamingTexts.Clear();
+                _pendingUpdates.Clear();
+            }
         }
 
+        public Dictionary<String, TextEntry> All() {
+            lock (_lock) { return new Dictionary<string, TextEntry>(_streamingTexts); }
+        }
+
+        /// <summary>
+        /// Updates the text dictionary. Thread-safe - can be called from any thread.
+        /// Listeners are NOT notified here; call ProcessPendingUpdates from main thread.
+        /// </summary>
         public String
         HandleNewStreamingText(String llmId, String newText, Int32 knownByteCount, bool completed) {
-            var currentText = "";
-            if (_streamingTexts.TryGetValue(llmId, out var entry)) { currentText = entry.Text; }
+            lock (_lock) {
+                var currentText = "";
+                if (_streamingTexts.TryGetValue(llmId, out var entry)) { currentText = entry.Text; }
 
-            var currentTextBytes = Encoding.UTF8.GetBytes(currentText);
-            var truncatedBytes = currentTextBytes.Take(knownByteCount).ToArray();
+                var currentTextBytes = Encoding.UTF8.GetBytes(currentText);
+                var truncatedBytes = currentTextBytes.Take(knownByteCount).ToArray();
 
-            var updatedText = Encoding.UTF8.GetString(truncatedBytes) + newText;
-            _streamingTexts[llmId] = new TextEntry(updatedText, completed);
+                var updatedText = Encoding.UTF8.GetString(truncatedBytes) + newText;
+                _streamingTexts[llmId] = new TextEntry(updatedText, completed);
 
-            _listeners.Where(x => x.TextId() == llmId)
-                    .ToList()
-                    .ForEach(x => x.OnTextUpdate(updatedText, completed));
+                // Mark this text ID as having pending updates
+                _pendingUpdates.Add(llmId);
 
-            return updatedText;
+                return updatedText;
+            }
+        }
+
+        /// <summary>
+        /// Process pending updates and notify listeners. Must be called from main thread.
+        /// This batches multiple updates to the same text ID into a single notification per frame.
+        /// </summary>
+        public void ProcessPendingUpdates() {
+            List<(String llmId, TextEntry entry)> updates;
+
+            lock (_lock) {
+                if (_pendingUpdates.Count == 0) return;
+
+                // Collect pending updates and their current values
+                updates = _pendingUpdates.Where(id => _streamingTexts.ContainsKey(id))
+                                  .Select(id => (id, _streamingTexts[id]))
+                                  .ToList();
+
+                _pendingUpdates.Clear();
+            }
+
+            // Notify listeners outside the lock to avoid potential deadlocks
+            foreach (var (llmId, textEntry) in updates) {
+                foreach (var listener in _listeners.Where(x => x.TextId() == llmId)) {
+                    listener.OnTextUpdate(textEntry.Text, textEntry.Completed);
+                }
+            }
         }
 
         public TextEntry GetTextEntry(string streamId) {
@@ -57,7 +108,10 @@ namespace eagle {
                 return new TextEntry(text, true);
             }
 
-            return _streamingTexts.GetValueOrDefault(streamId, null);
+            lock (_lock) {
+                _streamingTexts.TryGetValue(streamId, out var entry);
+                return entry;
+            }
         }
 
         public void AddListener(IClientTextListener listener) {
@@ -70,4 +124,4 @@ namespace eagle {
 
         public void RemoveListener(IClientTextListener listener) { _listeners.Remove(listener); }
     }
-}
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/CommandSelectors/DivineCommandSelector.cs

@@ -86,5 +86,17 @@ namespace eagle {
         }
 
         public void ToggleClicked(bool value) { SetCostLabel(); }
+
+        public override void AddTargetedHero(HeroId heroId) {
+            // Find the index of the clicked hero in the divinable heroes list
+            var divinableArray = DivineCommand.DivinableHeroes.ToArray();
+            for (int i = 0; i < divinableArray.Length; i++) {
+                if (divinableArray[i].Hero.Id == heroId) {
+                    _selectedHeroIndex = i;
+                    SetUpUI();
+                    return;
+                }
+            }
+        }
     }
 }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/CommandSelectors/ManagePrisonersCommandSelector.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Net.Eagle0.Eagle.Api;
 using Net.Eagle0.Eagle.Api.Command.Util;
@@ -9,6 +10,7 @@ using UnityEngine.UI;
 
 namespace eagle {
     using ProvinceId = Int32;
+    using HeroId = Int32;
 
     public class ManagePrisonersCommandSelector : CommandSelector {
         // Unity accessors
@@ -36,6 +38,26 @@ namespace eagle {
 
         public override AvailableCommand.SealedValueOneofCase CommandType =>
                 AvailableCommand.SealedValueOneofCase.ManagePrisonerCommand;
+
+        public override List<HeroId> TargetedHeroIds => new() { SelectedHero.Id };
+
+        public override bool HeroIsTargetable(HeroId heroId) {
+            if (_availableCommand == null || _availableCommand.ManagePrisonerCommand == null) {
+                return false;
+            }
+            return ManagePrisonersCommand.Prisoners.Any(p => p.Prisoner.Hero.Id == heroId);
+        }
+
+        public override void AddTargetedHero(HeroId heroId) {
+            // Find the prisoner with this heroId and select it
+            for (int i = 0; i < ManagePrisonersCommand.Prisoners.Count; i++) {
+                if (ManagePrisonersCommand.Prisoners[i].Prisoner.Hero.Id == heroId) {
+                    _selectedHeroIndex = i;
+                    DisplaySelectedHero();
+                    return;
+                }
+            }
+        }
         public override string HeaderString => "Manage Prisoners";
         public override string CommitButtonString =>
                 $"Commit {DisplayNames.PrisonerManagementTypeName(SelectedOption)}";

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/CommandSelectors/OrganizeTroopsCommandSelector.cs

@@ -224,13 +224,14 @@ namespace eagle {
                     tp => tp.TypeId == battalionTypeId && tp.MeetsRequirements);
         }
 
-        private void MaybeActivateRow(EventBasedTable table, BattalionTypeId battalionTypeId) {
+        private void MaybeActivateRow(
+                EventBasedTable table,
+                BattalionTypeId battalionTypeId,
+                int[] extraTroopsByType) {
             var parent = table.gameObject.transform.parent;
 
-            var allowed = TypeIsAllowed(battalionTypeId) ||
-                          extraTroops.Where(tfb => tfb.type == battalionTypeId)
-                                          .Select(tfb => tfb.count)
-                                          .Sum() > 0;
+            var allowed =
+                    TypeIsAllowed(battalionTypeId) || extraTroopsByType[(int)battalionTypeId] > 0;
 
             table.gameObject.GetComponent<OrganizeExtrasTable>().Set(
                     allowed,
@@ -251,12 +252,12 @@ namespace eagle {
             parent.GetComponentInChildren<RawImage>().color = color;
         }
 
-        private void MaybeActivateRows() {
-            MaybeActivateRow(lightInfantryTable, BattalionTypeId.LightInfantry);
-            MaybeActivateRow(heavyInfantryTable, BattalionTypeId.HeavyInfantry);
-            MaybeActivateRow(longbowmenTable, BattalionTypeId.Longbowmen);
-            MaybeActivateRow(dragoonsTable, BattalionTypeId.LightCavalry);
-            MaybeActivateRow(knightsTable, BattalionTypeId.HeavyCavalry);
+        private void MaybeActivateRows(int[] extraTroopsByType) {
+            MaybeActivateRow(lightInfantryTable, BattalionTypeId.LightInfantry, extraTroopsByType);
+            MaybeActivateRow(heavyInfantryTable, BattalionTypeId.HeavyInfantry, extraTroopsByType);
+            MaybeActivateRow(longbowmenTable, BattalionTypeId.Longbowmen, extraTroopsByType);
+            MaybeActivateRow(dragoonsTable, BattalionTypeId.LightCavalry, extraTroopsByType);
+            MaybeActivateRow(knightsTable, BattalionTypeId.HeavyCavalry, extraTroopsByType);
         }
 
         protected override void SetUpUI() {
@@ -330,7 +331,8 @@ namespace eagle {
             } else
                 return false;
 
-            eb.Update(existingBattalions);
+            // Note: We don't call Update() here - the caller (UpdateTable or MaxClickedImpl)
+            // will call it when needed. This avoids redundant recalculations.
             return true;
         }
 
@@ -367,7 +369,6 @@ namespace eagle {
             }
             // Remove original troops
             else {
-                var updated = eb.Update(existingBattalions);
                 var availableToRemove = eb.Original.Size - eb.troopsRemoved;
                 var newlyRemovedCount = Math.Min(KeyModifiedAmount.Amount(), availableToRemove);
 
@@ -464,7 +465,8 @@ namespace eagle {
             } else
                 return false;
 
-            newB.Update(existingBattalions);
+            // Note: We don't call Update() here - the caller (UpdateTable or MaxClickedImpl)
+            // will call it when needed. This avoids redundant recalculations.
             return true;
         }
 
@@ -639,8 +641,6 @@ namespace eagle {
         }
 
         public void UpdateTable() {
-            battalionsTable.RowCount = 0;
-
             maxAllButton.gameObject.SetActive(false);
             mergeButton.gameObject.SetActive(false);
 
@@ -653,23 +653,30 @@ namespace eagle {
                         { BattalionTypeId.Longbowmen, 0 }
                     };
 
-            maxAllButton.gameObject.SetActive(false);
-            foreach (var eb in existingBattalions) {
-                if (eb.dismissed) continue;
+            // Cache extra troop counts by type to avoid repeated LINQ queries
+            // Use array indexed by enum value for O(1) access without hashing
+            var battalionTypeCount = Enum.GetValues(typeof(BattalionTypeId)).Length;
+            var extraTroopsByType = new int[battalionTypeCount];
+            foreach (var et in extraTroops) { extraTroopsByType[(int)et.type] += et.count; }
 
-                var newRow = battalionsTable.AddRowWithComponent<OrganizeTroopsTableRow>();
+            // Count total rows needed and set RowCount to reuse existing rows
+            var activeExisting = existingBattalions.Where(eb => !eb.dismissed).ToList();
+            var totalRows = activeExisting.Count + newBattalions.Count;
+            battalionsTable.RowCount = totalRows;
+
+            int rowIndex = 0;
+            foreach (var eb in activeExisting) {
+                var row = battalionsTable.ComponentAt<OrganizeTroopsTableRow>(rowIndex);
                 eb.Update(existingBattalions);
-                newRow.BattalionInfo = eb;
+                row.BattalionInfo = eb;
 
-                newRow.PlusButtonClickedCallback = () => PlusClicked(eb);
-                newRow.MinusButtonClickedCallback = () => MinusClicked(eb);
-                newRow.MaxButtonClickedCallback = () => MaxClicked(eb);
-                newRow.DismissButtonClickedCallback = () => DismissClicked(eb);
+                row.PlusButtonClickedCallback = () => PlusClicked(eb);
+                row.MinusButtonClickedCallback = () => MinusClicked(eb);
+                row.MaxButtonClickedCallback = () => MaxClicked(eb);
+                row.DismissButtonClickedCallback = () => DismissClicked(eb);
 
-                bool canAugment =
-                        TypeIsAllowed(eb.TypeId) ||
-                        extraTroops.Where(tfb => tfb.type == eb.TypeId).Sum(tfb => tfb.count) > 0;
-                newRow.CanAugment = canAugment;
+                bool canAugment = TypeIsAllowed(eb.TypeId) || extraTroopsByType[(int)eb.TypeId] > 0;
+                row.CanAugment = canAugment;
 
                 if (eb.Count < eb.Capacity) {
                     // Enable MaxAll button if we could add new troops to this battalion type
@@ -681,18 +688,19 @@ namespace eagle {
                         mergeButton.gameObject.SetActive(true);
                     }
                 }
+                rowIndex++;
             }
 
             foreach (var newB in newBattalions) {
-                var newRow = battalionsTable.AddRowWithComponent<OrganizeTroopsTableRow>();
+                var row = battalionsTable.ComponentAt<OrganizeTroopsTableRow>(rowIndex);
 
                 newB.Update(existingBattalions);
-                newRow.BattalionInfo = newB;
+                row.BattalionInfo = newB;
 
-                newRow.PlusButtonClickedCallback = () => PlusClicked(newB);
-                newRow.MinusButtonClickedCallback = () => MinusClicked(newB);
-                newRow.MaxButtonClickedCallback = () => MaxClicked(newB);
-                newRow.DismissButtonClickedCallback = () => DismissClicked(newB);
+                row.PlusButtonClickedCallback = () => PlusClicked(newB);
+                row.MinusButtonClickedCallback = () => MinusClicked(newB);
+                row.MaxButtonClickedCallback = () => MaxClicked(newB);
+                row.DismissButtonClickedCallback = () => DismissClicked(newB);
 
                 if (newB.Count < newB.Capacity) {
                     maxAllButton.gameObject.SetActive(true);
@@ -701,6 +709,7 @@ namespace eagle {
                         mergeButton.gameObject.SetActive(true);
                     }
                 }
+                rowIndex++;
             }
 
             lightInfantryTable.RowCount = 0;
@@ -739,15 +748,18 @@ namespace eagle {
             if (!sufficient) { _disabledReason = "Not enough gold"; }
 
             // Also check that something has changed
+            // Check newBattalion fields directly instead of calling Update() which is expensive
             bool somethingChanged =
-                    (newBattalions.Exists(b => b.Update(existingBattalions).Size > 0) ||
+                    (newBattalions.Exists(
+                             b => b.newBattalion.NewTroops > 0 ||
+                                  b.newBattalion.TroopsFromOtherBattalion.Count > 0) ||
                      existingBattalions.Exists(eb => eb.changed != null || eb.troopsRemoved > 0));
             if (!somethingChanged) { _disabledReason = "No battalions have changed"; }
 
             _enableCommit = sufficient && somethingChanged;
             resetAllButton.gameObject.SetActive(somethingChanged);
 
-            MaybeActivateRows();
+            MaybeActivateRows(extraTroopsByType);
         }
 
         public override AvailableCommand.SealedValueOneofCase CommandType =>

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/CommandSelectors/RecruitHeroesCommandSelector.cs

@@ -30,10 +30,26 @@ namespace eagle {
         public override string HeaderString => "Recruit Heroes";
         public override string CommitButtonString => "Commit Recruit";
 
-        public override bool HeroIsTargetable(HeroId heroId) =>
-                RecruitHeroesCommand.AvailableHeroes.Any(euh => euh.Hero.Id == heroId);
+        public override bool HeroIsTargetable(HeroId heroId) {
+            if (_availableCommand == null || _availableCommand.RecruitHeroesCommand == null) {
+                return false;
+            }
+            return RecruitHeroesCommand.AvailableHeroes.Any(euh => euh.Hero.Id == heroId);
+        }
         public override List<HeroId> TargetedHeroIds => new List<HeroId> { SelectedHero.Hero.Id };
 
+        public override void AddTargetedHero(HeroId heroId) {
+            // Find the hero in available heroes and select it
+            var availableHeroes = RecruitHeroesCommand.AvailableHeroes.ToList();
+            for (int i = 0; i < availableHeroes.Count; i++) {
+                if (availableHeroes[i].Hero.Id == heroId) {
+                    _selectedHeroIndex = i;
+                    DisplayHero();
+                    return;
+                }
+            }
+        }
+
         void DisplayHero() {
             heroDetails.SetHero(SelectedHero.Hero, _model);
             statusText.text = DisplayNames.UnaffiliatedHeroStatus(SelectedHero.Type);

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/ConnectionCircuitBreaker.cs

@@ -0,0 +1,151 @@
+using System;
+using common;
+
+namespace eagle {
+    /// <summary>
+    /// Circuit breaker pattern for connection failures.
+    /// Prevents cascading failures by blocking connection attempts during server outages.
+    /// </summary>
+    public class ConnectionCircuitBreaker {
+        public enum State {
+            Closed,   // Normal operation, allowing connections
+            Open,     // Too many failures, blocking connections
+            HalfOpen  // Testing if service recovered
+        }
+
+        private const int FailureThreshold = 5;          // Open after 5 failures
+        private const double OpenTimeoutSeconds = 60.0;  // Wait 60s before test
+        private const double SuccessResetThreshold = 3;  // Close after 3 successes
+
+        private State _state = State.Closed;
+        private int _failureCount = 0;
+        private int _successCount = 0;
+        private DateTime? _openedAt = null;
+
+        private readonly Logger _logger = Logger.GetLogger("ConnectionLogger");
+
+        public State CurrentState {
+            get {
+                lock (this) { return _state; }
+            }
+        }
+
+        public DateTime? NextTestAttempt {
+            get {
+                lock (this) {
+                    if (_state == State.Open && _openedAt.HasValue) {
+                        return _openedAt.Value.AddSeconds(OpenTimeoutSeconds);
+                    }
+                    return null;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check if a connection attempt should be allowed.
+        /// </summary>
+        public bool ShouldAttemptConnection() {
+            lock (this) {
+                switch (_state) {
+                    case State.Closed: return true;  // Normal operation
+
+                    case State.HalfOpen: return true;  // Allow test attempt
+
+                    case State.Open:
+                        // Check if timeout has elapsed
+                        if (_openedAt.HasValue) {
+                            var elapsed = (DateTime.UtcNow - _openedAt.Value).TotalSeconds;
+                            if (elapsed >= OpenTimeoutSeconds) {
+                                // Transition to half-open for test
+                                _state = State.HalfOpen;
+                                _logger.LogLine(
+                                        $"[CIRCUIT] OPEN → HALF_OPEN (testing after {elapsed:F1}s)");
+                                return true;
+                            }
+                        }
+                        return false;  // Still in open state, block connection
+                }
+
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Record a successful connection.
+        /// </summary>
+        public void RecordSuccess() {
+            lock (this) {
+                if (_state == State.HalfOpen) {
+                    // Test succeeded, close circuit
+                    _state = State.Closed;
+                    _failureCount = 0;
+                    _successCount = 0;
+                    _openedAt = null;
+                    _logger.LogLine($"[CIRCUIT] HALF_OPEN → CLOSED (test succeeded)");
+                } else if (_state == State.Closed) {
+                    // Normal success, increment counter
+                    _successCount++;
+                    if (_failureCount > 0) {
+                        _failureCount = Math.Max(0, _failureCount - 1);  // Decay failures
+                    }
+                    if (_failureCount == 0 && _successCount >= SuccessResetThreshold) {
+                        _successCount = 0;  // Reset success counter
+                        _logger.LogLine($"[CIRCUIT] CLOSED (connection stable)");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Record a connection failure.
+        /// </summary>
+        public void RecordFailure() {
+            lock (this) {
+                _failureCount++;
+                _successCount = 0;  // Reset success counter on any failure
+
+                if (_state == State.HalfOpen) {
+                    // Test attempt failed, reopen circuit
+                    _state = State.Open;
+                    _openedAt = DateTime.UtcNow;
+                    _logger.LogLine(
+                            $"[CIRCUIT] HALF_OPEN → OPEN (test failed, failures={_failureCount})");
+                } else if (_failureCount >= FailureThreshold && _state == State.Closed) {
+                    // Too many failures, open circuit
+                    _state = State.Open;
+                    _openedAt = DateTime.UtcNow;
+                    _logger.LogLine(
+                            $"[CIRCUIT] CLOSED → OPEN (failures={_failureCount}, threshold={FailureThreshold})");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get human-readable status for UI display.
+        /// </summary>
+        public string GetStatusMessage() {
+            lock (this) {
+                switch (_state) {
+                    case State.Closed:
+                        return _failureCount > 0
+                                       ? $"Connection recovering ({_failureCount} recent failures)"
+                                       : "Connection healthy";
+
+                    case State.HalfOpen: return "Testing connection...";
+
+                    case State.Open:
+                        if (_openedAt.HasValue) {
+                            var timeUntilTest = OpenTimeoutSeconds -
+                                                (DateTime.UtcNow - _openedAt.Value).TotalSeconds;
+                            if (timeUntilTest > 0) {
+                                return $"Server unavailable. Retrying in {(int)timeUntilTest}s";
+                            }
+                        }
+                        return "Server unavailable. Testing...";
+
+                    default: return "Unknown state";
+                }
+            }
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/ConnectionCircuitBreaker.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 1c49d026769d746aeac2ceff7c1f5dc4

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/ConnectionStatusUI.cs

@@ -0,0 +1,149 @@
+using System;
+using Net.Eagle0.Eagle.Api;
+using TMPro;
+using UnityEngine;
+
+namespace eagle {
+    /// <summary>
+    /// Provides game state information for the connection status UI.
+    /// Implement this interface to show game-specific status when connected.
+    /// </summary>
+    public interface IGameStateProvider {
+        /// <summary>Server-reported game status. Null if no status received yet.</summary>
+        ServerGameStatus ServerStatus { get; }
+
+        /// <summary>True if a command was submitted and we're awaiting response (for >
+        /// 500ms).</summary>
+        bool IsProcessingCommand { get; }
+    }
+
+    /// <summary>
+    /// Simple UI component to display connection status and reconnection countdown.
+    /// Attach to a TextMeshProUGUI component to display status.
+    /// </summary>
+    public class ConnectionStatusUI : MonoBehaviour {
+        private TextMeshProUGUI _textComponent;
+        private PersistentClientConnection _connection;
+        private IGameStateProvider _gameStateProvider;
+
+        // Update interval in seconds
+        private const float UpdateInterval = 0.5f;
+        private float _timeSinceLastUpdate = 0f;
+
+        void Start() {
+            _textComponent = GetComponent<TextMeshProUGUI>();
+            if (_textComponent == null) {
+                Debug.LogError(
+                        "ConnectionStatusUI must be attached to a TextMeshProUGUI component");
+                enabled = false;
+                return;
+            }
+
+            // Find the PersistentClientConnection - this assumes it's accessible
+            // In production, this would need proper dependency injection
+            // For now, the connection will be set externally or found via another method
+        }
+
+        /// <summary>
+        /// Set the connection to monitor. Call this after creating the connection.
+        /// </summary>
+        public void SetConnection(PersistentClientConnection connection) {
+            _connection = connection;
+        }
+
+        /// <summary>
+        /// Set the game state provider for showing game-specific status.
+        /// Call this when entering a game, clear it when leaving.
+        /// </summary>
+        public void SetGameStateProvider(IGameStateProvider provider) {
+            _gameStateProvider = provider;
+        }
+
+        void Update() {
+            if (_connection == null || _textComponent == null) { return; }
+
+            _timeSinceLastUpdate += Time.deltaTime;
+            if (_timeSinceLastUpdate < UpdateInterval) { return; }
+
+            _timeSinceLastUpdate = 0f;
+            UpdateDisplay();
+        }
+
+        private void UpdateDisplay() {
+            // Check circuit breaker state first - it takes precedence
+            var circuitState = _connection.CircuitBreaker.CurrentState;
+            if (circuitState == ConnectionCircuitBreaker.State.Open) {
+                var nextTest = _connection.CircuitBreaker.NextTestAttempt;
+                if (nextTest.HasValue) {
+                    var timeUntilTest = nextTest.Value - DateTime.UtcNow;
+                    if (timeUntilTest.TotalSeconds > 0) {
+                        int seconds = (int)Math.Ceiling(timeUntilTest.TotalSeconds);
+                        _textComponent.text =
+                                $"<color=red>●</color> Server down. Retry in {seconds}s";
+                        return;
+                    }
+                }
+                _textComponent.text = "<color=red>●</color> Server unavailable";
+                return;
+            } else if (circuitState == ConnectionCircuitBreaker.State.HalfOpen) {
+                _textComponent.text = "<color=yellow>●</color> Testing connection...";
+                return;
+            }
+
+            // Normal connection state display
+            var state = _connection.CurrentState;
+            var nextAttempt = _connection.NextReconnectAttempt;
+
+            string statusText = state switch {
+                ConnectionState.Connected => GetConnectedStatusText(),
+                ConnectionState.Connecting => "<color=yellow>●</color> Connecting...",
+                ConnectionState.Disconnected => "<color=red>●</color> Disconnected",
+                ConnectionState.Reconnecting => GetReconnectingText(nextAttempt),
+                ConnectionState.SubscriptionPending => "<color=yellow>●</color> Subscribing...",
+                _ => "<color=gray>●</color> Unknown"
+            };
+
+            _textComponent.text = statusText;
+        }
+
+        private string GetConnectedStatusText() {
+            // If no game state provider, just show "Connected"
+            if (_gameStateProvider == null) { return "<color=green>●</color> Connected"; }
+
+            // Processing takes priority (client knows it submitted a command)
+            if (_gameStateProvider.IsProcessingCommand) {
+                return "<color=green>●</color> Processing...";
+            }
+
+            // Use server-reported status
+            var serverStatus = _gameStateProvider.ServerStatus;
+            if (serverStatus == null) {
+                // No server status yet - waiting for first response
+                return "<color=green>●</color> Connected";
+            }
+
+            return serverStatus.Status switch {
+                ServerGameStatus.Types.Status.YourTurn => "<color=green>●</color> Your turn",
+                ServerGameStatus.Types.Status.WaitingForPlayers =>
+                        "<color=green>●</color> Waiting for other players",
+                ServerGameStatus.Types.Status.GeneratingText =>
+                        "<color=green>●</color> Generating...",
+                ServerGameStatus.Types.Status.ProcessingAction =>
+                        "<color=green>●</color> Processing...",
+                _ => "<color=green>●</color> Connected"
+            };
+        }
+
+        private string GetReconnectingText(DateTime? nextAttempt) {
+            if (!nextAttempt.HasValue) { return "<color=yellow>●</color> Reconnecting..."; }
+
+            var timeUntilRetry = nextAttempt.Value - DateTime.UtcNow;
+            if (timeUntilRetry.TotalSeconds <= 0) {
+                return "<color=yellow>●</color> Reconnecting...";
+            }
+
+            int secondsRemaining = (int)Math.Ceiling(timeUntilRetry.TotalSeconds);
+            return $"<color=orange>●</color> Retry in {secondsRemaining}s";
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/ConnectionStatusUI.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 727a520b2deac4a28ae9c6a00e54c2e7

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/EagleGameController.cs

@@ -24,8 +24,8 @@ namespace eagle {
         public RollPanelController rollPanelController;
 
         public TextMeshProUGUI roundStatusLabel;
-        public TextMeshProUGUI widthLabel;
-        public TextMeshProUGUI heightLabel;
+        public TextMeshProUGUI connectionStatusLabel;
+        private bool _connectionStatusUIInitialized = false;
 
         public GameObject alwaysOnLeftColumn;
         public GameObject factionsAndMovingArmiesRow;
@@ -110,8 +110,15 @@ namespace eagle {
 
             if (newWidth == _lastWidth && newHeight == _lastHeight) { return; }
 
-            widthLabel.text = newWidth.ToString();
-            heightLabel.text = newHeight.ToString();
+            // Initialize ConnectionStatusUI component once when connection is available
+            if (!_connectionStatusUIInitialized &&
+                errorHandler.PersistentClientConnection != null) {
+                var statusUI = connectionStatusLabel.GetComponent<ConnectionStatusUI>();
+                if (statusUI != null) {
+                    statusUI.SetConnection(errorHandler.PersistentClientConnection);
+                    _connectionStatusUIInitialized = true;
+                }
+            }
 
             _lastWidth = newWidth;
             _lastHeight = newHeight;
@@ -158,6 +165,10 @@ namespace eagle {
             Model = null;
             chronicleCanvasController.Entries = new List<ChronicleEntry>();
             SetMusic();
+
+            // Clear game state provider when leaving game
+            var statusUI = connectionStatusLabel.GetComponent<ConnectionStatusUI>();
+            if (statusUI != null) { statusUI.SetGameStateProvider(null); }
         }
 
         void MapControllerChangedTarget(List<ProvinceId> newTarget) {
@@ -177,6 +188,9 @@ namespace eagle {
         }
 
         void Update() {
+            // Process batched streaming text updates (thread-safe, once per frame)
+            ClientTextProvider.Provider.ProcessPendingUpdates();
+
             ArrangeLayout();
             if (_newModel != null) { SwapModel(); }
 
@@ -218,7 +232,8 @@ namespace eagle {
             if (pause) {
                 ModelUpdater.StopListeningForUpdates();
             } else {
-                ModelUpdater.StartListeningForUpdates();
+                // Fire-and-forget - subscription is awaited internally and failures are logged
+                _ = ModelUpdater.StartListeningForUpdates();
             }
         }
 
@@ -255,7 +270,13 @@ namespace eagle {
 
             ModelUpdater.ErrorHandler = errorHandler;
 
-            MainQueue.Q.EnqueueForNextUpdate(() => { ModelUpdater.StartListeningForUpdates(); });
+            // Set up game state provider for connection status UI
+            var statusUI = connectionStatusLabel.GetComponent<ConnectionStatusUI>();
+            if (statusUI != null) { statusUI.SetGameStateProvider(ModelUpdater); }
+
+            // Fire-and-forget - subscription is awaited internally and failures are logged
+            MainQueue.Q.EnqueueForNextUpdate(
+                    () => { _ = ModelUpdater.StartListeningForUpdates(); });
 
 #if UNITY_EDITOR
             EditorApplication.playModeStateChanged += (state) => OnPlayModeStateChanged(state);
@@ -294,6 +315,7 @@ namespace eagle {
             movingArmiesTableController.UpdateTables();
             factionsTableController.UpdateTables();
             heroesAndBattalionsPanelController.UpdateTables();
+            freeHeroesTableController.UpdateUnaffiliatedHeroSelections();
         }
 
         private void UpdateButtons() {
@@ -649,7 +671,9 @@ namespace eagle {
             var shardokModel = Model.ShardokGameModels[selectedModel.ShardokGameId];
 
             shardokCanvas.gameObject.SetActive(true);
-            shardokCanvas.GetComponent<ShardokGameController>().SetUpGame(shardokModel);
+            var shardokController = shardokCanvas.GetComponent<ShardokGameController>();
+            shardokController.SetUpGame(shardokModel);
+            shardokController.SetConnection(errorHandler.PersistentClientConnection);
             gameObject.SetActive(false);
         }
 

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/EagleGameModel.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -61,7 +62,7 @@ namespace eagle {
         RollFetcher RollFetcher { get; }
     }
 
-    public class GameModelUpdater : IClientConnectionSubscriber {
+    public class GameModelUpdater : IClientConnectionSubscriber, IGameStateProvider {
         private FactionId? PlayerId => _currentModel.PlayerId;
         public Int64? CurrentEagleToken => _currentModel.CommandToken;
         public Int64? CurrentShardokToken(string shardokGameId) {
@@ -94,13 +95,25 @@ namespace eagle {
 
         public long GameId { get; }
 
-        public int LastUnfilteredResultCount => _lastUnfilteredResultCount;
+        public int LastUnfilteredResultCount {
+            get {
+                lock (_resultCountLock) { return _lastUnfilteredResultCount; }
+            }
+        }
 
         public List<IClientConnectionSubscriber.ShardokViewStatus> ShardokViewStatuses =>
                 _currentModel.ShardokGameModels
-                        .Select(sgm => new IClientConnectionSubscriber.ShardokViewStatus {
-                            shardokGameId = sgm.Key,
-                            filteredResultCount = sgm.Value.History.Count()
+                        .Select(sgm => {
+                            var needsResync = _shardokNeedsResync.GetValueOrDefault(sgm.Key, false);
+                            // Use thread-safe count from gRPC thread updates, fall back to model
+                            var count = _shardokResultCounts.GetValueOrDefault(
+                                    sgm.Key,
+                                    sgm.Value.History.Count());
+                            return new IClientConnectionSubscriber.ShardokViewStatus {
+                                shardokGameId = sgm.Key,
+                                filteredResultCount = needsResync ? 0 : count,
+                                requestFullResync = needsResync
+                            };
                         })
                         .ToList();
 
@@ -117,10 +130,27 @@ namespace eagle {
 
         public ErrorHandler ErrorHandler;
 
+        // Thread-safe: updated from gRPC thread via UpdateResultCounts, read from main thread
         private int _lastUnfilteredResultCount = 0;
+        private readonly object _resultCountLock = new();
 
         private readonly Logger _connectionLogger = Logger.GetLogger("ConnectionLogger");
 
+        // Track when a command was submitted for "Processing..." display
+        // Only show "Processing..." if command has been pending for > 500ms
+        private DateTime? _commandSubmittedTime;
+        private const double ProcessingDisplayDelayMs = 500.0;
+
+        // Track which Shardok games need full state resync after connection drop
+        // Thread-safe: accessed from both connection thread and Unity main thread
+        private readonly ConcurrentDictionary<string, bool> _shardokNeedsResync =
+                new ConcurrentDictionary<string, bool>();
+
+        // Thread-safe Shardok result counts: updated from gRPC thread via UpdateResultCounts
+        // Used by ShardokViewStatuses to report accurate counts even when MainQueue is blocked
+        private readonly ConcurrentDictionary<string, int> _shardokResultCounts =
+                new ConcurrentDictionary<string, int>();
+
         private readonly RollFetcher _rollFetcher;
 
         // State synced with server
@@ -219,8 +249,16 @@ namespace eagle {
         }
 
         private ShardokGameModel MakeGameModel(ShardokGameId shardokGameId) {
-            var battleView =
-                    _currentModel.ShardokBattles.First(b => b.ShardokGameId == shardokGameId);
+            var battleView = _currentModel.ShardokBattles.FirstOrDefault(
+                    b => b.ShardokGameId == shardokGameId);
+
+            if (battleView == null) {
+                // Battle was removed (e.g., it ended) before we could create the model.
+                // This is expected when Eagle's RemovedBattleIds update arrives before a
+                // pending Shardok update - the UI already shows "Back to Eagle" via
+                // MarkBattleEnded(), so we just skip this stale update.
+                return null;
+            }
 
             PlayerId playerId = battleView.MyPlayerId ?? -1;
 
@@ -247,10 +285,9 @@ namespace eagle {
                     locationName: _currentModel.Provinces[defenderProvince].Name,
                     month: _currentModel.CurrentDate.Month,
                     players: players,
-                    heroNames: _currentModel.Heroes.ToDictionary(
+                    heroNameTextIds: _currentModel.Heroes.ToDictionary(
                             kv => kv.Key,
-                            kv => ClientTextProvider.Provider.GetTextEntry(kv.Value.NameTextId)
-                                          .Text),
+                            kv => kv.Value.NameTextId),
                     heroImages: _currentModel.Heroes.ToDictionary(
                             kv => kv.Key,
                             kv => kv.Value.ImagePath),
@@ -267,6 +304,14 @@ namespace eagle {
 
             switch (updateItem.GameUpdateDetailsCase) {
                 case GameUpdate.GameUpdateDetailsOneofCase.ActionResultResponse:
+                    // Clear processing state - we received a response from the server
+                    _commandSubmittedTime = null;
+
+                    // Store server-reported game status for UI
+                    if (updateItem.ActionResultResponse.ServerGameStatus != null) {
+                        ServerStatus = updateItem.ActionResultResponse.ServerGameStatus;
+                    }
+
                     _lastUnfilteredResultCount =
                             updateItem.ActionResultResponse.UnfilteredResultCountAfter;
                     if (updateItem.ActionResultResponse.ActionResultViews.Any() ||
@@ -290,18 +335,41 @@ namespace eagle {
                                     out var shardokGameModel)) {
                             shardokGameModel =
                                     MakeGameModel(shardokGameId: oneResponse.ShardokGameId);
+
+                            // Battle may have ended before we could create the model - remove
+                            // any stale reference and skip this update
+                            if (shardokGameModel == null) {
+                                _currentModel.ShardokGameModels.Remove(oneResponse.ShardokGameId);
+                                _shardokResultCounts.TryRemove(oneResponse.ShardokGameId, out _);
+                                continue;
+                            }
                         }
 
-                        shardokGameModel.HandleUpdates(
+                        var updatesOk = shardokGameModel.HandleUpdates(
                                 oneResponse.ActionResultViews,
                                 oneResponse.NewResultViewCount);
+
+                        if (!updatesOk) {
+                            // Missing results - mark for resync and clear history
+                            MarkShardokForResync(oneResponse.ShardokGameId);
+                            shardokGameModel.History.Clear();
+                            continue;
+                        }
+
                         shardokGameModel.HandleAvailableCommands(oneResponse.AvailableCommands);
 
+                        // Clear resync flag after successfully receiving updates
+                        ClearShardokResyncFlag(oneResponse.ShardokGameId);
+
                         if (shardokGameModel.GameStatus.State ==
                                     GameStatus.Types.State.GameRunning ||
                             shardokGameModel.GameStatus.State == GameStatus.Types.State.SetUp) {
                             _currentModel.ShardokGameModels[oneResponse.ShardokGameId] =
                                     shardokGameModel;
+                        } else {
+                            // Game ended - remove from active models so UI knows battle is over
+                            _currentModel.ShardokGameModels.Remove(oneResponse.ShardokGameId);
+                            _shardokResultCounts.TryRemove(oneResponse.ShardokGameId, out _);
                         }
                     }
                     if (UpdateAction != null) UpdateAction.Invoke(_currentModel);
@@ -322,10 +390,67 @@ namespace eagle {
             }
         }
 
-        public void StartListeningForUpdates() { PersistentConnection.Subscribe(this); }
+        /// <summary>
+        /// Update result counts immediately when an update is received from the server.
+        /// Called from the gRPC thread BEFORE enqueueing to MainQueue, to ensure
+        /// reconnects use accurate counts even when MainQueue is blocked (e.g., backgrounded).
+        /// </summary>
+        public void UpdateResultCounts(GameUpdate update) {
+            switch (update.GameUpdateDetailsCase) {
+                case GameUpdate.GameUpdateDetailsOneofCase.ActionResultResponse:
+                    lock (_resultCountLock) {
+                        _lastUnfilteredResultCount =
+                                update.ActionResultResponse.UnfilteredResultCountAfter;
+                    }
+                    break;
+
+                case GameUpdate.GameUpdateDetailsOneofCase.ShardokActionResultResponse:
+                    foreach (var response in update.ShardokActionResultResponse
+                                     .ShardokGameResponses) {
+                        _shardokResultCounts[response.ShardokGameId] = response.NewResultViewCount;
+                    }
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Subscribe to game updates. Returns true if subscription was acknowledged by server.
+        /// </summary>
+        public async Task<bool> StartListeningForUpdates() {
+            return await PersistentConnection.Subscribe(this);
+        }
 
         public void StopListeningForUpdates() { PersistentConnection.Unsubscribe(this); }
 
+        /// <summary>
+        /// Mark a Shardok game for full state resync on next connection.
+        /// Used after connection drops to ensure state consistency.
+        /// </summary>
+        public void MarkShardokForResync(string shardokGameId) {
+            _shardokNeedsResync[shardokGameId] = true;
+            _connectionLogger.LogLine(
+                    $"[RESYNC] Marked Shardok game {shardokGameId} for full state resync");
+        }
+
+        /// <summary>
+        /// Clear resync flag after successfully receiving full state.
+        /// </summary>
+        public void ClearShardokResyncFlag(string shardokGameId) {
+            if (_shardokNeedsResync.TryRemove(shardokGameId, out _)) {
+                _connectionLogger.LogLine(
+                        $"[RESYNC] Cleared resync flag for Shardok game {shardokGameId}");
+            }
+        }
+
+        /// <summary>
+        /// Mark all active Shardok games for resync (called on disconnect).
+        /// </summary>
+        public void MarkAllShardokForResync() {
+            foreach (var shardokGameId in _currentModel.ShardokGameModels.Keys) {
+                MarkShardokForResync(shardokGameId);
+            }
+        }
+
         public Task PostCommand(ProvinceId provinceId, SelectedCommand command) {
             _connectionLogger.LogLine(
                     $"Posting command with token {_currentModel.CommandTokenString}");
@@ -333,6 +458,7 @@ namespace eagle {
                 _currentModel.AvailableCommandsByProvince.Clear();
                 _currentModel.CommandToken = null;
                 _currentModel.LastPostedToken = token;
+                _commandSubmittedTime = DateTime.UtcNow;
                 return PersistentConnection.PostEagleCommand(
                         gameId: GameId,
                         token: token,
@@ -344,6 +470,10 @@ namespace eagle {
         }
 
         private void HandleStartingState(GameStateView startingState) {
+            var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff");
+            _connectionLogger.LogLine(
+                    $"[STATE_RESYNC] timestamp={timestamp} round={startingState.CurrentRoundId} factions={startingState.Factions.Count} heroes={startingState.Heroes.Count}");
+
             _currentModel.GsView = startingState;
             _currentModel.BattalionTypes =
                     startingState.BattalionTypes.ToDictionary(bt => bt.TypeId, bt => bt);
@@ -645,6 +775,15 @@ namespace eagle {
             foreach (ShardokBattleView bv in entry.NewBattles) _currentModel.ShardokBattles.Add(bv);
 
             foreach (string rb in entry.RemovedBattleIds) {
+                // If there's an active ShardokGameModel for this battle, mark it as ended
+                // so the UI knows to return to Eagle. This handles the race condition where
+                // the Eagle update removing the battle arrives before the Shardok Victory update.
+                if (_currentModel.ShardokGameModels.TryGetValue(rb, out var sgm)) {
+                    sgm.MarkBattleEnded("Battle has ended.");
+                    _currentModel.ShardokGameModels.Remove(rb);
+                }
+                _shardokResultCounts.TryRemove(rb, out _);
+
                 for (int i = 0; i < _currentModel.ShardokBattles.Count; i++) {
                     if (_currentModel.ShardokBattles[i].ShardokGameId == rb) {
                         _currentModel.ShardokBattles.RemoveAt(i);
@@ -690,5 +829,21 @@ namespace eagle {
                 Notify(result);
             }
         }
+
+#region IGameStateProvider implementation
+
+        /// <summary>Server-reported game status from the last ActionResultResponse.</summary>
+        public ServerGameStatus ServerStatus { get; private set; }
+
+        /// <summary>
+        /// True if a command was submitted and we're awaiting response.
+        /// Only returns true if processing for > 500ms to avoid flashing.
+        /// </summary>
+        public bool IsProcessingCommand =>
+                _commandSubmittedTime.HasValue &&
+                (DateTime.UtcNow - _commandSubmittedTime.Value).TotalMilliseconds >
+                        ProcessingDisplayDelayMs;
+
+#endregion
     }
 }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/FreeHeroesTableController.cs

@@ -59,7 +59,7 @@ namespace eagle {
             }
         }
 
-        private void UpdateUnaffiliatedHeroSelections() {
+        public void UpdateUnaffiliatedHeroSelections() {
             UnaffiliatedHeroes.Each(
                     (uh, i) => SetUnaffiliatedHeroRowSelections(
                             unaffiliatedHeroesTable.ComponentAt<UnaffiliatedHeroRowController>(i),

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/GeneratedTextUpdater.cs

@@ -18,10 +18,11 @@ namespace eagle {
                     if (scrollRect) { scrollRect.normalizedPosition = new Vector2(0, 1); }
                 }
 
+                // Always update the view when TextId changes to clear any stale text
                 if (!String.IsNullOrEmpty(_textId)) {
-                    // If the text ID is set, we want to update the view immediately
-                    // to reflect any existing text.
                     OnTextUpdate(ClientTextProvider.Provider.GetTextEntry(TextId));
+                } else {
+                    UpdateView();
                 }
             }
         }
@@ -59,7 +60,14 @@ namespace eagle {
         }
 
         private void OnTextUpdate(TextEntry entry) {
-            if (entry != null) OnTextUpdate(entry.Text, entry.Completed);
+            if (entry != null) {
+                OnTextUpdate(entry.Text, entry.Completed);
+            } else {
+                // Entry doesn't exist yet - clear text and update view to avoid stale content
+                _currentText = "";
+                _currentCompleted = false;
+                UpdateView();
+            }
         }
 
         public void OnTextUpdate(string text, bool completed) {

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/IClientConnectionSubscriber.cs

@@ -11,10 +11,18 @@ namespace eagle {
 
         public void ReceiveGameUpdate(GameUpdate update);
 
+        /// <summary>
+        /// Update the known result counts immediately when an update is received.
+        /// Called from the gRPC thread BEFORE enqueueing to MainQueue, to ensure
+        /// reconnects don't request stale data while MainQueue is blocked.
+        /// </summary>
+        public void UpdateResultCounts(GameUpdate update);
+
         // Used for registering for stream updates
         struct ShardokViewStatus {
             public string shardokGameId;
             public Int32 filteredResultCount;
+            public bool requestFullResync;  // Request full state instead of delta
         }
 
         struct StreamingTextStatus {

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/MapController.cs

@@ -21,6 +21,8 @@ namespace eagle {
         public bool Enabled { get; set; }
 
         private void SetDefaultProvinceColor(ProvinceId provinceId) {
+            // Model may be null during reconnection when UI is being reset
+            if (Model?.Provinces == null || !Model.Provinces.ContainsKey(provinceId)) { return; }
             SetProvinceColor(provinceId, ColorForProvince(Model.Provinces[provinceId]));
         }
 

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/NotificationPanel.cs

@@ -17,6 +17,10 @@ namespace eagle {
 
         private readonly Queue<Notification> _notes = new();
 
+        // Incremented when DismissAll is clicked; pending AddNote calls check this
+        // to skip adding if a dismiss happened since they were enqueued
+        private int _dismissGeneration = 0;
+
         private void SetPopupInfos() {
             PopupInfos = _notes.Select(note => new PopupInfo {
                                    titleText = note.Title,
@@ -40,15 +44,30 @@ namespace eagle {
             }
         }
 
+        // Compare hero lists by ID since HeroView is a protobuf message with reference equality
+        private static bool HeroListsMatch(List<HeroView> a, List<HeroView> b) {
+            if (a == null && b == null) return true;
+            if (a == null || b == null) return false;
+            if (a.Count != b.Count) return false;
+            return a.Select(h => h.Id).SequenceEqual(b.Select(h => h.Id));
+        }
+
         public void AddNote(
                 string title,
                 string text,
                 string llmId,
                 List<ProvinceId> provinceIds,
                 List<HeroView> displayedHeroes) {
+            // Capture current generation - if DismissAll is clicked before this executes,
+            // we'll skip adding the note
+            var capturedGeneration = _dismissGeneration;
             MainQueue.Q.Enqueue(() => {
+                // Skip if DismissAll was clicked since this was enqueued
+                if (capturedGeneration != _dismissGeneration) return;
+
                 var existingNote = _notes.FirstOrDefault(
-                        n => n.Title == title && n.DisplayedHeroes.SequenceEqual(displayedHeroes));
+                        n => n.Title == title &&
+                             HeroListsMatch(n.DisplayedHeroes, displayedHeroes));
 
                 if (existingNote == null) {
                     _notes.Enqueue(new Notification(
@@ -70,6 +89,8 @@ namespace eagle {
         }
 
         public void DismissAllClicked() {
+            // Increment generation immediately so pending AddNote calls will skip
+            _dismissGeneration++;
             _notes.Clear();
             SetPopupInfos();
         }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/ARNNotificationDispatcher.cs

@@ -37,6 +37,9 @@ namespace eagle.Notifications {
             { OutlawSpottedDetails, OutlawSpottedDetailsNotificationGenerator.Generator },
             { PrisonerExchangeDetails, PrisonerExchangeDetailsNotificationGenerator.Generator },
             { PrisonerExecutedDetails, PrisonerExecutedDetailsNotificationGenerator.Generator },
+            { PrisonerReleasedDetails, PrisonerReleasedDetailsNotificationGenerator.Generator },
+            { PrisonerExiledDetails, PrisonerExiledDetailsNotificationGenerator.Generator },
+            { PrisonerReturnedDetails, PrisonerReturnedDetailsNotificationGenerator.Generator },
             { ProvinceHeldDetails, ProvinceHeldDetailsNotificationGenerator.Generator },
             { QuestFailed, QuestFailedDetailsNotificationGenerator.Generator },
             { QuestFulfilled, QuestFulfilledDetailsNotificationGenerator.Generator },
@@ -53,7 +56,8 @@ namespace eagle.Notifications {
             { AllianceRejectedDetails, AllianceRejectedDetailsNotificationGenerator.Generator },
             { BreakAllianceAcceptedDetails, BreakAllianceAcceptedNotificationGenerator.Generator },
             { VassalExiledDetails, VassalExiledDetailsNotificationGenerator.Generator },
-            { WithdrewForTruce, WithdrewForTruceDetailsNotificationGenerator.Generator }
+            { WithdrewForTruce, WithdrewForTruceDetailsNotificationGenerator.Generator },
+            { ProfessionGainedDetails, ProfessionGainedDetailsNotificationGenerator.Generator }
         };
 
         public static IEnumerable<Notification> GenerateNotifications(

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerExecutedDetailsNotificationGenerator.cs

@@ -43,11 +43,12 @@ namespace eagle.Notifications.ARNNotifications {
                 heroPlaceholders["ExecutedHero"] = (hero.NameTextId, "the prisoner");
             }
 
-            yield return new DynamicTextNotification(
+            yield return DynamicTextNotification.StreamingDynamicNotification(
                     title: noteTitle,
                     textTemplate: textTemplate,
                     heroPlaceholders: heroPlaceholders,
-                    singleProvinceId: note.ProvinceId,
+                    llmId: notification.LlmId,
+                    provinceIds: new List<int> { note.ProvinceId },
                     displayedHeroes: new List<HeroView> { factionLeader, hero });
         }
     }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerExiledDetailsNotificationGenerator.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using Net.Eagle0.Eagle.Views;
+
+namespace eagle.Notifications.ARNNotifications {
+    public static class PrisonerExiledDetailsNotificationGenerator {
+        public static readonly ARNNotificationGenerator Generator = GenerateNotifications;
+
+        private static IEnumerable<Notification> GenerateNotifications(
+                Net.Eagle0.Eagle.Common.Notification notification,
+                IGameModel currentModel) {
+            var note = notification.Details.PrisonerExiledDetails;
+
+            var hero = currentModel.Heroes[note.ExiledHeroId];
+            var exilingFactionName = currentModel.FactionName(note.ExilingFactionId);
+
+            var factionLeader =
+                    currentModel.Heroes[currentModel.ActiveFactions[note.ExilingFactionId]
+                                                .FactionHeadId];
+
+            string noteTitle = "Prisoner Exiled";
+            string textTemplate;
+
+            var heroPlaceholders = new Dictionary<string, (string nameTextId, string fallback)>();
+
+            if (note.LastFactionId is {} lastFactionId) {
+                var lastFaction = currentModel.MaybeDestroyedFaction(lastFactionId);
+
+                string victimDescription;
+                if (lastFaction.FactionHeadId == hero.Id) {
+                    victimDescription = "faction leader {HeroName}";
+                } else if (lastFaction.Leaders.Contains(hero.Id)) {
+                    victimDescription =
+                            $"{DisplayNames.ResolvedFactionString(lastFaction, currentModel)}'s sworn {DisplayNames.SiblingDescription(hero.PronounGender)} {{HeroName}}";
+                } else {
+                    victimDescription =
+                            $"{DisplayNames.ResolvedFactionString(lastFaction, currentModel)}'s hero {{HeroName}}";
+                }
+
+                textTemplate = $"{exilingFactionName} has exiled {victimDescription}!\n\n";
+                heroPlaceholders["HeroName"] = (hero.NameTextId, "the hero");
+            } else {
+                textTemplate = $"{exilingFactionName} has exiled {{ExiledHero}}!\n\n";
+                heroPlaceholders["ExiledHero"] = (hero.NameTextId, "the prisoner");
+            }
+
+            yield return DynamicTextNotification.StreamingDynamicNotification(
+                    title: noteTitle,
+                    textTemplate: textTemplate,
+                    heroPlaceholders: heroPlaceholders,
+                    llmId: notification.LlmId,
+                    provinceIds: new List<int> { note.ProvinceId },
+                    displayedHeroes: new List<HeroView> { factionLeader, hero });
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerExiledDetailsNotificationGenerator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: be877c33ab14e4b37b6402ca0826efa1

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerReleasedDetailsNotificationGenerator.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using Net.Eagle0.Eagle.Views;
+
+namespace eagle.Notifications.ARNNotifications {
+    public static class PrisonerReleasedDetailsNotificationGenerator {
+        public static readonly ARNNotificationGenerator Generator = GenerateNotifications;
+
+        private static IEnumerable<Notification> GenerateNotifications(
+                Net.Eagle0.Eagle.Common.Notification notification,
+                IGameModel currentModel) {
+            var note = notification.Details.PrisonerReleasedDetails;
+
+            var hero = currentModel.Heroes[note.ReleasedHeroId];
+            var releasingFactionName = currentModel.FactionName(note.ReleasingFactionId);
+
+            var factionLeader =
+                    currentModel.Heroes[currentModel.ActiveFactions[note.ReleasingFactionId]
+                                                .FactionHeadId];
+
+            string noteTitle = "Prisoner Released";
+            string textTemplate;
+
+            var heroPlaceholders = new Dictionary<string, (string nameTextId, string fallback)>();
+
+            if (note.LastFactionId is {} lastFactionId) {
+                var lastFaction = currentModel.MaybeDestroyedFaction(lastFactionId);
+
+                string victimDescription;
+                if (lastFaction.FactionHeadId == hero.Id) {
+                    victimDescription = "faction leader {HeroName}";
+                } else if (lastFaction.Leaders.Contains(hero.Id)) {
+                    victimDescription =
+                            $"{DisplayNames.ResolvedFactionString(lastFaction, currentModel)}'s sworn {DisplayNames.SiblingDescription(hero.PronounGender)} {{HeroName}}";
+                } else {
+                    victimDescription =
+                            $"{DisplayNames.ResolvedFactionString(lastFaction, currentModel)}'s hero {{HeroName}}";
+                }
+
+                textTemplate = $"{releasingFactionName} has released {victimDescription}!\n\n";
+                heroPlaceholders["HeroName"] = (hero.NameTextId, "the hero");
+            } else {
+                textTemplate = $"{releasingFactionName} has released {{ReleasedHero}}!\n\n";
+                heroPlaceholders["ReleasedHero"] = (hero.NameTextId, "the prisoner");
+            }
+
+            yield return DynamicTextNotification.StreamingDynamicNotification(
+                    title: noteTitle,
+                    textTemplate: textTemplate,
+                    heroPlaceholders: heroPlaceholders,
+                    llmId: notification.LlmId,
+                    provinceIds: new List<int> { note.ProvinceId },
+                    displayedHeroes: new List<HeroView> { factionLeader, hero });
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerReleasedDetailsNotificationGenerator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 21603b7e9604d459ea6141801d820f2e

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerReturnedDetailsNotificationGenerator.cs

@@ -0,0 +1,58 @@
+using System.Collections.Generic;
+using Net.Eagle0.Eagle.Views;
+
+namespace eagle.Notifications.ARNNotifications {
+    public static class PrisonerReturnedDetailsNotificationGenerator {
+        public static readonly ARNNotificationGenerator Generator = GenerateNotifications;
+
+        private static IEnumerable<Notification> GenerateNotifications(
+                Net.Eagle0.Eagle.Common.Notification notification,
+                IGameModel currentModel) {
+            var note = notification.Details.PrisonerReturnedDetails;
+
+            var hero = currentModel.Heroes[note.ReturnedHeroId];
+            var returningFactionName = currentModel.FactionName(note.ReturningFactionId);
+            var toFactionName = currentModel.FactionName(note.ToFactionId);
+
+            var factionLeader =
+                    currentModel.Heroes[currentModel.ActiveFactions[note.ReturningFactionId]
+                                                .FactionHeadId];
+
+            string noteTitle = "Prisoner Returned";
+            string textTemplate;
+
+            var heroPlaceholders = new Dictionary<string, (string nameTextId, string fallback)>();
+
+            if (note.LastFactionId is {} lastFactionId) {
+                var lastFaction = currentModel.MaybeDestroyedFaction(lastFactionId);
+
+                string victimDescription;
+                if (lastFaction.FactionHeadId == hero.Id) {
+                    victimDescription = "faction leader {HeroName}";
+                } else if (lastFaction.Leaders.Contains(hero.Id)) {
+                    victimDescription =
+                            $"{DisplayNames.ResolvedFactionString(lastFaction, currentModel)}'s sworn {DisplayNames.SiblingDescription(hero.PronounGender)} {{HeroName}}";
+                } else {
+                    victimDescription =
+                            $"{DisplayNames.ResolvedFactionString(lastFaction, currentModel)}'s hero {{HeroName}}";
+                }
+
+                textTemplate =
+                        $"{returningFactionName} has returned {victimDescription} to {toFactionName}!\n\n";
+                heroPlaceholders["HeroName"] = (hero.NameTextId, "the hero");
+            } else {
+                textTemplate =
+                        $"{returningFactionName} has returned {{ReturnedHero}} to {toFactionName}!\n\n";
+                heroPlaceholders["ReturnedHero"] = (hero.NameTextId, "the prisoner");
+            }
+
+            yield return DynamicTextNotification.StreamingDynamicNotification(
+                    title: noteTitle,
+                    textTemplate: textTemplate,
+                    heroPlaceholders: heroPlaceholders,
+                    llmId: notification.LlmId,
+                    provinceIds: new List<int> { note.ProvinceId },
+                    displayedHeroes: new List<HeroView> { factionLeader, hero });
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/PrisonerReturnedDetailsNotificationGenerator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9c378d55ca4214d53b63c2bb14a614a4

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/ProfessionGainedDetailsNotificationGenerator.cs

@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using Net.Eagle0.Eagle.Common;
+using Net.Eagle0.Eagle.Views;
+
+namespace eagle.Notifications.ARNNotifications {
+    public static class ProfessionGainedDetailsNotificationGenerator {
+        public static readonly ARNNotificationGenerator Generator = GenerateNotifications;
+
+        private static readonly Dictionary<Profession, string> ProfessionNames =
+                new Dictionary<Profession, string> {
+                    { Profession.Mage, "Mage" },
+                    { Profession.Necromancer, "Necromancer" },
+                    { Profession.Engineer, "Engineer" },
+                    { Profession.Paladin, "Paladin" },
+                    { Profession.Ranger, "Ranger" },
+                    { Profession.Champion, "Champion" }
+                };
+
+        private static readonly Dictionary<Profession, string> ProfessionTitles =
+                new Dictionary<Profession, string> {
+                    { Profession.Mage, "Arcane Awakening" },
+                    { Profession.Necromancer, "Dark Pact Sealed" },
+                    { Profession.Engineer, "Genius Unleashed" },
+                    { Profession.Paladin, "Divine Calling" },
+                    { Profession.Ranger, "One with the Wild" },
+                    { Profession.Champion, "Born for Battle" }
+                };
+
+        private static string GetProfessionName(Profession profession) {
+            return ProfessionNames.TryGetValue(profession, out var name) ? name : "Unknown";
+        }
+
+        private static string GetArticle(string word) {
+            if (string.IsNullOrEmpty(word)) return "a";
+            char firstChar = char.ToLower(word[0]);
+            return (firstChar == 'a' || firstChar == 'e' || firstChar == 'i' || firstChar == 'o' ||
+                    firstChar == 'u')
+                           ? "an"
+                           : "a";
+        }
+
+        private static string GetProfessionTitle(Profession profession) {
+            return ProfessionTitles.TryGetValue(profession, out var title) ? title
+                                                                           : "Profession Gained";
+        }
+
+        private static IEnumerable<Notification> GenerateNotifications(
+                Net.Eagle0.Eagle.Common.Notification notification,
+                IGameModel currentModel) {
+            var details = notification.Details.ProfessionGainedDetails;
+            var hero = currentModel.Heroes[details.HeroId];
+            var factionName = currentModel.FactionName(details.FactionId);
+            var professionName = GetProfessionName(details.NewProfession);
+            var article = GetArticle(professionName);
+
+            var affectedProvinces = currentModel.ProvincesForFaction(details.FactionId);
+
+            string textTemplate =
+                    $"{{Hero}} of {factionName} became {article} {professionName}.\n\n";
+
+            var heroPlaceholders = new Dictionary<string, (string nameTextId, string fallback)> {
+                { "Hero", (hero.NameTextId, "A hero") }
+            };
+
+            yield return DynamicTextNotification.StreamingDynamicNotification(
+                    title: GetProfessionTitle(details.NewProfession),
+                    textTemplate: textTemplate,
+                    heroPlaceholders: heroPlaceholders,
+                    llmId: notification.LlmId,
+                    provinceIds: affectedProvinces,
+                    displayedHeroes: new List<HeroView> { hero });
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/ARNNotifications/ProfessionGainedDetailsNotificationGenerator.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 11e2f9347861144c8983e71df3abef74

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/Notifications/Notification.cs

@@ -102,6 +102,11 @@ namespace eagle.Notifications {
         }
 
         public void Append(string text, List<ProvinceId> provinceIds) {
+            // Skip if this exact text is already in the notification (prevents duplicates
+            // when the same update is processed multiple times, e.g., after resuming from
+            // background)
+            if (Text.Contains(text)) { return; }
+
             if (ShouldAppend) {
                 Text += "\n" + text;
                 ProvinceIds.AddRange(provinceIds);

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Eagle/PersistentClientConnection.cs

@@ -16,6 +16,14 @@ namespace eagle {
     using ShardokGameId = String;
     using ProvinceId = Int32;
 
+    public enum ConnectionState {
+        Disconnected,
+        Connecting,
+        Connected,
+        Reconnecting,
+        SubscriptionPending  // Connected but waiting for subscription acknowledgment
+    }
+
     public interface ILobbySubscriber {
         void ReceiveLobbyUpdate(LobbyResponse lobbyResponse);
         void ReceivePregeneratedTextUpdate(PregeneratedTextResponse response);
@@ -26,20 +34,95 @@ namespace eagle {
 
     public class PersistentClientConnection : IDisposable {
         private const double TimeoutSeconds = 300.0;
-        private const double HeartbeatTimerSeconds = 10.0;
+        // Idle timeout = 2x HTTP/2 keepalive interval (15s * 2 = 30s)
+        private const double MaxIdleSeconds = 30.0;
 
         private DateTime _lastResponseReceived = DateTime.UtcNow;
+        private int _lastIdleWarningLevel = 0;  // 0=none, 1=10s warning, 2=20s warning
         private readonly Metadata _credentials;
         private readonly CancellationToken _cancellationToken;
 
         private readonly Logger _remoteEagleClientLogger = Logger.GetLogger("ConnectionLogger");
         private readonly Logger _timingsLogger = Logger.GetLogger("ConnectionLogger");
-        private Timer _timer = null;
+        private volatile bool _isConnecting = false;
+        private Timer _idleCheckTimer = null;
+        private Timer _heartbeatTimer = null;
+        private const double HeartbeatIntervalSeconds = 10.0;
+
+        // Connection metrics for diagnostics
+        private DateTime? _lastConnectAttempt = null;
+        private DateTime? _lastSuccessfulConnect = null;
+        private DateTime? _lastDisconnect = null;
+        private StatusCode? _lastDisconnectReason = null;
+
+        // Exponential backoff for reconnection
+        private int _consecutiveFailures = 0;
+        private const double MinBackoffSeconds = 2.0;
+        private const double MaxBackoffSeconds = 32.0;
+
+        // Connection state for UI monitoring
+        private ConnectionState _currentState = ConnectionState.Disconnected;
+        public ConnectionState CurrentState => _currentState;
+        public DateTime? NextReconnectAttempt { get; private set; } = null;
+
+        // Circuit breaker for preventing cascading failures
+        private ConnectionCircuitBreaker _circuitBreaker = new ConnectionCircuitBreaker();
+        public ConnectionCircuitBreaker CircuitBreaker => _circuitBreaker;
 
         private DateTime? GetDeadlineFromNow() {
             return DateTime.UtcNow.AddSeconds(TimeoutSeconds);
         }
 
+        private int GetTotalShardokGames() {
+            int total = 0;
+            lock (this) {
+                foreach (var sub in _subscribers.Values) { total += sub.ShardokViewStatuses.Count; }
+            }
+            return total;
+        }
+
+        private void
+        LogConnectionEvent(string eventType, string details = null, StatusCode? statusCode = null) {
+            var timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss.fff");
+            var shardokCount = GetTotalShardokGames();
+            var shardokInfo = shardokCount > 0 ? $" shardok_games={shardokCount}" : "";
+            var statusInfo = statusCode.HasValue ? $" status={statusCode.Value}" : "";
+            var detailsInfo = !string.IsNullOrEmpty(details) ? $" details=\"{details}\"" : "";
+            var timeSinceLastConnect =
+                    _lastSuccessfulConnect.HasValue
+                            ? $" seconds_since_connect={(DateTime.UtcNow - _lastSuccessfulConnect.Value).TotalSeconds:F1}"
+                            : "";
+
+            _remoteEagleClientLogger.LogLine(
+                    $"[CONNECTION] timestamp={timestamp} event={eventType}{shardokInfo}{statusInfo}{detailsInfo}{timeSinceLastConnect}");
+        }
+
+        private double GetBackoffSeconds() {
+            if (_consecutiveFailures == 0) { return MinBackoffSeconds; }
+
+            // Exponential backoff: 2, 4, 8, 16, 32 (capped)
+            double backoff = MinBackoffSeconds * Math.Pow(2, _consecutiveFailures);
+            return Math.Min(backoff, MaxBackoffSeconds);
+        }
+
+        private void ScheduleReconnect(string reason) {
+            double backoffSeconds = GetBackoffSeconds();
+            _consecutiveFailures++;
+            _currentState = ConnectionState.Reconnecting;
+            NextReconnectAttempt = DateTime.UtcNow.AddSeconds(backoffSeconds);
+
+            LogConnectionEvent(
+                    "schedule_reconnect",
+                    $"{reason}, backoff={backoffSeconds:F1}s, attempt={_consecutiveFailures}");
+
+            _retryTimer?.Dispose();
+            _retryTimer = new Timer();
+            _retryTimer.AutoReset = false;
+            _retryTimer.Interval = backoffSeconds * 1000;
+            _retryTimer.Elapsed += (sender, args) => Task.Run(() => Connect());
+            _retryTimer.Enabled = true;
+        }
+
         private readonly Eagle.EagleClient _grpcClient;
         private AsyncDuplexStreamingCall<UpdateStreamRequest, UpdateStreamResponse> _streamingCall;
 
@@ -51,6 +134,11 @@ namespace eagle {
 
         private List<PostCommandRequest> _pendingCommands = new();
 
+        // Pending subscription acknowledgments - used to wait for server confirmation
+        private readonly Dictionary<EagleGameId, TaskCompletionSource<SubscriptionAck>>
+                _pendingSubscriptionAcks = new();
+        private const int SubscriptionAckTimeoutMs = 10000;  // 10 seconds
+
         public PersistentClientConnection(
                 Eagle.EagleClient grpcClient,
                 Metadata credentials,
@@ -60,17 +148,27 @@ namespace eagle {
             _cancellationToken = cancellationToken;
         }
 
-        private void StreamOneGame(IClientConnectionSubscriber subscriber) {
+        /// <summary>
+        /// Sends a subscription request for a game and awaits server acknowledgment.
+        /// Returns true if the subscription was acknowledged successfully, false otherwise.
+        /// IMPORTANT: Must be called outside of lock(this) to allow awaiting.
+        /// </summary>
+        private async Task<bool> StreamOneGameAsync(IClientConnectionSubscriber subscriber) {
+            var gameId = subscriber.GameId;
             var streamGameRequest = new StreamGameRequest {
-                GameId = subscriber.GameId,
+                GameId = gameId,
                 UnfilteredResultCount = subscriber.LastUnfilteredResultCount
             };
 
-            streamGameRequest.ShardokViewStatuses.AddRange(subscriber.ShardokViewStatuses.Select(
+            // Get Shardok statuses (may include resync flags)
+            var shardokStatuses = subscriber.ShardokViewStatuses;
+            streamGameRequest.ShardokViewStatuses.AddRange(shardokStatuses.Select(
                     status => new StreamGameRequest.Types.ShardokViewStatus {
                         FilteredResultCount = status.filteredResultCount,
-                        ShardokGameId = status.shardokGameId
+                        ShardokGameId = status.shardokGameId,
+                        RequestFullResync = status.requestFullResync
                     }));
+
             streamGameRequest.StreamingTextStatuses.AddRange(
                     subscriber.StreamingTextStatuses.Select(
                             status => new StreamGameRequest.Types.StreamingTextStatus {
@@ -81,50 +179,205 @@ namespace eagle {
 
             var request = new UpdateStreamRequest { StreamGameRequest = streamGameRequest };
 
-            DoWithStreamingCall(async (sc) => {
+            // Create a TaskCompletionSource to wait for the server's acknowledgment
+            var ackTcs = new TaskCompletionSource<SubscriptionAck>();
+            lock (_pendingSubscriptionAcks) { _pendingSubscriptionAcks[gameId] = ackTcs; }
+
+            _remoteEagleClientLogger.LogLine(
+                    $"[SUBSCRIBE] Sending StreamGameRequest for game {gameId}, " +
+                    $"unfilteredCount={subscriber.LastUnfilteredResultCount}");
+
+            var sendSuccess = await DoWithStreamingCall(async (sc) => {
                 await sc.RequestStream.WriteAsync(request);
+                _remoteEagleClientLogger.LogLine(
+                        $"[SUBSCRIBE] StreamGameRequest sent successfully for game {gameId}");
                 return true;
             });
+
+            if (!sendSuccess) {
+                // Write failed - clean up and return
+                lock (_pendingSubscriptionAcks) { _pendingSubscriptionAcks.Remove(gameId); }
+                LogConnectionEvent("subscribe_send_failed", $"game={gameId}");
+                return false;
+            }
+
+            // Wait for server acknowledgment with timeout
+            using var timeoutCts = new CancellationTokenSource();
+            try {
+                var ackTask = ackTcs.Task;
+                var timeoutTask = Task.Delay(SubscriptionAckTimeoutMs, timeoutCts.Token);
+                var completedTask = await Task.WhenAny(ackTask, timeoutTask);
+
+                if (completedTask == timeoutTask) {
+                    // Timeout waiting for ack
+                    lock (_pendingSubscriptionAcks) { _pendingSubscriptionAcks.Remove(gameId); }
+                    LogConnectionEvent("subscribe_ack_timeout", $"game={gameId}");
+                    _remoteEagleClientLogger.LogLine(
+                            $"[SUBSCRIBE] Timeout waiting for SubscriptionAck for game {gameId}");
+                    return false;
+                }
+
+                // Cancel the timeout task since ack was received
+                timeoutCts.Cancel();
+
+                var ack = await ackTask;
+                if (ack.Success) {
+                    _remoteEagleClientLogger.LogLine(
+                            $"[SUBSCRIBE] Subscription confirmed for game {gameId}, " +
+                            $"confirmedResultCount={ack.ConfirmedResultCount}");
+
+                    // Note: Shardok resync flags are cleared in EagleGameModel.HandleOneGameUpdate
+                    // AFTER updates are actually received, not here. This ensures that if the
+                    // connection drops between acknowledgment and update delivery, the resync
+                    // will be requested again on the next reconnect.
+
+                    return true;
+                } else {
+                    LogConnectionEvent(
+                            "subscribe_ack_failed",
+                            $"game={gameId}, error={ack.ErrorMessage}");
+                    _remoteEagleClientLogger.LogLine(
+                            $"[SUBSCRIBE] Server rejected subscription for game {gameId}: {ack.ErrorMessage}");
+                    return false;
+                }
+            } catch (OperationCanceledException) {
+                // Task was cancelled (e.g., connection drop) - not an error
+                lock (_pendingSubscriptionAcks) { _pendingSubscriptionAcks.Remove(gameId); }
+                _remoteEagleClientLogger.LogLine(
+                        $"[SUBSCRIBE] Cancelled waiting for ack for game {gameId}");
+                return false;
+            } catch (Exception e) {
+                lock (_pendingSubscriptionAcks) { _pendingSubscriptionAcks.Remove(gameId); }
+                _remoteEagleClientLogger.LogLine(
+                        $"[SUBSCRIBE] Exception waiting for ack for game {gameId}: {e.Message}");
+                return false;
+            }
         }
 
         public async Task Connect() {
-            _remoteEagleClientLogger.LogLine($"Connect() called");
-
-            // Dispose existing streaming call before creating new one
-            lock (this) {
-                _streamingCall?.Dispose();
-                _streamingCall = null;
-
-                // Cancel and dispose existing thread cancellation token
-                _threadCancellationTokenSource?.Cancel();
-                _threadCancellationTokenSource?.Dispose();
-                _threadCancellationTokenSource = new CancellationTokenSource();
-                _currentThreadToken = _threadCancellationTokenSource.Token;
+            // Prevent concurrent connection attempts
+            if (_isConnecting) {
+                _remoteEagleClientLogger.LogLine($"Connect() skipped - already connecting");
+                return;
             }
 
-            var call = _grpcClient.StreamUpdates(
-                    headers: _credentials,
-                    deadline: GetDeadlineFromNow(),
-                    cancellationToken: _cancellationToken);
-            Queue<PostCommandRequest> pendingCommands = new Queue<PostCommandRequest>();
-            try {
-                lock (this) {
-                    _streamingCall = call;
-                    _streamingCallThread = new Thread(HandleStreamingCall);
-                    _streamingCallThread.Start();
+            // Check circuit breaker
+            if (!_circuitBreaker.ShouldAttemptConnection()) {
+                _remoteEagleClientLogger.LogLine(
+                        $"[CIRCUIT] Connection attempt blocked - circuit {_circuitBreaker.CurrentState}");
+                LogConnectionEvent("connect_blocked", $"circuit={_circuitBreaker.CurrentState}");
+                return;
+            }
 
-                    foreach (var kv in _subscribers) { StreamOneGame(kv.Value); }
+            _isConnecting = true;
+            try {
+                _lastConnectAttempt = DateTime.UtcNow;
+                _currentState = _consecutiveFailures > 0 ? ConnectionState.Reconnecting
+                                                         : ConnectionState.Connecting;
+                NextReconnectAttempt = null;
+                LogConnectionEvent("connect_attempt");
+
+                // Dispose existing streaming call before creating new one
+                lock (this) {
+                    _streamingCall?.Dispose();
+                    _streamingCall = null;
+
+                    // Cancel and dispose existing thread cancellation token
+                    _threadCancellationTokenSource?.Cancel();
+                    _threadCancellationTokenSource?.Dispose();
+                    _threadCancellationTokenSource = new CancellationTokenSource();
+                    _currentThreadToken = _threadCancellationTokenSource.Token;
                 }
 
-                await TryPendingCommands();
-            } catch (Exception e) {
-                _remoteEagleClientLogger.LogLine($"Got exception {e} in Connect()");
-                lock (this) {
-                    while (pendingCommands.Any()) {
-                        _pendingCommands.Add(pendingCommands.Dequeue());
+                var call = _grpcClient.StreamUpdates(
+                        headers: _credentials,
+                        deadline: GetDeadlineFromNow(),
+                        cancellationToken: _cancellationToken);
+                Queue<PostCommandRequest> pendingCommands = new Queue<PostCommandRequest>();
+                try {
+                    List<IClientConnectionSubscriber> subscribersToStream;
+                    lock (this) {
+                        _streamingCall = call;
+                        _streamingCallThread = new Thread(HandleStreamingCall);
+                        _streamingCallThread.Start();
+
+                        // Collect subscribers under lock
+                        subscribersToStream = _subscribers.Values.ToList();
+                    }
+
+                    // Stream subscriptions OUTSIDE lock (can await)
+                    // Set state to SubscriptionPending while waiting for acks
+                    if (subscribersToStream.Any()) {
+                        _currentState = ConnectionState.SubscriptionPending;
+                    }
+
+                    bool allSucceeded = true;
+                    foreach (var subscriber in subscribersToStream) {
+                        if (!await StreamOneGameAsync(subscriber)) { allSucceeded = false; }
+                    }
+
+                    if (!allSucceeded) {
+                        // Subscription failed - this is critical because the game won't receive
+                        // updates. Trigger reconnect rather than proceeding to Connected state.
+                        LogConnectionEvent(
+                                "subscribe_failed",
+                                "Subscription failed - triggering reconnect");
+
+                        // Cleanup resources before reconnecting (consistent with other failure
+                        // paths in HandleStreamingCall). This prevents the background thread from
+                        // triggering its own reconnect when Connect() disposes the streaming call.
+                        lock (this) {
+                            _streamingCall?.Dispose();
+                            _streamingCall = null;
+                            _threadCancellationTokenSource?.Cancel();
+                        }
+                        MarkAllShardokGamesForResync();
+                        CancelAllPendingSubscriptionAcks();
+
+                        _circuitBreaker.RecordFailure();
+                        ScheduleReconnect("SubscriptionFailed");
+                        return;
+                    }
+
+                    _lastSuccessfulConnect = DateTime.UtcNow;
+                    _consecutiveFailures = 0;  // Reset backoff on successful connection
+                    _currentState = ConnectionState.Connected;
+                    _circuitBreaker.RecordSuccess();
+                    LogConnectionEvent("connect_success");
+
+                    // CRITICAL: Cancel any pending scheduled reconnect to prevent it from
+                    // firing and killing this working connection
+                    if (_retryTimer != null) {
+                        _retryTimer.Enabled = false;
+                        _retryTimer.Dispose();
+                        _retryTimer = null;
+                    }
+
+                    // CRITICAL: Reset idle timer baseline before starting idle check
+                    // Otherwise, on reconnect, _lastResponseReceived still has the old
+                    // timestamp and CheckForIdleTimeout() will immediately kill this
+                    // new connection thinking it's been idle for minutes
+                    _lastResponseReceived = DateTime.UtcNow;
+                    _lastIdleWarningLevel = 0;
+
+                    // Start monitoring for idle timeout (relies on HTTP/2 keepalive)
+                    StartIdleCheckTimer();
+
+                    // Start sending heartbeats with sync status
+                    StartHeartbeatTimer();
+
+                    await TryPendingCommands();
+                } catch (Exception e) {
+                    _circuitBreaker.RecordFailure();
+                    LogConnectionEvent("connect_failed", e.GetType().Name);
+                    _remoteEagleClientLogger.LogLine($"Got exception {e} in Connect()");
+                    lock (this) {
+                        while (pendingCommands.Any()) {
+                            _pendingCommands.Add(pendingCommands.Dequeue());
+                        }
                     }
                 }
-            }
+            } finally { _isConnecting = false; }
         }
 
         private async Task<bool> TryPendingCommands() {
@@ -229,6 +482,10 @@ namespace eagle {
 
         public void Disconnect() {
             lock (this) {
+                _lastDisconnect = DateTime.UtcNow;
+                LogConnectionEvent("disconnect_explicit");
+                StopIdleCheckTimer();
+                StopHeartbeatTimer();
                 _streamingCall?.Dispose();
                 _streamingCall = null;
             }
@@ -237,11 +494,8 @@ namespace eagle {
         public void Dispose() {
             lock (this) {
                 // Dispose timers first to stop any pending callbacks
-                if (_timer != null) {
-                    _timer.Enabled = false;
-                    _timer.Dispose();
-                    _timer = null;
-                }
+                StopIdleCheckTimer();
+                StopHeartbeatTimer();
 
                 if (_retryTimer != null) {
                     _retryTimer.Enabled = false;
@@ -280,11 +534,19 @@ namespace eagle {
             _lobbySubscriber = subscriber;
         }
 
-        public void Subscribe(IClientConnectionSubscriber subscriber) {
+        /// <summary>
+        /// Subscribe to a game and wait for server acknowledgment.
+        /// Returns true if subscription was acknowledged, false if it failed or timed out.
+        /// </summary>
+        public async Task<bool> Subscribe(IClientConnectionSubscriber subscriber) {
+            IClientConnectionSubscriber toStream;
             lock (this) {
                 _subscribers[subscriber.GameId] = subscriber;
-                StreamOneGame(subscriber);
+                toStream = subscriber;
             }
+
+            // Stream OUTSIDE lock (can await)
+            return await StreamOneGameAsync(toStream);
         }
 
         public async Task PostError(EagleGameId gameId, string errorMessage, string stackTrace) {
@@ -439,9 +701,32 @@ namespace eagle {
                     });
                     break;
 
+                case GameUpdate.GameUpdateDetailsOneofCase.StreamingTextResponse:
+                    // Handle streaming text directly on gRPC thread - dictionary is thread-safe.
+                    // Listeners are notified later via ProcessPendingUpdates() on main thread.
+                    var str = gameUpdate.StreamingTextResponse;
+                    if (str != null) {
+                        ClientTextProvider.Provider.HandleNewStreamingText(
+                                str.LlmIdentifier,
+                                str.NewText,
+                                str.StartingByteCount,
+                                str.Completed);
+                    }
+                    // No MainQueue enqueue needed - ProcessPendingUpdates handles listener
+                    // notification
+                    break;
+
                 case GameUpdate.GameUpdateDetailsOneofCase.ActionResultResponse:
                 case GameUpdate.GameUpdateDetailsOneofCase.ShardokActionResultResponse:
-                case GameUpdate.GameUpdateDetailsOneofCase.StreamingTextResponse:
+                    // Update result counts IMMEDIATELY on the gRPC thread, before enqueueing.
+                    // This ensures reconnects use accurate counts even when MainQueue is blocked
+                    // (e.g., when Unity is backgrounded).
+                    lock (this) {
+                        if (_subscribers.TryGetValue(gameUpdate.GameId, out var sub)) {
+                            sub.UpdateResultCounts(gameUpdate);
+                        }
+                    }
+
                     MainQueue.Q.Enqueue(async () => {
                         IClientConnectionSubscriber subscriber;
                         lock (this) {
@@ -472,14 +757,12 @@ namespace eagle {
                     threadToken = _currentThreadToken;
                 }
 
-                SetUpTimer();
-
                 var waitStartTime = DateTime.UtcNow;
                 while (sc != null && !_currentThreadToken.IsCancellationRequested &&
                        await sc.ResponseStream.MoveNext(_cancellationToken)) {
                     var receivedTime = DateTime.UtcNow;
                     _lastResponseReceived = receivedTime;
-                    SetUpTimer();
+                    _lastIdleWarningLevel = 0;  // Reset idle warnings on data received
                     var waitTime = (receivedTime - waitStartTime).TotalMilliseconds;
                     if (waitTime > 100.0) { _timingsLogger.LogLine($"WAIT    {waitTime} ms"); }
 
@@ -488,7 +771,7 @@ namespace eagle {
 
                         switch (current.ResponseDetailsCase) {
                             case UpdateStreamResponse.ResponseDetailsOneofCase.HeartbeatResponse:
-                                _remoteEagleClientLogger.LogLine("Got a heartbeat response!");
+                                HandleHeartbeatResponse(current.HeartbeatResponse);
                                 break;
 
                             case UpdateStreamResponse.ResponseDetailsOneofCase.GameUpdate:
@@ -553,6 +836,25 @@ namespace eagle {
                                             mapInfo.Map);
                                 }
 
+                                break;
+
+                            case UpdateStreamResponse.ResponseDetailsOneofCase.SubscriptionAck:
+                                var ack = current.SubscriptionAck;
+                                _remoteEagleClientLogger.LogLine(
+                                        $"[SUBSCRIBE] Received SubscriptionAck for game {ack.GameId}, " +
+                                        $"success={ack.Success}");
+                                // Get TCS under lock, but call TrySetResult outside to avoid
+                                // potential deadlock from synchronous continuations
+                                TaskCompletionSource<SubscriptionAck> ackTcs = null;
+                                lock (_pendingSubscriptionAcks) {
+                                    if (_pendingSubscriptionAcks.TryGetValue(
+                                                ack.GameId,
+                                                out ackTcs)) {
+                                        _pendingSubscriptionAcks.Remove(ack.GameId);
+                                    }
+                                }
+                                ackTcs?.TrySetResult(ack);
+
                                 break;
                         }
 
@@ -566,113 +868,242 @@ namespace eagle {
                         "How did we get here? This is not my beautiful wife!");
             } catch (RpcException e) {
                 lock (this) {
+                    _lastDisconnect = DateTime.UtcNow;
+                    _lastDisconnectReason = e.StatusCode;
+
+                    // Mark all active Shardok games for full state resync
+                    MarkAllShardokGamesForResync();
+                    CancelAllPendingSubscriptionAcks();
+
                     switch (e.StatusCode) {
                         case StatusCode.Cancelled:
+                            LogConnectionEvent("disconnect", "Cancelled", StatusCode.Cancelled);
                             _remoteEagleClientLogger.LogLine($"Got exception {e}");
-                            if (_cancellationToken.IsCancellationRequested ||
-                                _currentThreadToken.IsCancellationRequested) {
-                                return;
-                            }
+                            // Only check the main cancellation token, not the thread-specific one
+                            // The thread token gets cancelled during normal reconnection and
+                            // shouldn't prevent it
+                            if (_cancellationToken.IsCancellationRequested) { return; }
 
-                            Connect();
+                            ScheduleReconnect("Cancelled");
 
                             break;
 
                         case StatusCode.Internal:
+                            LogConnectionEvent("disconnect", "Internal error", StatusCode.Internal);
                             _remoteEagleClientLogger.LogLine($"Got exception {e}");
-                            Connect();
+                            ScheduleReconnect("Internal");
                             break;
 
                         case StatusCode.DeadlineExceeded:
+                            LogConnectionEvent(
+                                    "disconnect",
+                                    "Deadline exceeded",
+                                    StatusCode.DeadlineExceeded);
                             _remoteEagleClientLogger.LogLine("Got DeadlineExceeded");
-                            Connect();
+                            ScheduleReconnect("DeadlineExceeded");
                             break;
 
                         case StatusCode.Unavailable:
+                            LogConnectionEvent("disconnect", "Unavailable", StatusCode.Unavailable);
                             _remoteEagleClientLogger.LogLine("Got Unavailable");
-                            _retryTimer?.Dispose();
-                            _retryTimer = new Timer();
-                            _retryTimer.AutoReset = false;
-                            _retryTimer.Interval = 5000;
-                            _retryTimer.Elapsed += (sender, args) => Connect();
-                            _retryTimer.Enabled = true;
+                            ScheduleReconnect("Unavailable");
                             break;
 
                         default:
+                            LogConnectionEvent(
+                                    "disconnect",
+                                    $"Unknown: {e.StatusCode}",
+                                    e.StatusCode);
                             _remoteEagleClientLogger.LogLine(
                                     $"Something went very wrong, caught exception {e}");
+                            ScheduleReconnect($"Unknown-{e.StatusCode}");
                             break;
                     }
                 }
             } catch (ObjectDisposedException e) {
+                _lastDisconnect = DateTime.UtcNow;
+                LogConnectionEvent("disconnect", "ObjectDisposed");
                 _remoteEagleClientLogger.LogLine($"Got ObjectDisposedException {e}");
-                Connect();
+
+                // Mark all active Shardok games for full state resync
+                MarkAllShardokGamesForResync();
+                CancelAllPendingSubscriptionAcks();
+
+                ScheduleReconnect("ObjectDisposed");
             }
 
             return;
         }
 
-        private void SetUpTimer() {
-            if (_timer != null) {
-                _timer.Enabled = false;
-                _timer.Dispose();
-                _timer = null;
+        /// <summary>
+        /// Mark all active Shardok games for resync across all subscribers.
+        /// Called when connection drops to ensure state consistency on reconnect.
+        /// </summary>
+        private void MarkAllShardokGamesForResync() {
+            foreach (var updater in _subscribers.Values.OfType<GameModelUpdater>()) {
+                updater.MarkAllShardokForResync();
             }
-
-            _timer = new Timer { AutoReset = false, Interval = HeartbeatTimerSeconds * 1000 };
-            _timer.Elapsed += TimerFired;
-            _timer.Enabled = true;
         }
 
-        private void SendHeartbeatRequest(
-                AsyncDuplexStreamingCall<UpdateStreamRequest, UpdateStreamResponse> sc) {
-            var heartbeatRequest = new UpdateStreamRequest {
-                HeartbeatRequest =
-                        new HeartbeatRequest {
-                            ClientTimestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds()
-                        }
+        /// <summary>
+        /// Cancel all pending subscription acknowledgments.
+        /// Called when connection drops to unblock any waiting subscription tasks.
+        /// </summary>
+        private void CancelAllPendingSubscriptionAcks() {
+            lock (_pendingSubscriptionAcks) {
+                foreach (var tcs in _pendingSubscriptionAcks.Values) { tcs.TrySetCanceled(); }
+
+                _pendingSubscriptionAcks.Clear();
+            }
+        }
+
+        private void StartIdleCheckTimer() {
+            StopIdleCheckTimer();
+            _idleCheckTimer = new Timer {
+                AutoReset = true,
+                Interval = 5000  // Check every 5 seconds
             };
-            sc.RequestStream.WriteAsync(heartbeatRequest);
+            _idleCheckTimer.Elapsed += (sender, args) => CheckForIdleTimeout();
+            _idleCheckTimer.Enabled = true;
         }
 
-        private void TimerFired(object sender, ElapsedEventArgs e) {
-            if (sender != _timer) {
-                // This timer was canceled; ignore
-                return;
+        private void StopIdleCheckTimer() {
+            if (_idleCheckTimer != null) {
+                _idleCheckTimer.Enabled = false;
+                _idleCheckTimer.Dispose();
+                _idleCheckTimer = null;
             }
-            if (_cancellationToken.IsCancellationRequested ||
-                _currentThreadToken.IsCancellationRequested) {
-                return;
+        }
+
+        private void CheckForIdleTimeout() {
+            if (_cancellationToken.IsCancellationRequested) { return; }
+
+            var idleTime = (DateTime.UtcNow - _lastResponseReceived).TotalSeconds;
+
+            // Early warnings at 10s and 20s to help diagnose slow connections
+            if (idleTime > 20.0 && _lastIdleWarningLevel < 2) {
+                _lastIdleWarningLevel = 2;
+                _remoteEagleClientLogger.LogLine(
+                        $"[IDLE_WARNING] No messages received in {idleTime:F1}s (timeout at {MaxIdleSeconds}s)");
+                LogConnectionEvent("idle_warning_20s", $"idle_time={idleTime:F1}s");
+            } else if (idleTime > 10.0 && _lastIdleWarningLevel < 1) {
+                _lastIdleWarningLevel = 1;
+                _remoteEagleClientLogger.LogLine(
+                        $"[IDLE_WARNING] No messages received in {idleTime:F1}s (timeout at {MaxIdleSeconds}s)");
+                LogConnectionEvent("idle_warning_10s", $"idle_time={idleTime:F1}s");
             }
 
-            AsyncDuplexStreamingCall<UpdateStreamRequest, UpdateStreamResponse> sc;
-            lock (this) { sc = _streamingCall; }
+            if (idleTime > MaxIdleSeconds) {
+                _remoteEagleClientLogger.LogLine(
+                        $"[IDLE_TIMEOUT] No messages received in {idleTime:F1}s (max={MaxIdleSeconds}s), forcing reconnect");
+                LogConnectionEvent("idle_timeout", $"idle_time={idleTime:F1}s");
 
-            if (sc == null) {
-                // Already canceled
-                return;
-            }
-
-            _timer.Enabled = false;
-            _timer.Dispose();
-            _timer = null;
-
-            var now = DateTime.UtcNow;
-            var lastResponseReceived = _lastResponseReceived;
-
-            var secondsSinceResponse = (now - lastResponseReceived).TotalSeconds;
-            if (secondsSinceResponse > 2.0 * HeartbeatTimerSeconds) {
                 var toCancel = _streamingCall;
-
                 if (toCancel != null) {
                     toCancel.Dispose();
-                    lock (this) {
-                        _streamingCall = null;
-                        Connect();
+                    lock (this) { _streamingCall = null; }
+                    Task.Run(() => Connect());
+                }
+            }
+        }
+
+        private void StartHeartbeatTimer() {
+            StopHeartbeatTimer();
+            _heartbeatTimer =
+                    new Timer { AutoReset = true, Interval = HeartbeatIntervalSeconds * 1000 };
+            _heartbeatTimer.Elapsed += (sender, args) => Task.Run(() => SendHeartbeat());
+            _heartbeatTimer.Enabled = true;
+        }
+
+        private void StopHeartbeatTimer() {
+            if (_heartbeatTimer != null) {
+                _heartbeatTimer.Enabled = false;
+                _heartbeatTimer.Dispose();
+                _heartbeatTimer = null;
+            }
+        }
+
+        private async Task SendHeartbeat() {
+            if (_cancellationToken.IsCancellationRequested) { return; }
+            if (_currentState != ConnectionState.Connected) { return; }
+
+            // Build sync status for all subscribed games
+            var heartbeatRequest = new HeartbeatRequest {
+                ClientTimestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
+            };
+
+            List<IClientConnectionSubscriber> subscribers;
+            lock (this) { subscribers = _subscribers.Values.ToList(); }
+
+            foreach (var subscriber in subscribers) {
+                var gameSyncStatus = new GameSyncStatus {
+                    GameId = subscriber.GameId,
+                    UnfilteredResultCount = subscriber.LastUnfilteredResultCount
+                };
+
+                foreach (var shardokStatus in subscriber.ShardokViewStatuses) {
+                    gameSyncStatus.ShardokSyncStatuses.Add(new ShardokSyncStatus {
+                        ShardokGameId = shardokStatus.shardokGameId,
+                        FilteredResultCount = shardokStatus.filteredResultCount
+                    });
+                }
+
+                heartbeatRequest.GameSyncStatuses.Add(gameSyncStatus);
+            }
+
+            var request = new UpdateStreamRequest { HeartbeatRequest = heartbeatRequest };
+
+            var sent = await SendUpdateStreamRequestAsync(request);
+            if (sent) {
+                _remoteEagleClientLogger.LogLine(
+                        $"[HEARTBEAT] Sent heartbeat with {heartbeatRequest.GameSyncStatuses.Count} games");
+            }
+        }
+
+        private void HandleHeartbeatResponse(HeartbeatResponse response) {
+            _remoteEagleClientLogger.LogLine(
+                    $"[HEARTBEAT] Got response, server_timestamp={response.ServerTimestamp}");
+
+            // Check for sync mismatches reported by server
+            if (response.GameSyncResults.Count > 0) {
+                foreach (var syncResult in response.GameSyncResults) {
+                    if (!syncResult.EagleInSync) {
+                        _remoteEagleClientLogger.LogLine(
+                                $"[SYNC_MISMATCH] Game {syncResult.GameId}: Eagle out of sync, " +
+                                $"server has {syncResult.ServerUnfilteredResultCount} results");
+                        LogConnectionEvent(
+                                "sync_mismatch_eagle",
+                                $"game={syncResult.GameId}, server_count={syncResult.ServerUnfilteredResultCount}");
+                    }
+
+                    foreach (var shardokResult in syncResult.ShardokSyncResults) {
+                        if (!shardokResult.InSync) {
+                            _remoteEagleClientLogger.LogLine(
+                                    $"[SYNC_MISMATCH] Game {syncResult.GameId}, Shardok {shardokResult.ShardokGameId}: " +
+                                    $"out of sync, server has {shardokResult.ServerFilteredResultCount} results");
+                            LogConnectionEvent(
+                                    "sync_mismatch_shardok",
+                                    $"game={syncResult.GameId}, shardok={shardokResult.ShardokGameId}, " +
+                                            $"server_count={shardokResult.ServerFilteredResultCount}");
+                        }
                     }
                 }
-            } else if (secondsSinceResponse > HeartbeatTimerSeconds) {
-                SendHeartbeatRequest(sc);
+
+                // Trigger resync by reconnecting - this will re-subscribe with current counts
+                // and the server will send missing updates
+                _remoteEagleClientLogger.LogLine(
+                        "[SYNC_MISMATCH] Detected sync mismatch, triggering reconnect to resync");
+                LogConnectionEvent("sync_mismatch_reconnect", "Triggering reconnect to resync");
+
+                // Schedule reconnect to resync
+                lock (this) {
+                    _streamingCall?.Dispose();
+                    _streamingCall = null;
+                    _threadCancellationTokenSource?.Cancel();
+                }
+                MarkAllShardokGamesForResync();
+                CancelAllPendingSubscriptionAcks();
+                ScheduleReconnect("SyncMismatch");
             }
         }
     }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/EagleConnection.cs

@@ -12,7 +12,8 @@ public class EagleConnection : IDisposable {
     public readonly string playerName;
     public readonly Metadata credentials;
     public readonly string authHeader;
-    private const double KeepAliveSeconds = 45.0;
+    // Reduced from 45s to 15s for better NAT/firewall traversal
+    private const double KeepAliveSeconds = 15.0;
 
     public static CancellationToken EagleCancellationToken =>
             ConnectionKiller.EagleCancellationToken;

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/MainQueue.cs

@@ -1,12 +1,21 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using UnityEngine;
+using Debug = UnityEngine.Debug;
 
 public class MainQueue : MonoBehaviour {
     static MainQueue __singletonInstance;
     private readonly Queue<Action> _actionQueue = new();
     private readonly Queue<Action> _nextUpdateQueue = new();
 
+    // Time budget per frame to prevent blocking when resuming from background
+    // 8ms leaves room for rendering within a 16ms (60fps) frame budget
+    private const long MaxMillisecondsPerFrame = 8;
+
+    // Track queue depth for logging
+    private int _lastLoggedQueueDepth = 0;
+
     private MainQueue() {}
 
     void Awake() {
@@ -15,6 +24,29 @@ public class MainQueue : MonoBehaviour {
 
     // Update is called once per frame
     void Update() {
+        int queueDepthBefore;
+        lock (_actionQueue) { queueDepthBefore = _actionQueue.Count; }
+
+        // Fast path: skip processing if queue is empty
+        if (queueDepthBefore == 0) {
+            lock (_nextUpdateQueue) {
+                if (_nextUpdateQueue.Count > 0) {
+                    foreach (Action action in _nextUpdateQueue) { Enqueue(action); }
+                    _nextUpdateQueue.Clear();
+                }
+            }
+            return;
+        }
+
+        // Log when queue has built up (e.g., after resuming from background)
+        if (queueDepthBefore > 100 && queueDepthBefore != _lastLoggedQueueDepth) {
+            Debug.Log($"[MainQueue] Processing backlog: {queueDepthBefore} actions queued");
+            _lastLoggedQueueDepth = queueDepthBefore;
+        } else if (queueDepthBefore <= 100) {
+            _lastLoggedQueueDepth = 0;
+        }
+
+        var stopwatch = Stopwatch.StartNew();
         Action possibleAction;
         do {
             possibleAction = null;
@@ -23,7 +55,7 @@ public class MainQueue : MonoBehaviour {
             }
 
             if (possibleAction != null) { possibleAction.Invoke(); }
-        } while (possibleAction != null);
+        } while (possibleAction != null && stopwatch.ElapsedMilliseconds < MaxMillisecondsPerFrame);
 
         lock (_nextUpdateQueue) {
             foreach (Action action in _nextUpdateQueue) { Enqueue(action); }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/SettingsPanelController.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Diagnostics;
 using System.IO;
+using common;
 using eagle;
 using Net.Eagle0.Shardok.Api;
 using TMPro;
@@ -27,6 +28,9 @@ public class SettingsPanelController : MonoBehaviour {
     public Toggle tooltipHugsCursorToggle;
     public HoveringTooltip hoveringTooltip;
 
+    public Slider autoScrollSpeedSlider;
+    public TMP_Text autoScrollSpeedLabel;
+
     public HexGrid hexGrid;
 
     private bool _active = false;
@@ -54,6 +58,11 @@ public class SettingsPanelController : MonoBehaviour {
 
         tooltipHugsCursorToggle.isOn = PlayerPrefs.GetInt(TooltipHugsCursorKey, 0) == 1;
         hoveringTooltip.HugsCursor = tooltipHugsCursorToggle.isOn;
+
+        if (autoScrollSpeedSlider != null) {
+            autoScrollSpeedSlider.value = AutoScrollingText.GlobalScrollSpeedMultiplier;
+            UpdateAutoScrollSpeedLabel(autoScrollSpeedSlider.value);
+        }
     }
 
     // Update is called once per frame
@@ -107,6 +116,21 @@ public class SettingsPanelController : MonoBehaviour {
         hoveringTooltip.HugsCursor = val;
     }
 
+    public void OnAutoScrollSpeedSliderChange(float val) {
+        AutoScrollingText.GlobalScrollSpeedMultiplier = val;
+        UpdateAutoScrollSpeedLabel(val);
+    }
+
+    private void UpdateAutoScrollSpeedLabel(float val) {
+        if (autoScrollSpeedLabel != null) {
+            if (val < 0.01f) {
+                autoScrollSpeedLabel.text = "Paused";
+            } else {
+                autoScrollSpeedLabel.text = $"{val:F2}x";
+            }
+        }
+    }
+
     public void OnResourcesFolderClick() {
         Process.Start(Path.Combine(Application.persistentDataPath, "eagle0", "Resources"));
     }

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Shardok/HexMesh.cs

@@ -22,6 +22,9 @@ public class HexMesh : MonoBehaviour {
     }
 
     public void Triangulate(IEnumerable<HexCell> cells) {
+        // Guard against Update() being called before SetUp() initializes hexMesh
+        if (hexMesh == null) return;
+
         hexMesh.Clear();
         vertices.Clear();
         triangles.Clear();

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Shardok/ShardokGameController.cs

@@ -74,6 +74,8 @@ namespace Shardok {
         public ActionResultTypeManager actionResultTypeManager;
 
         public Canvas eagleCanvas;
+        public TMP_Text connectionStatusLabel;
+        private bool _connectionStatusUIInitialized = false;
 
         public ShardokGameModel Model { get; private set; }
 
@@ -353,6 +355,17 @@ namespace Shardok {
             });
         }
 
+        public void SetConnection(eagle.PersistentClientConnection connection) {
+            if (!_connectionStatusUIInitialized && connectionStatusLabel != null &&
+                connection != null) {
+                var statusUI = connectionStatusLabel.GetComponent<eagle.ConnectionStatusUI>();
+                if (statusUI != null) {
+                    statusUI.SetConnection(connection);
+                    _connectionStatusUIInitialized = true;
+                }
+            }
+        }
+
         private void UpdateReserves() {
             reservesController.HeaderLabelText = "Reserves";
             reservesController.AllowSelection = false;
@@ -511,8 +524,8 @@ namespace Shardok {
             UnitViewWithName unit;
             if (!Model.UnitsById.TryGetValue(unitId, out unit)) { return "UNKNOWN"; }
 
-            if (unit.AttachedHero?.EagleHeroId is HeroId heroId) {
-                return Model.HeroNames[heroId];
+            if (unit.AttachedHero != null) {
+                return unit.Name ?? "Hero";
             } else if (unit.Battalion.Type == BattalionTypeId.Undead) {  // FIXME: hardcoded undead
                 if (unit.CommandingUnitId is UnitId commandingUnitId) {
                     return $"[[{HeroNameForUnitId(commandingUnitId)}]]";
@@ -948,7 +961,7 @@ namespace Shardok {
                                    commandTypeUIManager.CommandGroupForType(command.Type));
             }
 
-            if (allCommands.Any()) {
+            if (allCommands.Any() && mapMouseCoords != null) {
                 var meleeCommands = allCommands.Where(
                         command => CommandTypeUIManager.MeleeAttackGroup ==
                                    commandTypeUIManager.CommandGroupForType(command.Type));

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Shardok/ShardokGameModel.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using eagle;
 using eagle0;
+using UnityEngine;
 using Net.Eagle0.Shardok.Api;
 using Net.Eagle0.Shardok.Common;
 using UnityGoDiceInterface;
@@ -17,6 +18,23 @@ using static Net.Eagle0.Eagle.Api.ShardokPlacementCommands.Types;
 using Hostility = Net.Eagle0.Common.Hostility;
 
 public class ShardokGameModel {
+    private class HeroNameListener : IClientTextListener {
+        private readonly string _textId;
+        private readonly ShardokGameModel _model;
+
+        public HeroNameListener(string textId, ShardokGameModel model) {
+            _textId = textId;
+            _model = model;
+        }
+
+        public void OnTextUpdate(string text, bool completed) { _model.UpdateAction?.Invoke(); }
+
+        public string TextId() { return _textId; }
+    }
+
+    private readonly Dictionary<HeroId, string> _heroNameTextIds;
+    private readonly List<HeroNameListener> _heroNameListeners = new();
+
     public struct PlayerWithHostility {
         public PlayerId playerId;
         public string factionName;
@@ -31,10 +49,20 @@ public class ShardokGameModel {
     public int CastleCount { get; private set; }
     public Dictionary<UnitId, UnitViewWithName> UnitsById { get; }
     public Dictionary<UnitId, UnitViewWithName> ReserveUnitsById { get; }
-    public Dictionary<HeroId, ShardokGameId> HeroNames {
-            get; }  // Heroes always stay in this list even if they are removed from the game.
     public Dictionary<HeroId, ShardokGameId> HeroImages { get; }
     public Dictionary<BattalionId, ShardokGameId> BattalionNames { get; }
+
+    public string GetHeroNameTextId(HeroId heroId) {
+        _heroNameTextIds.TryGetValue(heroId, out var textId);
+        return textId;
+    }
+
+    public void CleanupListeners() {
+        foreach (var listener in _heroNameListeners) {
+            ClientTextProvider.Provider.RemoveListener(listener);
+        }
+        _heroNameListeners.Clear();
+    }
     public Dictionary<UnitId, PlayerId> UnitPlayers { get; }
     public List<UnitViewWithName> Units => UnitsById.Values.ToList();
     public List<UnitViewWithName> AllUncommittedUnits => ReserveUnitsById.Values.ToList();
@@ -83,6 +111,17 @@ public class ShardokGameModel {
 
     public bool InSetUp => GameStatus != null && GameStatus.State == GameStatus.Types.State.SetUp;
 
+    /// <summary>
+    /// Mark this battle as ended (called when battle is removed from Eagle before
+    /// we receive the final Shardok update, e.g., due to race conditions when
+    /// Unity was backgrounded).
+    /// </summary>
+    public void MarkBattleEnded(string reason) {
+        GameStatus =
+                new GameStatus { State = GameStatus.Types.State.Victory, Description = reason };
+        UpdateAction?.Invoke();
+    }
+
     private readonly PersistentClientConnection _persistentClientConnection;
 
     private const int StartingHistoryCapacity = 100;
@@ -98,7 +137,7 @@ public class ShardokGameModel {
             string locationName,
             int month,
             List<PlayerWithHostility> players,
-            Dictionary<HeroId, String> heroNames,
+            Dictionary<HeroId, String> heroNameTextIds,
             Dictionary<HeroId, String> heroImages,
             Dictionary<BattalionId, String> battalionNames,
             RollFetcher rollFetcher) {
@@ -116,12 +155,19 @@ public class ShardokGameModel {
 
         UnitsById = new Dictionary<UnitId, UnitViewWithName>();
         ReserveUnitsById = new Dictionary<UnitId, UnitViewWithName>();
-        HeroNames = heroNames;
+        _heroNameTextIds = heroNameTextIds;
         HeroImages = heroImages;
         BattalionNames = battalionNames;
         UnitPlayers = new Dictionary<UnitId, PlayerId>();
 
         PlayerTotals = players.Select(p => new PlayerTotals { PlayerId = p.playerId }).ToList();
+
+        // Set up listeners for hero names
+        foreach (var kv in _heroNameTextIds) {
+            var listener = new HeroNameListener(kv.Value, this);
+            _heroNameListeners.Add(listener);
+            ClientTextProvider.Provider.AddListener(listener);
+        }
     }
 
     public UnitViewWithName UnitAtCoords(Coords coords) {
@@ -139,7 +185,10 @@ public class ShardokGameModel {
         return null;
     }
 
-    public void HandleUpdates(
+    /// <summary>
+    /// Returns true if updates were handled successfully, false if a resync is needed.
+    /// </summary>
+    public bool HandleUpdates(
             IEnumerable<ActionResultView> newHistory,
             int expectedNewResultCount) {
         var existingHistoryCount = History.Count();
@@ -148,12 +197,16 @@ public class ShardokGameModel {
             var diff = existingHistoryCount + newHistoryCount - expectedNewResultCount;
             History.RemoveRange(existingHistoryCount - diff, diff);
         } else if (expectedNewResultCount > existingHistoryCount + newHistoryCount) {
-            throw new ArgumentException(
-                    $"Should have {expectedNewResultCount} results but we have {existingHistoryCount + newHistoryCount}");
+            // Missing results - likely due to dropped packets on bad network.
+            // Request a full resync instead of crashing.
+            Debug.Log(
+                    $"ShardokGameModel: Missing results (expected {expectedNewResultCount}, have {existingHistoryCount + newHistoryCount}). Requesting resync.");
+            return false;
         }
         foreach (ActionResultView entry in newHistory) { HandleNewHistoryEntry(entry); }
 
         if (newHistoryCount > 0 && UpdateAction != null) { UpdateAction.Invoke(); }
+        return true;
     }
 
     public void HandleAvailableCommands(AvailableCommands newCommands) {
@@ -360,10 +413,10 @@ public class ShardokGameModel {
             }
 
             foreach (UnitView changedUnit in gsvDiff.ChangedUnits) {
-                string name = null;
+                string heroNameTextId = null;
                 string headshotPath = null;
                 if (changedUnit.AttachedHero?.EagleHeroId is HeroId hid) {
-                    HeroNames.TryGetValue(hid, out name);
+                    heroNameTextId = GetHeroNameTextId(hid);
                     HeroImages.TryGetValue(hid, out headshotPath);
                 }
 
@@ -374,7 +427,7 @@ public class ShardokGameModel {
 
                 UnitsById[changedUnit.UnitId] = new UnitViewWithName(
                         uv: changedUnit,
-                        name: name,
+                        heroNameTextId: heroNameTextId,
                         battalionName: battalionName,
                         headshotPath: headshotPath);
                 UnitPlayers[changedUnit.UnitId] = changedUnit.PlayerId;
@@ -395,10 +448,10 @@ public class ShardokGameModel {
 
                 if (changedReserveUnit.PlayerId != PlayerId) { continue; }
 
-                string name = null;
+                string heroNameTextId = null;
                 string headshotPath = null;
                 if (changedReserveUnit.AttachedHero?.EagleHeroId is HeroId hid) {
-                    HeroNames.TryGetValue(hid, out name);
+                    heroNameTextId = GetHeroNameTextId(hid);
                     HeroImages.TryGetValue(hid, out headshotPath);
                 }
 
@@ -409,7 +462,7 @@ public class ShardokGameModel {
 
                 var uvwn = new UnitViewWithName(
                         uv: changedReserveUnit,
-                        name: name,
+                        heroNameTextId: heroNameTextId,
                         battalionName: battalionName,
                         headshotPath: headshotPath);
 

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/Shardok/Unit.cs

@@ -1,4 +1,5 @@
 using System;
+using eagle;
 using Net.Eagle0.Shardok.Api;
 using Net.Eagle0.Shardok.Common;
 
@@ -18,7 +19,7 @@ namespace eagle0 {
                 Coords newLocation) {
             UnitViewWithName newHero = new UnitViewWithName(
                     uv: unit.Unit.CopyAtLocation(newLocation),
-                    name: unit.Name,
+                    heroNameTextId: unit.HeroNameTextId,
                     battalionName: unit.BattalionName,
                     headshotPath: unit.HeadshotPath);
             return newHero;
@@ -27,10 +28,15 @@ namespace eagle0 {
 
     public class UnitViewWithName {
         public UnitView Unit { get; private set; }
-        public string Name { get; private set; }
+        public string HeroNameTextId { get; private set; }
         public string BattalionName { get; private set; }
         public string HeadshotPath { get; private set; }
 
+        public string Name =>
+                HeroNameTextId != null
+                        ? ClientTextProvider.Provider.GetTextEntry(HeroNameTextId)?.Text ?? "Hero"
+                        : null;
+
         public HeroView AttachedHero => Unit.AttachedHero;
         public BattalionView Battalion => Unit.Battalion;
         public bool Hidden => Unit.Hidden;
@@ -55,11 +61,11 @@ namespace eagle0 {
 
         public UnitViewWithName(
                 UnitView uv,
-                string name,
+                string heroNameTextId,
                 string battalionName,
                 string headshotPath) {
             Unit = uv;
-            Name = name;
+            HeroNameTextId = heroNameTextId;
             BattalionName = battalionName;
             HeadshotPath = headshotPath;
         }