Fix sysroot .so plugins and registry auth

- Exclude GCC plugin .so files from sysroot (Bazel can't handle them) - Only copy GCC headers and static libs needed for cross-compilation - Add tarball structure verification to build script - Fix DO registry auth by setting DOCKER_CONFIG env var for Bazel 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
Update sysroot sha256 for v2 with GCC directories
2026-07-28 23:15:41 +00:00 · 2025-12-23 08:50:44 -08:00 · 2025-12-23 08:34:47 -08:00 · 2025-12-23 08:30:55 -08:00 · 2025-12-23 08:23:04 -08:00 · 2025-12-23 08:12:19 -08:00
263 changed files with 18114 additions and 8541 deletions
@@ -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
@@ -6,4 +6,7 @@
 *.bytes filter=lfs diff=lfs merge=lfs -text
 *.psd filter=lfs diff=lfs merge=lfs -text
 *.ttf filter=lfs diff=lfs merge=lfs -text
+# Exclude pre-existing font files that were committed as blobs (not LFS pointers)
+src/main/csharp/**/GUI[[:space:]]Pro[[:space:]]Kit*/**/*.ttf !filter !diff !merge
+src/main/csharp/**/Modern[[:space:]]UI[[:space:]]Pack/**/*.ttf !filter !diff !merge
 *.herodata filter=lfs diff=lfs merge=lfs -text
@@ -0,0 +1,66 @@
+name: Build Linux Sysroot
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Sysroot version (e.g., v2, v3)'
+        required: true
+        default: 'v2'
+        type: string
+
+permissions:
+  contents: read
+
+jobs:
+  build-sysroot:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Build sysroot
+        run: ./tools/sysroot/build_sysroot.sh
+
+      - name: Upload sysroot artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: ubuntu-noble-sysroot
+          path: tools/sysroot/output/
+
+      - name: Install AWS CLI
+        run: |
+          if ! command -v aws &> /dev/null; then
+            curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
+            unzip -q awscliv2.zip
+            sudo ./aws/install
+          fi
+
+      - name: Upload to DigitalOcean Spaces
+        env:
+          AWS_ACCESS_KEY_ID: ${{ secrets.ACCESS_KEY_ID }}
+          AWS_SECRET_ACCESS_KEY: ${{ secrets.SECRET_KEY }}
+        run: |
+          # Upload sysroot tarball to DO Spaces (using eagle0-windows bucket, same as other workflows)
+          aws s3 cp tools/sysroot/output/ubuntu_noble_amd64_sysroot.tar.xz \
+            s3://eagle0-windows/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.tar.xz \
+            --endpoint-url https://sfo3.digitaloceanspaces.com \
+            --acl public-read
+
+          # Upload sha256 file
+          aws s3 cp tools/sysroot/output/ubuntu_noble_amd64_sysroot.sha256 \
+            s3://eagle0-windows/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.sha256 \
+            --endpoint-url https://sfo3.digitaloceanspaces.com \
+            --acl public-read
+
+          echo ""
+          echo "=== Sysroot uploaded ==="
+          echo "URL: https://eagle0-windows.sfo3.digitaloceanspaces.com/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.tar.xz"
+          echo "SHA256: $(cat tools/sysroot/output/ubuntu_noble_amd64_sysroot.sha256)"
+          echo ""
+          echo "Update MODULE.bazel with:"
+          echo "sysroot("
+          echo "    name = \"linux_sysroot\","
+          echo "    sha256 = \"$(cat tools/sysroot/output/ubuntu_noble_amd64_sysroot.sha256)\","
+          echo "    urls = [\"https://eagle0-windows.sfo3.digitaloceanspaces.com/sysroot/${{ inputs.version }}/ubuntu_noble_amd64_sysroot.tar.xz\"],"
+          echo ")"
@@ -0,0 +1,82 @@
+name: Docker Build and Push
+
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - 'src/main/cpp/**'
+      - 'src/main/scala/**'
+      - 'src/main/protobuf/**'
+      - 'src/main/resources/**'
+      - 'ci/BUILD.bazel'
+      - 'MODULE.bazel'
+      - '.github/workflows/docker_build.yml'
+  workflow_dispatch:
+    inputs:
+      push_images:
+        description: 'Push images to container registry'
+        required: true
+        default: 'false'
+        type: boolean
+
+permissions:
+  contents: read
+
+jobs:
+  build-eagle:
+    runs-on: self-hosted
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          lfs: false
+
+      - name: Build Eagle Docker image
+        run: bazel build //ci:eagle_server_image
+
+      - name: Login to DigitalOcean Container Registry
+        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+        env:
+          DO_TOKEN: ${{ secrets.DO_REGISTRY_TOKEN }}
+        run: |
+          mkdir -p ~/.docker
+          AUTH=$(echo -n "${DO_TOKEN}:${DO_TOKEN}" | base64)
+          echo "{\"auths\":{\"registry.digitalocean.com\":{\"auth\":\"${AUTH}\"}}}" > ~/.docker/config.json
+          # Also set for current directory in case Bazel uses different home
+          mkdir -p .docker
+          cp ~/.docker/config.json .docker/
+
+      - name: Push Eagle image to DO registry
+        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+        env:
+          DOCKER_CONFIG: ${{ github.workspace }}/.docker
+        run: bazel run //ci:eagle_server_push
+
+  build-shardok:
+    runs-on: self-hosted
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          lfs: false
+
+      - name: Build Shardok Docker image (cross-compile for Linux)
+        run: bazel build --platforms=//:linux_x86_64 //ci:shardok_server_image
+
+      - name: Login to DigitalOcean Container Registry
+        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+        env:
+          DO_TOKEN: ${{ secrets.DO_REGISTRY_TOKEN }}
+        run: |
+          mkdir -p ~/.docker
+          AUTH=$(echo -n "${DO_TOKEN}:${DO_TOKEN}" | base64)
+          echo "{\"auths\":{\"registry.digitalocean.com\":{\"auth\":\"${AUTH}\"}}}" > ~/.docker/config.json
+          # Also set for current directory in case Bazel uses different home
+          mkdir -p .docker
+          cp ~/.docker/config.json .docker/
+
+      - name: Push Shardok image to DO registry
+        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+        env:
+          DOCKER_CONFIG: ${{ github.workspace }}/.docker
+        run: bazel run --platforms=//:linux_x86_64 //ci:shardok_server_push
@@ -3,6 +3,15 @@ load("@io_bazel_rules_go//go:def.bzl", "nogo")

 package(default_visibility = ["//visibility:public"])

+# Platform for cross-compiling to Linux x86_64
+platform(
+    name = "linux_x86_64",
+    constraint_values = [
+        "@platforms//os:linux",
+        "@platforms//cpu:x86_64",
+    ],
+)
+
 gazelle(name = "gazelle")

 # gazelle:proto file
@@ -216,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:
@@ -254,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/`
@@ -26,50 +26,68 @@ scala_config = use_extension(
    "@rules_scala//scala/extensions:config.bzl",
    "scala_config",
 )
-
 scala_config.settings(scala_version = SCALA_VERSION)

 scala_deps = use_extension(
    "@rules_scala//scala/extensions:deps.bzl",
    "scala_deps",
 )
-
 scala_deps.scala()
-
 scala_deps.scalatest()
-
 scala_deps.scala_proto()

 #
 # Language Support - C++
 #

-bazel_dep(name = "toolchains_llvm", version = "1.4.0")
+bazel_dep(name = "toolchains_llvm", version = "1.6.0")

 llvm = use_extension("@toolchains_llvm//toolchain/extensions:llvm.bzl", "llvm")

+# Native toolchain (macOS -> macOS, Linux -> Linux)
 llvm.toolchain(
    name = "llvm_toolchain",
    llvm_version = "20.1.2",
 )

-use_repo(llvm, "llvm_toolchain")
+# Cross-compilation toolchain (macOS -> Linux x86_64)
+# Uses the same LLVM distribution but with a Linux sysroot
+llvm.toolchain(
+    name = "llvm_toolchain_linux",
+    llvm_version = "20.1.2",
+)
+
+# Linux sysroot for cross-compilation (Chromium's Debian sysroot)
+llvm.sysroot(
+    name = "llvm_toolchain_linux",
+    label = "@linux_sysroot//sysroot",
+    targets = ["linux-x86_64"],
+)
+
+use_repo(llvm, "llvm_toolchain", "llvm_toolchain_linux")
+
+# Download the Linux sysroot (Ubuntu 24.04 Noble for C++23 support)
+# Built by: .github/workflows/build_sysroot.yml
+# To rebuild: Run the "Build Linux Sysroot" workflow with a new version, then update sha256 and URL
+sysroot = use_repo_rule("@toolchains_llvm//toolchain:sysroot.bzl", "sysroot")
+sysroot(
+    name = "linux_sysroot",
+    sha256 = "aadb60a2e2c776ac000bb2e29f3039fd81b5b031500cf4a1651b365712819d1f",
+    urls = ["https://eagle0-windows.sfo3.digitaloceanspaces.com/sysroot/v2/ubuntu_noble_amd64_sysroot.tar.xz"],
+)

 #
 # Language Support - Go
 #

-bazel_dep(name = "rules_go", repo_name = "io_bazel_rules_go", version = "0.56.1")
-bazel_dep(name = "gazelle", repo_name = "bazel_gazelle", version = "0.45.0")
+bazel_dep(name = "rules_go", version = "0.56.1", repo_name = "io_bazel_rules_go")
+bazel_dep(name = "gazelle", version = "0.45.0", repo_name = "bazel_gazelle")

 go_sdk = use_extension("@io_bazel_rules_go//go:extensions.bzl", "go_sdk")
-
 go_sdk.download(version = "1.23.3")

 go_deps = use_extension("@bazel_gazelle//:extensions.bzl", "go_deps")
-
 go_deps.from_file(go_mod = "//:go.mod")
-
 use_repo(
    go_deps,
    "com_github_aws_aws_sdk_go_v2",
@@ -84,15 +102,15 @@ use_repo(
 # Platform Support - Apple/iOS
 #

-bazel_dep(name = "apple_support", repo_name = "build_bazel_apple_support", version = "1.21.1")
-bazel_dep(name = "rules_apple", repo_name = "build_bazel_rules_apple", version = "3.16.1")
-bazel_dep(name = "rules_swift", repo_name = "build_bazel_rules_swift", version = "2.3.1")
+bazel_dep(name = "apple_support", version = "1.21.1", repo_name = "build_bazel_apple_support")
+bazel_dep(name = "rules_apple", version = "3.16.1", repo_name = "build_bazel_rules_apple")
+bazel_dep(name = "rules_swift", version = "2.3.1", repo_name = "build_bazel_rules_swift")

 #
 # Protocol Buffers & RPC
 #

-bazel_dep(name = "protobuf", repo_name = "com_google_protobuf", version = "29.2")
+bazel_dep(name = "protobuf", version = "29.2", repo_name = "com_google_protobuf")
 bazel_dep(name = "grpc", version = "1.71.0")
 bazel_dep(name = "grpc-java", version = "1.71.0")
 bazel_dep(name = "flatbuffers", version = "25.2.10")
@@ -103,6 +121,32 @@ bazel_dep(name = "flatbuffers", version = "25.2.10")

 bazel_dep(name = "googletest", version = "1.17.0")

+#
+# Container Images (OCI)
+#
+
+bazel_dep(name = "rules_oci", version = "2.2.6")
+bazel_dep(name = "aspect_bazel_lib", version = "2.16.0")
+
+oci = use_extension("@rules_oci//oci:extensions.bzl", "oci")
+
+# Base image for Eagle (Java 17)
+oci.pull(
+    name = "eclipse_temurin_17",
+    digest = "sha256:d286b5352d98777bbf727f54038b04f0145cd9b76ca83f38a67aa111d4303748",
+    image = "docker.io/library/eclipse-temurin",
+    platforms = ["linux/amd64"],
+)
+
+# Base image for Shardok (Ubuntu 24.04 for C++ runtime)
+oci.pull(
+    name = "ubuntu_24_04",
+    image = "docker.io/library/ubuntu",
+    platforms = ["linux/amd64"],
+    tag = "24.04",
+)
+use_repo(oci, "eclipse_temurin_17", "eclipse_temurin_17_linux_amd64", "ubuntu_24_04", "ubuntu_24_04_linux_amd64")
+
 #
 # Java/Scala Dependencies
 #
@@ -110,7 +154,6 @@ bazel_dep(name = "googletest", version = "1.17.0")
 bazel_dep(name = "rules_jvm_external", version = "6.3")

 maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
-
 maven.install(
    artifacts = [
        # Netty
@@ -161,6 +204,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,
@@ -169,7 +216,6 @@ maven.install(
        "https://repo1.maven.org/maven2",
    ],
 )
-
 use_repo(maven, "maven", "unpinned_maven")

 #
@@ -217,5 +263,6 @@ register_toolchains(
 # Set dev_dependency so we can turn this off for swift MacOS builds
 register_toolchains(
    "@llvm_toolchain//:all",
+    "@llvm_toolchain_linux//:all",
    dev_dependency = True,
 )
@@ -26,7 +26,11 @@
    "https://bcr.bazel.build/modules/aspect_bazel_lib/1.38.0/MODULE.bazel": "6307fec451ba9962c1c969eb516ebfe1e46528f7fa92e1c9ac8646bef4cdaa3f",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/1.40.3/MODULE.bazel": "668e6bcb4d957fc0e284316dba546b705c8d43c857f87119619ee83c4555b859",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.11.0/MODULE.bazel": "cb1ba9f9999ed0bc08600c221f532c1ddd8d217686b32ba7d45b0713b5131452",
-    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.11.0/source.json": "92494d5aa43b96665397dd13ee16023097470fa85e276b93674d62a244de47ee",
+    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.14.0/MODULE.bazel": "2b31ffcc9bdc8295b2167e07a757dbbc9ac8906e7028e5170a3708cecaac119f",
+    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.16.0/MODULE.bazel": "852f9ebbda017572a7c113a2434592dd3b2f55cd9a0faea3d4be5a09a59e4900",
+    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.19.3/MODULE.bazel": "253d739ba126f62a5767d832765b12b59e9f8d2bc88cc1572f4a73e46eb298ca",
+    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.19.3/source.json": "ffab9254c65ba945f8369297ad97ca0dec213d3adc6e07877e23a48624a8b456",
+    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.7.2/MODULE.bazel": "780d1a6522b28f5edb7ea09630748720721dfe27690d65a2d33aa7509de77e07",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.7.7/MODULE.bazel": "491f8681205e31bb57892d67442ce448cda4f472a8e6b3dc062865e29a64f89c",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.8.1/MODULE.bazel": "812d2dd42f65dca362152101fbec418029cc8fd34cbad1a2fde905383d705838",
    "https://bcr.bazel.build/modules/aspect_bazel_lib/2.9.3/MODULE.bazel": "66baf724dbae7aff4787bf2245cc188d50cb08e07789769730151c0943587c14",
@@ -51,8 +55,11 @@
    "https://bcr.bazel.build/modules/bazel_features/1.19.0/MODULE.bazel": "59adcdf28230d220f0067b1f435b8537dd033bfff8db21335ef9217919c7fb58",
    "https://bcr.bazel.build/modules/bazel_features/1.21.0/MODULE.bazel": "675642261665d8eea09989aa3b8afb5c37627f1be178382c320d1b46afba5e3b",
    "https://bcr.bazel.build/modules/bazel_features/1.27.0/MODULE.bazel": "621eeee06c4458a9121d1f104efb80f39d34deff4984e778359c60eaf1a8cb65",
-    "https://bcr.bazel.build/modules/bazel_features/1.27.0/source.json": "ed8cf0ef05c858dce3661689d0a2b110ff398e63994e178e4f1f7555a8067fed",
+    "https://bcr.bazel.build/modules/bazel_features/1.28.0/MODULE.bazel": "4b4200e6cbf8fa335b2c3f43e1d6ef3e240319c33d43d60cc0fbd4b87ece299d",
    "https://bcr.bazel.build/modules/bazel_features/1.3.0/MODULE.bazel": "cdcafe83ec318cda34e02948e81d790aab8df7a929cec6f6969f13a489ccecd9",
+    "https://bcr.bazel.build/modules/bazel_features/1.34.0/MODULE.bazel": "e8475ad7c8965542e0c7aac8af68eb48c4af904be3d614b6aa6274c092c2ea1e",
+    "https://bcr.bazel.build/modules/bazel_features/1.38.0/MODULE.bazel": "f9b8a9c890ebd216b4049fd12a31d3c2602e3403c7af636b04fbbd7453edc9c9",
+    "https://bcr.bazel.build/modules/bazel_features/1.38.0/source.json": "31ba776c122b54a2885e23651642e32f087a87bf025465f8040751894b571277",
    "https://bcr.bazel.build/modules/bazel_features/1.4.1/MODULE.bazel": "e45b6bb2350aff3e442ae1111c555e27eac1d915e77775f6fdc4b351b758b5d7",
    "https://bcr.bazel.build/modules/bazel_features/1.9.0/MODULE.bazel": "885151d58d90d8d9c811eb75e3288c11f850e1d6b481a8c9f766adee4712358b",
    "https://bcr.bazel.build/modules/bazel_features/1.9.1/MODULE.bazel": "8f679097876a9b609ad1f60249c49d68bfab783dd9be012faf9d82547b14815a",
@@ -69,7 +76,8 @@
    "https://bcr.bazel.build/modules/bazel_skylib/1.7.0/MODULE.bazel": "0db596f4563de7938de764cc8deeabec291f55e8ec15299718b93c4423e9796d",
    "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/MODULE.bazel": "3120d80c5861aa616222ec015332e5f8d3171e062e3e804a2a0253e1be26e59b",
    "https://bcr.bazel.build/modules/bazel_skylib/1.8.1/MODULE.bazel": "88ade7293becda963e0e3ea33e7d54d3425127e0a326e0d17da085a5f1f03ff6",
-    "https://bcr.bazel.build/modules/bazel_skylib/1.8.1/source.json": "7ebaefba0b03efe59cac88ed5bbc67bcf59a3eff33af937345ede2a38b2d368a",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.8.2/MODULE.bazel": "69ad6927098316848b34a9142bcc975e018ba27f08c4ff403f50c1b6e646ca67",
+    "https://bcr.bazel.build/modules/bazel_skylib/1.8.2/source.json": "34a3c8bcf233b835eb74be9d628899bb32999d3e0eadef1947a0a562a2b16ffb",
    "https://bcr.bazel.build/modules/bazel_worker_api/0.0.6/MODULE.bazel": "fd1f9432ca04c947e91b500df69ce7c5b6dbfe1bc45ab1820338205dae3383a6",
    "https://bcr.bazel.build/modules/bazel_worker_api/0.0.6/source.json": "5d68545f224904745a3cabd35aea6bc2b6cc5a78b7f49f3f69660eab2eeeb273",
    "https://bcr.bazel.build/modules/boringssl/0.0.0-20211025-d4f1ab9/MODULE.bazel": "6ee6353f8b1a701fe2178e1d925034294971350b6d3ac37e67e5a7d463267834",
@@ -98,6 +106,8 @@
    "https://bcr.bazel.build/modules/envoy_api/0.0.0-20250128-4de3c74/source.json": "028519164a2e24563f4b43d810fdedc702daed90e71e7042d45ba82ad807b46f",
    "https://bcr.bazel.build/modules/flatbuffers/25.2.10/MODULE.bazel": "dab15cafe8512d2c4a8daa44c2d7968c5c79f01e220d40076cdc260bf58605e2",
    "https://bcr.bazel.build/modules/flatbuffers/25.2.10/source.json": "7eae7ea3eb913b9802426e4d5df11d6c6072a3573a548f8cabf1e965f5cca4d0",
+    "https://bcr.bazel.build/modules/gawk/5.3.2.bcr.1/MODULE.bazel": "cdf8cbe5ee750db04b78878c9633cc76e80dcf4416cbe982ac3a9222f80713c8",
+    "https://bcr.bazel.build/modules/gawk/5.3.2.bcr.1/source.json": "fa7b512dfcb5eafd90ce3959cf42a2a6fe96144ebbb4b3b3928054895f2afac2",
    "https://bcr.bazel.build/modules/gazelle/0.27.0/MODULE.bazel": "3446abd608295de6d90b4a8a118ed64a9ce11dcb3dda2dc3290a22056bd20996",
    "https://bcr.bazel.build/modules/gazelle/0.30.0/MODULE.bazel": "f888a1effe338491f35f0e0e85003b47bb9d8295ccba73c37e07702d8d31c65b",
    "https://bcr.bazel.build/modules/gazelle/0.32.0/MODULE.bazel": "b499f58a5d0d3537f3cf5b76d8ada18242f64ec474d8391247438bf04f58c7b8",
@@ -137,6 +147,10 @@
    "https://bcr.bazel.build/modules/grpc/1.70.1/MODULE.bazel": "b800cd8e3e7555c1e61cba2e02d3a2fcf0e91f66e800db286d965d3b7a6a721a",
    "https://bcr.bazel.build/modules/grpc/1.71.0/MODULE.bazel": "7fcab2c05530373f1a442c362b17740dd0c75b6a2a975eec8f5bf4c70a37928a",
    "https://bcr.bazel.build/modules/grpc/1.71.0/source.json": "60ef8c4c72c8280ae94c05b4f38bf67785acb25477ab8dbac096a9604449ff90",
+    "https://bcr.bazel.build/modules/helly25_bzl/0.3.1/MODULE.bazel": "3a4be20f6fc13be32ad44643b8252ef5af09eee936f1d943cd4fd7867fa92826",
+    "https://bcr.bazel.build/modules/helly25_bzl/0.3.1/source.json": "b129ab1828492de2c163785bbeb4065c166de52d932524b4317beb5b7f917994",
+    "https://bcr.bazel.build/modules/jq.bzl/0.1.0/MODULE.bazel": "2ce69b1af49952cd4121a9c3055faa679e748ce774c7f1fda9657f936cae902f",
+    "https://bcr.bazel.build/modules/jq.bzl/0.1.0/source.json": "746bf13cac0860f091df5e4911d0c593971cd8796b5ad4e809b2f8e133eee3d5",
    "https://bcr.bazel.build/modules/jsoncpp/1.9.5/MODULE.bazel": "31271aedc59e815656f5736f282bb7509a97c7ecb43e927ac1a37966e0578075",
    "https://bcr.bazel.build/modules/jsoncpp/1.9.5/source.json": "4108ee5085dd2885a341c7fab149429db457b3169b86eb081fa245eadf69169d",
    "https://bcr.bazel.build/modules/libpfm/4.11.0/MODULE.bazel": "45061ff025b301940f1e30d2c16bea596c25b176c8b6b3087e92615adbd52902",
@@ -161,6 +175,7 @@
    "https://bcr.bazel.build/modules/opentelemetry-proto/1.5.0/source.json": "046b721ce203e88cdaad44d7dd17a86b7200eab9388b663b234e72e13ff7b143",
    "https://bcr.bazel.build/modules/opentracing-cpp/1.6.0/MODULE.bazel": "b3925269f63561b8b880ae7cf62ccf81f6ece55b62cd791eda9925147ae116ec",
    "https://bcr.bazel.build/modules/opentracing-cpp/1.6.0/source.json": "da1cb1add160f5e5074b7272e9db6fd8f1b3336c15032cd0a653af9d2f484aed",
+    "https://bcr.bazel.build/modules/package_metadata/0.0.2/MODULE.bazel": "fb8d25550742674d63d7b250063d4580ca530499f045d70748b1b142081ebb92",
    "https://bcr.bazel.build/modules/package_metadata/0.0.5/MODULE.bazel": "ef4f9439e3270fdd6b9fd4dbc3d2f29d13888e44c529a1b243f7a31dfbc2e8e4",
    "https://bcr.bazel.build/modules/package_metadata/0.0.5/source.json": "2326db2f6592578177751c3e1f74786b79382cd6008834c9d01ec865b9126a85",
    "https://bcr.bazel.build/modules/platforms/0.0.10/MODULE.bazel": "8cb8efaf200bdeb2150d93e162c40f388529a25852b332cec879373771e48ed5",
@@ -225,12 +240,14 @@
    "https://bcr.bazel.build/modules/rules_cc/0.0.15/MODULE.bazel": "6704c35f7b4a72502ee81f61bf88706b54f06b3cbe5558ac17e2e14666cd5dcc",
    "https://bcr.bazel.build/modules/rules_cc/0.0.16/MODULE.bazel": "7661303b8fc1b4d7f532e54e9d6565771fea666fbdf839e0a86affcd02defe87",
    "https://bcr.bazel.build/modules/rules_cc/0.0.17/MODULE.bazel": "2ae1d8f4238ec67d7185d8861cb0a2cdf4bc608697c331b95bf990e69b62e64a",
-    "https://bcr.bazel.build/modules/rules_cc/0.0.17/source.json": "4db99b3f55c90ab28d14552aa0632533e3e8e5e9aea0f5c24ac0014282c2a7c5",
    "https://bcr.bazel.build/modules/rules_cc/0.0.2/MODULE.bazel": "6915987c90970493ab97393024c156ea8fb9f3bea953b2f3ec05c34f19b5695c",
    "https://bcr.bazel.build/modules/rules_cc/0.0.5/MODULE.bazel": "be41f87587998fe8890cd82ea4e848ed8eb799e053c224f78f3ff7fe1a1d9b74",
    "https://bcr.bazel.build/modules/rules_cc/0.0.6/MODULE.bazel": "abf360251023dfe3efcef65ab9d56beefa8394d4176dd29529750e1c57eaa33f",
    "https://bcr.bazel.build/modules/rules_cc/0.0.8/MODULE.bazel": "964c85c82cfeb6f3855e6a07054fdb159aced38e99a5eecf7bce9d53990afa3e",
    "https://bcr.bazel.build/modules/rules_cc/0.0.9/MODULE.bazel": "836e76439f354b89afe6a911a7adf59a6b2518fafb174483ad78a2a2fde7b1c5",
+    "https://bcr.bazel.build/modules/rules_cc/0.1.1/MODULE.bazel": "2f0222a6f229f0bf44cd711dc13c858dad98c62d52bd51d8fc3a764a83125513",
+    "https://bcr.bazel.build/modules/rules_cc/0.2.14/MODULE.bazel": "353c99ed148887ee89c54a17d4100ae7e7e436593d104b668476019023b58df8",
+    "https://bcr.bazel.build/modules/rules_cc/0.2.14/source.json": "55d0a4587c5592fad350f6e698530f4faf0e7dd15e69d43f8d87e220c78bea54",
    "https://bcr.bazel.build/modules/rules_foreign_cc/0.10.1/MODULE.bazel": "b9527010e5fef060af92b6724edb3691970a5b1f76f74b21d39f7d433641be60",
    "https://bcr.bazel.build/modules/rules_foreign_cc/0.10.1/source.json": "9300e71df0cdde0952f10afff1401fa664e9fc5d9ae6204660ba1b158d90d6a6",
    "https://bcr.bazel.build/modules/rules_foreign_cc/0.9.0/MODULE.bazel": "c9e8c682bf75b0e7c704166d79b599f93b72cfca5ad7477df596947891feeef6",
@@ -289,6 +306,8 @@
    "https://bcr.bazel.build/modules/rules_nodejs/6.3.0/MODULE.bazel": "45345e4aba35dd6e4701c1eebf5a4e67af4ed708def9ebcdc6027585b34ee52d",
    "https://bcr.bazel.build/modules/rules_nodejs/6.3.3/MODULE.bazel": "b66eadebd10f1f1b25f52f95ab5213a57e82c37c3f656fcd9a57ad04d2264ce7",
    "https://bcr.bazel.build/modules/rules_nodejs/6.3.3/source.json": "45bd343155bdfed2543f0e39b80ff3f6840efc31975da4b5795797f4c94147ad",
+    "https://bcr.bazel.build/modules/rules_oci/2.2.6/MODULE.bazel": "2ba6ddd679269e00aeffe9ca04faa2d0ca4129650982c9246d0d459fe2da47d9",
+    "https://bcr.bazel.build/modules/rules_oci/2.2.6/source.json": "94e7decb8f95d9465b0bbea71c65064cd16083be1350c7468f131818641dc4a5",
    "https://bcr.bazel.build/modules/rules_pkg/0.7.0/MODULE.bazel": "df99f03fc7934a4737122518bb87e667e62d780b610910f0447665a7e2be62dc",
    "https://bcr.bazel.build/modules/rules_pkg/1.0.1/MODULE.bazel": "5b1df97dbc29623bccdf2b0dcd0f5cb08e2f2c9050aab1092fd39a41e82686ff",
    "https://bcr.bazel.build/modules/rules_pkg/1.1.0/MODULE.bazel": "9db8031e71b6ef32d1846106e10dd0ee2deac042bd9a2de22b4761b0c3036453",
@@ -321,7 +340,8 @@
    "https://bcr.bazel.build/modules/rules_scala/7.1.1/source.json": "5038cb231d4020c5965c920681cf961a7bf137b40315025e40f3a7b6a0ac1f0f",
    "https://bcr.bazel.build/modules/rules_shell/0.2.0/MODULE.bazel": "fda8a652ab3c7d8fee214de05e7a9916d8b28082234e8d2c0094505c5268ed3c",
    "https://bcr.bazel.build/modules/rules_shell/0.3.0/MODULE.bazel": "de4402cd12f4cc8fda2354fce179fdb068c0b9ca1ec2d2b17b3e21b24c1a937b",
-    "https://bcr.bazel.build/modules/rules_shell/0.3.0/source.json": "c55ed591aa5009401ddf80ded9762ac32c358d2517ee7820be981e2de9756cf3",
+    "https://bcr.bazel.build/modules/rules_shell/0.4.1/MODULE.bazel": "00e501db01bbf4e3e1dd1595959092c2fadf2087b2852d3f553b5370f5633592",
+    "https://bcr.bazel.build/modules/rules_shell/0.4.1/source.json": "4757bd277fe1567763991c4425b483477bb82e35e777a56fd846eb5cceda324a",
    "https://bcr.bazel.build/modules/rules_swift/1.16.0/MODULE.bazel": "4a09f199545a60d09895e8281362b1ff3bb08bbde69c6fc87aff5b92fcc916ca",
    "https://bcr.bazel.build/modules/rules_swift/1.18.0/MODULE.bazel": "a6aba73625d0dc64c7b4a1e831549b6e375fbddb9d2dde9d80c9de6ec45b24c9",
    "https://bcr.bazel.build/modules/rules_swift/2.1.1/MODULE.bazel": "494900a80f944fc7aa61500c2073d9729dff0b764f0e89b824eb746959bc1046",
@@ -339,14 +359,19 @@
    "https://bcr.bazel.build/modules/stardoc/0.7.2/source.json": "58b029e5e901d6802967754adf0a9056747e8176f017cfe3607c0851f4d42216",
    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.1/MODULE.bazel": "5e463fbfba7b1701d957555ed45097d7f984211330106ccd1352c6e0af0dcf91",
    "https://bcr.bazel.build/modules/swift_argument_parser/1.3.1.1/source.json": "32bd87e5f4d7acc57c5b2ff7c325ae3061d5e242c0c4c214ae87e0f1c13e54cb",
-    "https://bcr.bazel.build/modules/toolchains_llvm/1.4.0/MODULE.bazel": "05239402b7374293359c2f22806f420b75aa5d6f4b15a2eaa809a2c214d58b31",
-    "https://bcr.bazel.build/modules/toolchains_llvm/1.4.0/source.json": "229a516d282b17a82be54c6e3ae220a1b750fb55a8495567e5c7a9d09423f3e2",
+    "https://bcr.bazel.build/modules/tar.bzl/0.2.1/MODULE.bazel": "52d1c00a80a8cc67acbd01649e83d8dd6a9dc426a6c0b754a04fe8c219c76468",
+    "https://bcr.bazel.build/modules/tar.bzl/0.6.0/MODULE.bazel": "a3584b4edcfafcabd9b0ef9819808f05b372957bbdff41601429d5fd0aac2e7c",
+    "https://bcr.bazel.build/modules/tar.bzl/0.6.0/source.json": "4a620381df075a16cb3a7ed57bd1d05f7480222394c64a20fa51bdb636fda658",
+    "https://bcr.bazel.build/modules/toolchains_llvm/1.6.0/MODULE.bazel": "39603859cafb1c6830160fcd6370552e836790e6abb2bfb8d13bff53c0c10a64",
+    "https://bcr.bazel.build/modules/toolchains_llvm/1.6.0/source.json": "6bd3ef95a288dd2bb1582eca332af850c9a5428a23bb92cb1c57c2dfe6cb7369",
    "https://bcr.bazel.build/modules/upb/0.0.0-20211020-160625a/MODULE.bazel": "6cced416be2dc5b9c05efd5b997049ba795e5e4e6fafbe1624f4587767638928",
    "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/MODULE.bazel": "7298990c00040a0e2f121f6c32544bab27d4452f80d9ce51349b1a28f3005c43",
    "https://bcr.bazel.build/modules/upb/0.0.0-20230516-61a97ef/MODULE.bazel": "c0df5e35ad55e264160417fd0875932ee3c9dda63d9fccace35ac62f45e1b6f9",
    "https://bcr.bazel.build/modules/upb/0.0.0-20230907-e7430e6/MODULE.bazel": "3a7dedadf70346e678dc059dbe44d05cbf3ab17f1ce43a1c7a42edc7cbf93fd9",
    "https://bcr.bazel.build/modules/xds/0.0.0-20240423-555b57e/MODULE.bazel": "cea509976a77e34131411684ef05a1d6ad194dd71a8d5816643bc5b0af16dc0f",
    "https://bcr.bazel.build/modules/xds/0.0.0-20240423-555b57e/source.json": "7227e1fcad55f3f3cab1a08691ecd753cb29cc6380a47bc650851be9f9ad6d20",
+    "https://bcr.bazel.build/modules/yq.bzl/0.1.1/MODULE.bazel": "9039681f9bcb8958ee2c87ffc74bdafba9f4369096a2b5634b88abc0eaefa072",
+    "https://bcr.bazel.build/modules/yq.bzl/0.1.1/source.json": "2d2bad780a9f2b9195a4a370314d2c17ae95eaa745cefc2e12fbc49759b15aa3",
    "https://bcr.bazel.build/modules/zlib/1.2.11/MODULE.bazel": "07b389abc85fdbca459b69e2ec656ae5622873af3f845e1c9d80fe179f3effa0",
    "https://bcr.bazel.build/modules/zlib/1.2.12/MODULE.bazel": "3b1a8834ada2a883674be8cbd36ede1b6ec481477ada359cd2d3ddc562340b27",
    "https://bcr.bazel.build/modules/zlib/1.2.13/MODULE.bazel": "aa6deb1b83c18ffecd940c4119aff9567cd0a671d7bba756741cb2ef043a29d5",
@@ -388,7 +413,7 @@
    },
    "@@aspect_rules_esbuild~//esbuild:extensions.bzl%esbuild": {
      "general": {
-        "bzlTransitiveDigest": "8iOqbPY5ve3DvjzaI1mJZ8XTiJypN2PeWvcKOvmZLy8=",
+        "bzlTransitiveDigest": "8jv3p0xDR/oitFeH8y0+Y5xlyrUbfsTRlc9TSwYkwl8=",
        "usagesDigest": "iDVoyPxUeADmfK8ssoyG3Ehq1bj6p7A43LpEiE266os=",
        "recordedFileInputs": {},
        "recordedDirentsInputs": {},
@@ -1265,6 +1290,247 @@
        "recordedRepoMappingEntries": []
      }
    },
+    "@@rules_oci~//oci:extensions.bzl%oci": {
+      "general": {
+        "bzlTransitiveDigest": "FaY+7xb13bB3hmxqwAWaGp3Tf3Q4Nfdlr+F38CP5mcg=",
+        "usagesDigest": "BuciKSozbpJMD9EP+j0RG5ZgrYMeDPsQyiOnLUni2V8=",
+        "recordedFileInputs": {},
+        "recordedDirentsInputs": {},
+        "envVariables": {},
+        "generatedRepoSpecs": {
+          "eclipse_temurin_17_linux_amd64": {
+            "bzlFile": "@@rules_oci~//oci/private:pull.bzl",
+            "ruleClassName": "oci_pull",
+            "attributes": {
+              "www_authenticate_challenges": {},
+              "scheme": "https",
+              "registry": "index.docker.io",
+              "repository": "library/eclipse-temurin",
+              "identifier": "sha256:d286b5352d98777bbf727f54038b04f0145cd9b76ca83f38a67aa111d4303748",
+              "platform": "linux/amd64",
+              "target_name": "eclipse_temurin_17_linux_amd64",
+              "bazel_tags": []
+            }
+          },
+          "eclipse_temurin_17": {
+            "bzlFile": "@@rules_oci~//oci/private:pull.bzl",
+            "ruleClassName": "oci_alias",
+            "attributes": {
+              "target_name": "eclipse_temurin_17",
+              "www_authenticate_challenges": {},
+              "scheme": "https",
+              "registry": "index.docker.io",
+              "repository": "library/eclipse-temurin",
+              "identifier": "sha256:d286b5352d98777bbf727f54038b04f0145cd9b76ca83f38a67aa111d4303748",
+              "platforms": {
+                "@@platforms//cpu:x86_64": "@eclipse_temurin_17_linux_amd64"
+              },
+              "bzlmod_repository": "eclipse_temurin_17",
+              "reproducible": true
+            }
+          },
+          "ubuntu_24_04_linux_amd64": {
+            "bzlFile": "@@rules_oci~//oci/private:pull.bzl",
+            "ruleClassName": "oci_pull",
+            "attributes": {
+              "www_authenticate_challenges": {},
+              "scheme": "https",
+              "registry": "index.docker.io",
+              "repository": "library/ubuntu",
+              "identifier": "24.04",
+              "platform": "linux/amd64",
+              "target_name": "ubuntu_24_04_linux_amd64",
+              "bazel_tags": []
+            }
+          },
+          "ubuntu_24_04": {
+            "bzlFile": "@@rules_oci~//oci/private:pull.bzl",
+            "ruleClassName": "oci_alias",
+            "attributes": {
+              "target_name": "ubuntu_24_04",
+              "www_authenticate_challenges": {},
+              "scheme": "https",
+              "registry": "index.docker.io",
+              "repository": "library/ubuntu",
+              "identifier": "24.04",
+              "platforms": {
+                "@@platforms//cpu:x86_64": "@ubuntu_24_04_linux_amd64"
+              },
+              "bzlmod_repository": "ubuntu_24_04",
+              "reproducible": true
+            }
+          },
+          "oci_crane_darwin_amd64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "darwin_amd64",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_darwin_arm64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "darwin_arm64",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_linux_arm64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "linux_arm64",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_linux_armv6": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "linux_armv6",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_linux_i386": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "linux_i386",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_linux_s390x": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "linux_s390x",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_linux_amd64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "linux_amd64",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_windows_armv6": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "windows_armv6",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_windows_amd64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "crane_repositories",
+            "attributes": {
+              "platform": "windows_amd64",
+              "crane_version": "v0.18.0"
+            }
+          },
+          "oci_crane_toolchains": {
+            "bzlFile": "@@rules_oci~//oci/private:toolchains_repo.bzl",
+            "ruleClassName": "toolchains_repo",
+            "attributes": {
+              "toolchain_type": "@rules_oci//oci:crane_toolchain_type",
+              "toolchain": "@oci_crane_{platform}//:crane_toolchain"
+            }
+          },
+          "oci_regctl_darwin_amd64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "regctl_repositories",
+            "attributes": {
+              "platform": "darwin_amd64"
+            }
+          },
+          "oci_regctl_darwin_arm64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "regctl_repositories",
+            "attributes": {
+              "platform": "darwin_arm64"
+            }
+          },
+          "oci_regctl_linux_arm64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "regctl_repositories",
+            "attributes": {
+              "platform": "linux_arm64"
+            }
+          },
+          "oci_regctl_linux_s390x": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "regctl_repositories",
+            "attributes": {
+              "platform": "linux_s390x"
+            }
+          },
+          "oci_regctl_linux_amd64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "regctl_repositories",
+            "attributes": {
+              "platform": "linux_amd64"
+            }
+          },
+          "oci_regctl_windows_amd64": {
+            "bzlFile": "@@rules_oci~//oci:repositories.bzl",
+            "ruleClassName": "regctl_repositories",
+            "attributes": {
+              "platform": "windows_amd64"
+            }
+          },
+          "oci_regctl_toolchains": {
+            "bzlFile": "@@rules_oci~//oci/private:toolchains_repo.bzl",
+            "ruleClassName": "toolchains_repo",
+            "attributes": {
+              "toolchain_type": "@rules_oci//oci:regctl_toolchain_type",
+              "toolchain": "@oci_regctl_{platform}//:regctl_toolchain"
+            }
+          }
+        },
+        "moduleExtensionMetadata": {
+          "explicitRootModuleDirectDeps": [
+            "eclipse_temurin_17",
+            "eclipse_temurin_17_linux_amd64",
+            "ubuntu_24_04",
+            "ubuntu_24_04_linux_amd64"
+          ],
+          "explicitRootModuleDirectDevDeps": [],
+          "useAllRepos": "NO",
+          "reproducible": false
+        },
+        "recordedRepoMappingEntries": [
+          [
+            "aspect_bazel_lib~",
+            "bazel_tools",
+            "bazel_tools"
+          ],
+          [
+            "bazel_features~",
+            "bazel_tools",
+            "bazel_tools"
+          ],
+          [
+            "rules_oci~",
+            "aspect_bazel_lib",
+            "aspect_bazel_lib~"
+          ],
+          [
+            "rules_oci~",
+            "bazel_features",
+            "bazel_features~"
+          ],
+          [
+            "rules_oci~",
+            "bazel_skylib",
+            "bazel_skylib~"
+          ]
+        ]
+      }
+    },
    "@@rules_scala~//scala/extensions:config.bzl%scala_config": {
      "general": {
        "bzlTransitiveDigest": "TdBxhkZTM7VU6teIFS+KoonKU7wmb5BL7leCWWx7yX8=",
@@ -1293,7 +1559,7 @@
    },
    "@@rules_scala~//scala/extensions:deps.bzl%scala_deps": {
      "general": {
-        "bzlTransitiveDigest": "F2PMm61fmZ/IE+VSw1rigJ71hBDD7k3vqyYR1/GgXeA=",
+        "bzlTransitiveDigest": "5SDZrXQHW6tI/VEw+La2OPOK4ZWm0LGTxnChXOXBCag=",
        "usagesDigest": "kwo8oolISmSSITnit4b4S0vBiUtHlHK0WLDUwScxmOg=",
        "recordedFileInputs": {},
        "recordedDirentsInputs": {},
@@ -4904,85 +5170,6 @@
          ]
        ]
      }
-    },
-    "@@toolchains_llvm~//toolchain/extensions:llvm.bzl%llvm": {
-      "general": {
-        "bzlTransitiveDigest": "afRF0aFOIUrkYl3o040WQ606ep1qciEXzjnAxT3Kek8=",
-        "usagesDigest": "sYVuhiCAQehFTnGTv0bNtTBR4WorebpWBNxF0mRusyw=",
-        "recordedFileInputs": {},
-        "recordedDirentsInputs": {},
-        "envVariables": {},
-        "generatedRepoSpecs": {
-          "llvm_toolchain_llvm": {
-            "bzlFile": "@@toolchains_llvm~//toolchain:rules.bzl",
-            "ruleClassName": "llvm",
-            "attributes": {
-              "alternative_llvm_sources": [],
-              "auth_patterns": {},
-              "distribution": "auto",
-              "exec_arch": "",
-              "exec_os": "",
-              "libclang_rt": {},
-              "llvm_mirror": "",
-              "llvm_version": "20.1.2",
-              "llvm_versions": {},
-              "netrc": "",
-              "sha256": {},
-              "strip_prefix": {},
-              "urls": {}
-            }
-          },
-          "llvm_toolchain": {
-            "bzlFile": "@@toolchains_llvm~//toolchain:rules.bzl",
-            "ruleClassName": "toolchain",
-            "attributes": {
-              "absolute_paths": false,
-              "archive_flags": {},
-              "compile_flags": {},
-              "conly_flags": {},
-              "coverage_compile_flags": {},
-              "coverage_link_flags": {},
-              "cxx_builtin_include_directories": {},
-              "cxx_flags": {},
-              "cxx_standard": {},
-              "dbg_compile_flags": {},
-              "exec_arch": "",
-              "exec_os": "",
-              "extra_exec_compatible_with": {},
-              "extra_target_compatible_with": {},
-              "link_flags": {},
-              "link_libs": {},
-              "llvm_versions": {
-                "": "20.1.2"
-              },
-              "opt_compile_flags": {},
-              "opt_link_flags": {},
-              "stdlib": {},
-              "target_settings": {},
-              "unfiltered_compile_flags": {},
-              "toolchain_roots": {},
-              "sysroot": {}
-            }
-          }
-        },
-        "recordedRepoMappingEntries": [
-          [
-            "toolchains_llvm~",
-            "bazel_skylib",
-            "bazel_skylib~"
-          ],
-          [
-            "toolchains_llvm~",
-            "bazel_tools",
-            "bazel_tools"
-          ],
-          [
-            "toolchains_llvm~",
-            "toolchains_llvm",
-            "toolchains_llvm~"
-          ]
-        ]
-      }
    }
  }
 }
@@ -0,0 +1,128 @@
+load("@rules_oci//oci:defs.bzl", "oci_image", "oci_load", "oci_push")
+load("@rules_pkg//pkg:tar.bzl", "pkg_tar")
+
+#
+# Eagle Server Docker Image
+#
+# Build: bazel build //ci:eagle_server_image
+# Load:  bazel run //ci:eagle_server_load
+# Push:  bazel run //ci:eagle_server_push
+#
+
+# Package the deploy JAR
+pkg_tar(
+    name = "eagle_server_jar_layer",
+    srcs = ["//src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar"],
+    package_dir = "/app",
+)
+
+# Package the game resources needed at runtime
+pkg_tar(
+    name = "eagle_resources_layer",
+    srcs = [
+        "//src/main/resources/net/eagle0/eagle:beasts",
+        "//src/main/resources/net/eagle0/eagle:game_parameters",
+        "//src/main/resources/net/eagle0/eagle:headshots",
+        "//src/main/resources/net/eagle0/eagle:heroes",
+        "//src/main/resources/net/eagle0/eagle:province_map",
+        "//src/main/resources/net/eagle0/eagle:settings",
+    ],
+    package_dir = "/app/resources",
+)
+
+oci_image(
+    name = "eagle_server_image",
+    base = "@eclipse_temurin_17_linux_amd64",
+    entrypoint = [
+        "java",
+        "-Xmx4g",
+        "-XX:+UseG1GC",
+        "-jar",
+        "/app/eagle_server_deploy.jar",
+    ],
+    env = {
+        "JAVA_OPTS": "-Xmx4g -XX:+UseG1GC",
+    },
+    exposed_ports = ["40032/tcp"],
+    tars = [
+        ":eagle_server_jar_layer",
+        ":eagle_resources_layer",
+    ],
+    workdir = "/app",
+)
+
+# Load into Docker locally: bazel run //ci:eagle_server_load
+oci_load(
+    name = "eagle_server_load",
+    image = ":eagle_server_image",
+    repo_tags = ["eagle0/eagle-server:latest"],
+)
+
+# Push to DigitalOcean Container Registry
+oci_push(
+    name = "eagle_server_push",
+    image = ":eagle_server_image",
+    repository = "registry.digitalocean.com/eagle0/eagle-server",
+)
+
+#
+# Shardok Server Docker Image
+#
+# Build: bazel build //ci:shardok_server_image
+# Load:  bazel run //ci:shardok_server_load
+# Push:  bazel run //ci:shardok_server_push
+#
+
+# Package the Shardok binary
+pkg_tar(
+    name = "shardok_binary_layer",
+    srcs = ["//src/main/cpp/net/eagle0/shardok:shardok-server"],
+    package_dir = "/app",
+)
+
+# Package the Shardok resources (battalion types, settings)
+pkg_tar(
+    name = "shardok_resources_layer",
+    srcs = [
+        "//src/main/resources/net/eagle0/shardok:battalion_types",
+        "//src/main/resources/net/eagle0/shardok:settings",
+    ],
+    package_dir = "/app/resources",
+)
+
+# Package the converted maps
+pkg_tar(
+    name = "shardok_maps_layer",
+    srcs = ["//src/main/resources/net/eagle0/shardok/maps"],
+    package_dir = "/app/resources/maps",
+)
+
+oci_image(
+    name = "shardok_server_image",
+    base = "@ubuntu_24_04_linux_amd64",
+    entrypoint = ["/app/shardok-server"],
+    exposed_ports = [
+        "40042/tcp",
+        "40052/tcp",
+    ],
+    tars = [
+        ":shardok_binary_layer",
+        ":shardok_resources_layer",
+        ":shardok_maps_layer",
+    ],
+    workdir = "/app",
+)
+
+# Load into Docker locally: bazel run //ci:shardok_server_load
+oci_load(
+    name = "shardok_server_load",
+    image = ":shardok_server_image",
+    repo_tags = ["eagle0/shardok-server:latest"],
+)
+
+# Push to DigitalOcean Container Registry
+oci_push(
+    name = "shardok_server_push",
+    image = ":shardok_server_image",
+    repository = "registry.digitalocean.com/eagle0/shardok-server",
+)
@@ -0,0 +1,47 @@
+# Docker Compose for local testing of production images
+# Build images: bazel run //ci:eagle_server_load && bazel run //ci:shardok_server_load
+# Run: docker compose -f docker-compose.prod.yml up
+
+services:
+  eagle:
+    image: eagle0/eagle-server:latest
+    container_name: eagle-server
+    ports:
+      - "40032:40032"
+    environment:
+      # Eagle server configuration
+      EAGLE_GRPC_PORT: "40032"
+      SHARDOK_HOST: "shardok"
+      SHARDOK_PORT: "40042"
+      # Resource paths (relative to /app in container)
+      EAGLE_RESOURCES_PATH: "/app/resources"
+    volumes:
+      # Mount saves directory for persistence
+      - ./saves:/app/saves
+    depends_on:
+      - shardok
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "nc", "-z", "localhost", "40032"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+
+  shardok:
+    image: eagle0/shardok-server:latest
+    container_name: shardok-server
+    ports:
+      - "40042:40042"
+      - "40052:40052"
+    environment:
+      # Shardok server configuration
+      SHARDOK_RESOURCES_PATH: "/app/resources"
+      SHARDOK_MAPS_PATH: "/app/resources/maps"
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "nc", "-z", "localhost", "40042"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
@@ -9,9 +9,9 @@
 │                         GRPC BOUNDARY                               │
 │  EagleServiceImpl.scala  ←→  Proto Messages  ←→  Unity Client       │
 └─────────────────────────────────────────────────────────────────────┘
-                                    ↓
-                           GameStateConverter
-                                    ↓
+                                   ↓
+                          GameStateConverter
+                                   ↓
 ┌─────────────────────────────────────────────────────────────────────┐
 │                         SCALA ENGINE                                │
 │                                                                     │
@@ -22,9 +22,9 @@
 │                                                                     │
 │   HeroC, FactionC, ProvinceC, BattalionC, ArmyC, etc.              │
 └─────────────────────────────────────────────────────────────────────┘
-                                    ↓
-                           GameStateConverter
-                                    ↓
+                                   ↓
+                          GameStateConverter
+                                   ↓
 ┌─────────────────────────────────────────────────────────────────────┐
 │                      PERSISTENCE BOUNDARY                           │
 │  GameHistory.scala  ←→  Proto Messages  ←→  File/Database          │
@@ -35,561 +35,288 @@

 ## Current State

-### What's Done ✅
+### Completed Phases

-| Component | Status | Details |
-|-----------|--------|---------|
-| Commands | **100% Complete** | All 41 commands use Scala models only |
-| Scala Models | **43 models** | GameState, Hero, Faction, Province, Battalion, Army, Supplies, Date, RoundPhase, etc. |
-| Converters | **43 converters** | Bidirectional toProto/fromProto for all models including GameState |
-| Protoless Base Classes | **Available** | `ProtolessSimpleAction`, `ProtolessSequentialResultsAction`, `ProtolessRandomSimpleAction` |
-| **GameState** | **Complete** | `GameState.scala` with all 22 fields + `GameStateConverter` with full round-trip support |
-| **EngineImpl** | **Complete** | Holds Scala `GameState` internally (PR #4563) |
-| **GameHistory** | **Complete** | `stateAfter` returns Scala GameState, `sinceDate` uses Scala Date (PR #4576) |
+| 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 |

-### What's Partially Done ⚠️
+### Phase 5c/5d Progress (Complete)

-| Component | Status | Details |
-|-----------|--------|---------|
-| Actions | **~59/59 (100%)** | All actions return `ActionResultT`. DeterministicSingleResultAction conversions complete. |
-| ActionResultT | **Trait complete** | Full concrete implementation with converters |
+`RoundPhaseAdvancer.checkForPhaseAdvancement` now accepts Scala `GameState` and `ActionResultApplier` directly (PR #4677).

-### What's Outstanding ❌
+| 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 |

-| Component | Priority | Details |
-|-----------|----------|---------|
-| ~~DeterministicSingleResultAction~~ | ~~High~~ | ✅ All converted to ProtolessSimpleAction |
-| ~~RandomSequentialResultsAction~~ | ~~Medium~~ | ✅ All converted to use Scala GameState (PR #4624) |
-| Legacy Utilities | **Low** | Direct proto imports in utility classes |
+### 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 1: ~~Create GameStateC~~ ✅ COMPLETE
-
-**Already done!** The Scala `GameState` model and converter exist:
-
- `src/main/scala/net/eagle0/eagle/model/state/game_state/GameState.scala` - Case class with 22 fields
- `src/main/scala/net/eagle0/eagle/model/proto_converters/game_state/GameStateConverter.scala` - Full bidirectional conversion
-
-```scala
-// GameState.scala - already exists with all fields:
-case class GameState(
-    gameId: GameId,
-    currentRoundId: RoundId,
-    currentPhase: RoundPhase,
-    currentDate: Option[Date],
-    actionResultCount: Int,
-    provinces: Map[ProvinceId, ProvinceT],
-    heroes: Map[HeroId, HeroT],
-    battalions: Map[BattalionId, BattalionT],
-    destroyedBattalions: Map[BattalionId, BattalionT],
-    factions: Map[FactionId, FactionT],
-    factionCommandCounts: Map[FactionId, Int],
-    killedHeroes: Map[HeroId, HeroT],
-    destroyedFactions: Map[FactionId, FactionT],
-    outstandingBattles: Vector[ShardokBattle],
-    battleCounter: Int,
-    deferredNotifications: Vector[NotificationT],
-    runStatus: RunStatus,
-    victor: Option[FactionId],
-    battalionTypes: Vector[BattalionType],
-    randomSeed: Long,
-    chronicleEntries: Vector[ChronicleEntry]
-)
-```
-
---
-
-## Phase 2: ~~Update EngineImpl~~ ✅ COMPLETE (PR #4563)
+## Phase 6: Migrate to ActionResultT Consumers

 ### Objective
-Change EngineImpl to hold `GameState` (Scala model) internally instead of `GameState` (proto).

-### Completed Changes
+Eliminate internal consumption of `ActionResultProto`. Everything inside the engine should work with `ActionResultT`.

- EngineImpl now uses `net.eagle0.eagle.model.state.game_state.GameState` (Scala)
- Engine trait updated to return Scala `GameState`
- GameController, GamesManager, and AIClient updated to use Scala models
- Converters called only at persistence/GRPC boundaries
-
-### Validation
- [x] EngineImpl compiles with new types
- [x] Engine operations work correctly
- [x] All tests pass
-
---
-
-## Phase 3: ~~Update GameHistory~~ ✅ COMPLETE (PR #4576)
-
-### Objective
-GameHistory should work with Scala models internally, converting to/from proto only for persistence.
-
-### Completed Changes
-
- `GameHistory.stateAfter(count: Int)` now returns Scala `GameState`
- `GameHistory.sinceDate(date: Date)` now accepts Scala `Date`
- `InMemoryHistory` and `PersistedHistory` updated to use converters at boundaries
- Callers updated:
-  - `EngineImpl` - wraps with `GameStateConverter.toProto()` where proto needed
-  - `UnrequestedTextHandler` - same
-  - `HumanPlayerClientConnectionState` - imports converter
-  - `NewRoundAction` / `ChronicleEventGenerator` - uses Scala Date
-
-### Validation
- [x] GameHistory compiles
- [x] Game state persistence/retrieval works
- [x] All 7 service tests pass
- [x] NewRoundActionTest passes
-
---
-
-## Phase 4: ~~Complete ActionResultT Implementation~~ ✅ ESSENTIALLY COMPLETE
-
-### Assessment Results (2024-11)
-
-The ActionResultT infrastructure is **already 86% complete**:
-
-| Component | Status | Details |
-|-----------|--------|---------|
-| **ActionResultT trait** | ✅ Complete | Full interface with 27 fields |
-| **ActionResultC case class** | ✅ Complete | Concrete implementation |
-| **ActionResultTApplier** | ✅ Exists | Wraps proto applier for gradual migration |
-| **ActionResultProtoConverter** | ✅ Complete | Bidirectional toProto/fromProto |
-| **Actions using ActionResultT** | ✅ 51/59 (86%) | Only ~10 actions still use proto |
-
-### Remaining Proto Actions (4 DeterministicSingleResultAction)
-
-**DeterministicSingleResultAction subclasses (0 remaining):**
- ~~EndBattleRequestPhaseAction~~ ✅ PR #4581
- ~~EndBattleResolutionPhaseAction~~ ✅ PR #4581
- ~~EndFreeForAllBattleResolutionPhaseAction~~ ✅ PR #4585
- ~~EndFreeForAllBattleRequestPhaseAction~~ ✅ PR #4585
- ~~EndPleaseRecruitMePhaseAction~~ ✅ PR #4586
- ~~EndDefenseDecisionPhaseAction~~ ✅ PR #4586
- ~~PerformFoodConsumptionPhaseAction~~ ✅
- ~~PerformHostileArmySetupAction~~ ✅
- ~~NewYearAction~~ ✅
-
-**RandomSequentialResultsAction subclasses (all converted to use Scala GameState - PR #4624):**
- PerformProvinceMoveResolutionAction ✅, TruceTurnBackPhaseAction ✅
- PerformUnaffiliatedHeroesAction ✅ (internal deproto complete PR #4606 - uses Scala GameState, inlined move action)
- PerformVassalCommandsPhaseAction ✅
- PerformVassalDefenseDecisionsAction ✅, PerformReconResolutionAction ✅
- EndVassalCommandsPhaseAction ✅, EndHandleRiotsPhaseAction ✅
- PerformProvinceEventsAction ✅
- NewRoundAction ✅
-
-**DeterministicSequentialResultsAction subclasses (already return ActionResultT via results()):**
- PrisonerExchangeAction, PerformForcedTurnBackAction, PerformHeroDeparturesAction
-
-### Decision
-
-These remaining actions will be converted as part of **Phase 5** alongside the GameState parameter migration. No separate Phase 4 work needed.
-
-### Validation
- [x] All action result types have Scala models
- [x] Converter handles all cases
- [x] ActionResultTApplier exists for gradual migration
-
---
-
-## Phase 5: Convert Actions & RoundPhaseAdvancer
-
-### Objective
-Convert actions to accept Scala `GameState`, then convert `RoundPhaseAdvancer` to orchestrate with Scala models throughout.
-
-### Strategic Insight
-
-`RoundPhaseAdvancer` is the central orchestrator that calls all phase-handling actions. Currently:
- It receives proto `GameState` (converted from Scala in EngineImpl)
- ~13 actions take proto `GameState` directly
- ~6 actions already take individual Scala model parameters (protoless)
- Inline conversions exist to bridge proto→Scala for protoless actions
-
-**Key win**: Converting actions called by RoundPhaseAdvancer enables converting RoundPhaseAdvancer itself, eliminating all inline conversions.
-
-### Recommended Tiers
-
-**Tier 1 - RoundPhaseAdvancer Actions (HIGH PRIORITY):**
-
-These 13 actions are called directly from RoundPhaseAdvancer with proto `GameState`:
+### Current Flow (Proto-Heavy)
 ```
-NewRoundAction
-PrisonerExchangeAction
-PerformProvinceEventsAction
-PerformForcedTurnBackAction
-PerformProvinceMoveResolutionAction
-EndHandleRiotsPhaseAction
-PerformHeroDeparturesAction
-PerformUnaffiliatedHeroesAction
-EndPleaseRecruitMePhaseAction
-PerformVassalCommandsPhaseAction / EndVassalCommandsPhaseAction
-PerformFoodConsumptionPhaseAction
-EndDefenseDecisionPhaseAction
-TruceTurnBackPhaseAction
-PerformReconResolutionAction
-EndBattleResolutionPhaseAction / EndFreeForAllBattleResolutionPhaseAction
-RequestFreeForAllBattlesAction / EndFreeForAllBattleRequestPhaseAction
-PerformHostileArmySetupAction
-PerformVassalDefenseDecisionsAction
+Action.execute()
+    → ActionResultT
+    → ActionResultProtoConverter.toProto()
+    → ActionResultProto
+    → ActionResultProtoApplierImpl.applyActionResults()
+    → GameStateProto
+    → GameStateConverter.fromProto()
+    → GameStateC
 ```

-Target: Convert each to accept Scala `GameState` parameter.
+### Target Flow (T-Types Throughout)
+```
+Action.execute()
+    → ActionResultT
+    → ActionResultApplier.applyActionResults()
+    → GameStateC

-**Tier 2 - RoundPhaseAdvancer Itself:**
+    (Proto conversion only at boundaries)
+```

-Once Tier 1 is complete:
+### 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.

-Changes:
-1. Accept Scala `GameState` instead of proto
-2. Pattern match on Scala `RoundPhase` sealed trait (cleaner than proto enum)
-3. Remove all inline converter calls (no more `ProvinceConverter.fromProto`, etc.)
-4. Convert to proto only when calling `ActionResultProtoApplier.applyActionResults`
-
-**Tier 3 - Remaining Actions:**
-
-Other actions not called from RoundPhaseAdvancer:
- Command actions, battle resolution, etc.
- Can be converted incrementally after Tier 2
-
-### Pattern for Conversion
-
-**Before (proto-dependent):**
-```scala
-class SomeAction(gameState: GameState) extends ProtolessSimpleAction {
-  def apply(): ActionResultT = {
-    val faction = gameState.factions(factionId)  // proto access
-    // ...
-  }
-}
+**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.

-**After (Scala GameState):**
-```scala
-class SomeAction(gameState: GameState) extends ProtolessSimpleAction {
-  // Now using: import net.eagle0.eagle.model.state.game_state.GameState
-  def apply(): ActionResultT = {
-    val faction = gameState.factions(factionId)  // Scala model access
-    // ...
-  }
-}
-```
+**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.

-### Files to Modify
+**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/library/RoundPhaseAdvancer.scala
-src/main/scala/net/eagle0/eagle/library/actions/impl/action/*.scala
+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
+
+**Progress: 46 of 52 action files (88%) are fully protoless.**
+
+The following 6 actions still have proto usage:
+
+| Action | Proto Usages | Blocker | Effort |
+|--------|--------------|---------|--------|
+| `ResolveBattleAction` | 24 | Shardok interface, complex battle logic | High |
+| `PerformVassalCommandsPhaseAction` | 3 | `CommandChoiceHelpers` takes proto GameState | Medium |
+| `EndHandleRiotsPhaseAction` | 2 | `CommandChoiceHelpers` takes proto GameState | Medium |
+| `PerformVassalDefenseDecisionsAction` | 2 | `CommandChoiceHelpers` takes proto GameState | Medium |
+| `EndVassalCommandsPhaseAction` | 1 | `CommandChoiceHelpers` takes proto GameState | Medium |
+| `NewRoundAction` | 1 | `ChronicleEventGenerator` returns proto | Medium |
+
+**Deleted Dead Code:**
+- `UnaffiliatedHeroMovedAction` - Was never called; `PerformUnaffiliatedHeroesAction.heroMovedResult` constructs `ActionResultC` directly
+- `HeroBackstoryUpdateActionGenerator.fromGameState` - Dead method that converted proto to Scala; only `apply(GameState)` is used
+
+**Note**: `PerformReconResolutionAction` and `EndBattleAftermathPhaseAction` are now fully protoless after:
+1. Migrating `FactionT.reconnedProvinces` and `ChangedFactionC.updatedReconnedProvinces` to use Scala `ProvinceView`
+2. Adding Scala overload of `ProvinceViewFilter.withdrawnFromProvinceView`
+
+### Estimated Effort (Remaining)
+
+| Component | Lines | Complexity | Blocks |
+|-----------|-------|------------|--------|
+| `CommandChoiceHelpers` to Scala | ~2000 | High | 4 vassal actions |
+| `ResolveBattleAction` refactor | ~500 | High | 1 action (complex) |
+| `ChronicleEventGenerator` to Scala | ~400 | Medium | 1 action |
+| History API updates | ~100 | Low | - |
+| **Total Remaining** | **~3000** | | |
+
+### Progress Summary
+
+| Metric | Value |
+|--------|-------|
+| Action files fully protoless | 46 / 52 (88%) |
+| Proto usages in remaining actions | 33 total |
+| Biggest blocker | `ResolveBattleAction` (24 usages) |
+| Second biggest blocker | `CommandChoiceHelpers` (blocks 4 actions) |

 ### Validation
- [x] Each converted action compiles
- [x] Each converted action passes its tests
- [ ] RoundPhaseAdvancer works with Scala GameState
- [ ] No inline converter calls in RoundPhaseAdvancer
- [ ] EngineImpl no longer converts to proto before calling RoundPhaseAdvancer
-
---
-
-## Phase 5b: Delete RandomSequentialResultsAction Base Class
-
-### Objective
-Migrate `RandomSequentialResultsAction` subclasses to a new `TRandomSequentialResultsAction` base class, enabling deletion of the proto-based base class.
-
-### Progress (IN PROGRESS)
-
-**Completed:**
- [x] Created `TRandomSequentialResultsAction` base class
-  - Takes Scala `GameState` as constructor parameter
-  - Extends `Action` trait (provides `execute()`)
-  - Uses `ActionResultTApplier` for applying results
-  - Uses `RandomStateTSequencer` for sequencing operations
- [x] Converted `EndVassalCommandsPhaseAction`
- [x] Converted `TruceTurnBackPhaseAction`
- [x] Converted `PerformUnaffiliatedHeroesAction` (was already mostly T-based internally)
- [x] Converted `PerformProvinceMoveResolutionAction` (uses T-based sub-actions)
- [x] Converted `PerformReconResolutionAction` (uses T-based types: `ChangedProvinceC`, `ChangedFactionC`, `ClientTextVisibilityExtensionC`)
- [x] Converted `NewRoundAction` (uses T-based types: `ChangedProvinceC`, `ChangedHeroC`, `ChangedFactionC`, `LlmRequestT.ChronicleUpdateMessage`, `ChronicleEntry`)
-
-**Remaining - Blocked (4 actions):**
-
-These actions cannot be easily converted because they use `CommandFactory.makeCommand()` which returns proto `Action`:
-
-| Action | Blocker |
-|--------|---------|
-| `EndHandleRiotsPhaseAction` | Uses `CommandFactory.makeCommand()` |
-| `PerformProvinceEventsAction` | Heavily proto-based throughout (builds `ChangedProvince`, `ChangedFaction`, etc.) |
-| `PerformVassalCommandsPhaseAction` | Uses `CommandFactory.makeCommand()` |
-| `PerformVassalDefenseDecisionsAction` | Uses `CommandFactory.makeCommand()` |
-
-**Future work needed:**
- Create T-based `CommandFactory` that returns protoless actions (or add `withRandomAction` to T-sequencer)
- Convert the 4 remaining actions once infrastructure is in place
- Note: `ChangedProvinceC`, `ChangedFactionC` now have full field support (used by `PerformReconResolutionAction`)
-
-### New Architecture
-
-**TRandomSequentialResultsAction** (new base class):
- Location: `src/main/scala/net/eagle0/eagle/library/actions/impl/common/TRandomSequentialResultsAction.scala`
- Takes `GameState` (Scala) as constructor parameter
- Extends `Action` trait
- `randomResults(FunctionalRandom, ActionResultTApplier)` returns `RandomState[Vector[ActionResultT]]`
- `execute(ActionResultProtoApplier)` converts results to proto and applies them
-
-**ProtolessRandomSequentialResultsAction** (kept unchanged):
- Used for sub-actions that don't need `execute()` (e.g., `CheckForFactionChangesAction`)
- Simpler interface: `randomResults(FunctionalRandom)` only
-
-### Pattern for Conversion
-
-**Before (proto ActionResult):**
-```scala
-case class SomeAction(gameState: GameState)
-    extends RandomSequentialResultsAction(GameStateConverter.toProto(gameState)) {
-
-  override def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultProtoApplier: ActionResultProtoApplier
-  ): RandomState[Vector[ActionResult]] = {
-    RandomStateProtoSequencer(...)
-      .withActionResult(_ => ActionResult(`type` = SOME_TYPE, ...))
-      .actionResults
-  }
-}
-```
-
-**After (ActionResultT):**
-```scala
-case class SomeAction(gameState: GameState)
-    extends TRandomSequentialResultsAction(gameState) {
-
-  override protected def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultTApplier: ActionResultTApplier
-  ): RandomState[Vector[ActionResultT]] = {
-    RandomStateTSequencer(
-      initialState = gameState,
-      actionResultApplier = actionResultTApplier,
-      functionalRandom = functionalRandom
-    )
-      .withActionResultT(_ => ActionResultC(SomeResultType, ...))
-      .actionResults
-  }
-}
-```
-
-### Key Changes in Conversion
-
-1. **Base class**: `RandomSequentialResultsAction` → `TRandomSequentialResultsAction`
-2. **Sequencer**: `RandomStateProtoSequencer` → `RandomStateTSequencer`
-3. **Return type**: `RandomState[Vector[ActionResult]]` → `RandomState[Vector[ActionResultT]]`
-4. **Applier**: `ActionResultProtoApplier` → `ActionResultTApplier`
-5. **Result construction**: `ActionResult(...)` → `ActionResultC(...)`
-6. **Field names**: Proto field names → Scala model field names (e.g., `player` → `actingFactionId`)
-
-### Estimated Effort
- 8 remaining actions × ~50 lines each = ~400 lines to change
- Complexity: Medium-High (requires careful mapping of proto → Scala field names)
- Infrastructure complete: `TRandomSequentialResultsAction` base class created
-
-### Validation
- [x] `TRandomSequentialResultsAction` base class created
- [x] 6/10 actions converted (`EndVassalCommandsPhaseAction`, `TruceTurnBackPhaseAction`, `PerformUnaffiliatedHeroesAction`, `PerformProvinceMoveResolutionAction`, `PerformReconResolutionAction`, `NewRoundAction`)
- [x] Converted action tests pass
- [ ] All 10 actions converted to `TRandomSequentialResultsAction` (4 blocked - see table above)
- [ ] All action tests pass
- [ ] `RandomSequentialResultsAction` base class deleted
- [ ] No proto `ActionResult` construction in converted actions
-
---
-
-## Phase 6: Clean Up Legacy Utilities
-
-### Objective
-Remove direct proto imports from utility classes.
-
-### Files to Modify
-
-#### 6.1 LegacyFactionUtils.scala
-```
-src/main/scala/net/eagle0/eagle/library/LegacyFactionUtils.scala
-```
- Replace `import net.eagle0.eagle.internal.faction.Faction` with `FactionT`
- Update method signatures
-
-#### 6.2 LegacyUnaffiliatedHeroUtils.scala
-```
-src/main/scala/net/eagle0/eagle/library/LegacyUnaffiliatedHeroUtils.scala
-```
- Replace proto imports with Scala model imports
- Update method signatures
-
-#### 6.3 BattalionTypeLoader.scala
-```
-src/main/scala/net/eagle0/eagle/library/BattalionTypeLoader.scala
-```
- Keep proto usage for file loading (persistence boundary)
- Convert immediately to Scala model after load
-
-#### 6.4 BeastUtils.scala
-```
-src/main/scala/net/eagle0/eagle/library/BeastUtils.scala
-```
- Replace proto BeastInfo with Scala model (if one exists, otherwise create)
-
-### Validation
- [ ] No proto imports in utility files (except for persistence/serialization)
- [ ] All utilities work correctly with Scala models
-
---
-
-## Phase 7: Verify GRPC Boundary
-
-### Objective
-Confirm that protos are used correctly at the GRPC boundary — and ONLY there.
-
---
-
-## Phase 8: Create Scala-Native Sequencer (Future)
-
-### Objective
-Create a `ScalaOnlySequencer` that operates on Scala `GameState` throughout, eliminating proto conversions inside sequenced operations.
-
-### Background
-
-Currently `RandomStateTSequencer` internally:
-1. Takes Scala `GameState` as input
-2. Converts to proto `GameStateProto` immediately
-3. Threads proto state through all operations
-4. Callbacks receive `GameStateProto`, requiring converter calls at every step:
-   ```scala
-   .withRandomActionResults { (gs, fr) =>
-     CheckForFactionChangesAction(
-       factions = gs.factions.values.toVector.map(FactionConverter.fromProto),  // conversion!
-       provinces = gs.provinces.values.toVector.map(ProvinceConverter.fromProto), // conversion!
-       ...
-     ).randomResults(fr)
-   }
-   ```
-
-### Proposed Design
-
-**ScalaOnlySequencer:**
- Takes Scala `GameState` as input
- Threads Scala `GameState` through all operations (no proto internally)
- Callbacks receive Scala `GameState` directly
- Uses a new `ActionResultScalaApplier` that applies `ActionResultT` to Scala `GameState`
- Converts to proto only at the final output boundary
-
-**Usage after conversion:**
-```scala
-ScalaOnlySequencer(gameState, applier, random)
-  .withRandomActionResults { (gs, fr) =>
-    CheckForFactionChangesAction(
-      factions = gs.factions.values.toVector,  // no conversion!
-      provinces = gs.provinces.values.toVector, // no conversion!
-      ...
-    ).randomResults(fr)
-  }
-  .actionResults
-```
-
-### Prerequisites
- Phase 5 complete (actions use `TRandomSequentialResultsAction`)
- Phase 6 complete (utilities work with Scala models)
- `ActionResultScalaApplier` created (applies `ActionResultT` directly to Scala `GameState`)
-
-### Estimated Effort
- `ActionResultScalaApplier`: ~800-900 lines (port of `ActionResultProtoApplierImpl`)
- `ScalaOnlySequencer`: ~200 lines (similar to `RandomStateTSequencer`)
- Action updates: Remove converter calls from callbacks
-
-### Benefits
- Eliminates per-callback proto conversions
- Cleaner code at usage sites
- Better type safety (no proto field access mistakes)
- Prepares for eventual removal of proto `GameState` from internal operations
-
-### Validation
- [ ] `ActionResultScalaApplier` created and tested
- [ ] `ScalaOnlySequencer` created
- [ ] Actions migrated to use `ScalaOnlySequencer`
- [ ] No proto conversions inside sequenced operations
+- [x] `ActionResultApplier` created and tested
+- [x] `RandomStateSequencer` threads Scala GameState throughout
+- [x] `RoundPhaseAdvancer` uses T-types internally
+- [x] `ProvinceViewFilter` has Scala overload for server-side use (PR #4752)
+- [x] `FactionT.reconnedProvinces` and `ChangedFactionC.updatedReconnedProvinces` use Scala `ProvinceView`
+- [x] `ProvinceViewFilter.withdrawnFromProvinceView` has Scala overload
+- [ ] `ProvinceViewFilter` faction-filtered views use Scala types
+- [ ] `CommandChoiceHelpers` uses Scala types
+- [ ] History APIs vend Scala types
+- [ ] No `ActionResultProtoConverter.toProto()` calls except at persistence/gRPC boundaries
 - [ ] All tests pass

-### Files to Review
+---

-#### 7.1 EagleServiceImpl.scala
-```
-src/main/scala/net/eagle0/eagle/service/EagleServiceImpl.scala
-```
+## Phase 7: Clean Up Legacy Utilities

-**Correct Pattern:**
-```scala
-// Receive proto from client
-def postCommand(request: PostCommandRequest): Future[PostCommandResponse] = {
-  // Convert to Scala model
-  val command = CommandConverter.fromProto(request.command)
+### Objective
+Remove remaining direct proto imports from utility classes.

-  // Process with Scala models
-  val result = engine.processCommand(command)
+### Files to Modify

-  // Convert back to proto for response
-  PostCommandResponse(ActionResultConverter.toProto(result))
-}
-```
+| 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 |

-**This file SHOULD have proto imports** — it's the boundary.
+### View Filters (Partially Complete)

-### Validation
- [ ] GRPC service converts proto ↔ Scala at the boundary
- [ ] No proto types leak into engine internals
- [ ] No Scala model types leak into GRPC responses
+The view filter utilities now have Scala overloads for server-side use:
+
+| File | Status | Notes |
+|------|--------|-------|
+| `ProvinceViewFilter.scala` | **Partial** | `filteredProvinceView(ProvinceT, ScalaGameState)` added (PR #4752) |
+| `ArmyFilter.scala` | **Partial** | `filterArmy(ScalaArmy, Map[BattalionId, BattalionT], Option[FactionId])` added |
+| `BattalionViewFilter.scala` | **Complete** | Uses Scala `BattalionT` throughout |
+| `GameStateViewFilter.scala` | Pending | Uses proto types throughout |
+| `GameStateViewDiffer.scala` | Pending | Works with view protos |
+
+**Unblocked Actions** (PR #4752):
+- `EndBattleAftermathPhaseAction` - can now use `filteredProvinceView(province, scalaGameState)`
+- `PerformReconResolutionAction` - can now use Scala overload
+- `GameStateFactionExtensions` - can now use `updatedReconnedProvinces` with Scala types
+
+**Remaining Work**:
+- Faction-filtered `filteredProvinceView(Province, GameState, FactionId)` still uses proto types
+- `withdrawnFromProvinceView` still uses proto types
+- These are needed for client-facing views with visibility restrictions

 ---

-## Rollout Strategy
+## Phase 8: Verify Boundaries

-### Approach: Incremental, Always-Green
+### Objective
+Confirm protos are used correctly at boundaries — and ONLY there.

-Each phase should result in a **buildable, testable** state. Never have a broken build.
+### Expected Proto Usage (Keep)
+- `EagleServiceImpl.scala` - gRPC boundary
+- `InMemoryHistory.scala` / `PersistedHistory.scala` - Persistence boundary
+- `*Converter.scala` - Explicit conversion utilities
+- `*Loader.scala` - File loading utilities

-```
-Phase 1 (GameStateC) ──→ PR ──→ Merge ✅ (already existed)
-         │
-         ↓
-Phase 2 (EngineImpl) ──→ PR #4563 ──→ Merge ✅
-         │
-         ↓
-Phase 3 (GameHistory) ──→ PR #4576 ──→ Merge ✅
-         │
-         ↓
-Phase 4 (ActionResult) ──→ ✅ Already complete (86% of actions use ActionResultT)
-         │
-         ↓
-Phase 5 (Actions - batched) ──→ PRs ──→ Merge  ← NEXT
-         │
-         ↓
-Phase 6 (Utilities) ──→ PR ──→ Merge
-         │
-         ↓
-Phase 7 (Verification) ──→ PR ──→ Merge
-```
+### Expected No Proto Usage (Verify)
+- `/library/actions/impl/` - Pure Scala models
+- `/library/util/` - Pure Scala models (except loaders)
+- `/model/state/` - Pure Scala models

-### Testing Strategy
+---

-1. **Unit Tests**: Each converter should have round-trip tests
-2. **Integration Tests**: Engine operations should produce correct results
-3. **Regression Tests**: Existing game scenarios should work identically
+## Open Questions

-### Rollback Plan
+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?

-If issues arise:
- Each phase is a separate PR
- Can revert individual PRs without affecting others
- Converters provide backward compatibility during transition
+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.

 ---

@@ -599,132 +326,9 @@ If issues arise:
 - [ ] 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
-
-### Functionality
- [ ] All existing tests pass
- [ ] Game behavior unchanged
- [ ] Performance within acceptable bounds
+- [ ] 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
-
---
-
-## Appendix A: File Inventory
-
-### Proto Files (Keep - for serialization)
-```
-src/main/protobuf/net/eagle0/eagle/internal/game_state.proto
-src/main/protobuf/net/eagle0/eagle/internal/action_result.proto
-src/main/protobuf/net/eagle0/eagle/internal/hero.proto
-... (all .proto files)
-```
-
-### Scala Models (Complete)
-```
-src/main/scala/net/eagle0/eagle/model/state/
-├── army/Army.scala ✅
-├── battalion/BattalionT.scala ✅
-├── faction/FactionT.scala ✅
-├── hero/HeroT.scala ✅
-├── province/ProvinceT.scala ✅
-├── game_state/GameState.scala ✅
-└── ... (43 total)
-```
-
-### Converters (Complete)
-```
-src/main/scala/net/eagle0/eagle/model/proto_converters/
-├── army/ArmyConverter.scala ✅
-├── battalion/BattalionConverter.scala ✅
-├── game_state/GameStateConverter.scala ✅
-└── ... (43 total)
-```
-
-### Actions (Convert)
-```
-src/main/scala/net/eagle0/eagle/library/actions/
-├── ProvinceConqueredAction.scala ✅ (converted)
-├── HeroBackstoryUpdateAction.scala ✅ (converted)
-├── NewRoundAction.scala ✅ (converted - PR #4624)
-├── ResolveBattleAction.scala ❌ (needs conversion)
-└── ... (All RandomSequentialResultsAction subclasses converted)
-```
-
---
-
-## Appendix B: Estimated Effort
-
-| Phase | Files | Lines Changed | Complexity | Status |
-|-------|-------|---------------|------------|--------|
-| Phase 1 | ✅ | 0 | Complete | **DONE** |
-| Phase 2 | 10 | ~200 | High | **DONE** (PR #4563) |
-| Phase 3 | 18 | ~200 | Medium | **DONE** (PR #4576) |
-| Phase 4 | ✅ | 0 | Already complete | **DONE** (93% of actions use ActionResultT) |
-| Phase 5 | ~10 | ~500 | Medium | **DONE** (All action base classes converted) |
-| Phase 6 | 4-6 | ~300 | Low | |
-| Phase 7 | 1-2 | ~50 | Low | |
-| **Total** | **~35** | **~1250** | | **~85% complete** |
-
-### Phase 5 Progress
-
-**DeterministicSingleResultAction → ProtolessSimpleAction:**
- PR #4581: EndBattleRequestPhaseAction, EndBattleResolutionPhaseAction ✅
- PR #4585: EndFreeForAllBattleRequestPhaseAction, EndFreeForAllBattleResolutionPhaseAction ✅
- PR #4586: EndPleaseRecruitMePhaseAction, EndDefenseDecisionPhaseAction ✅
- PR #4606: PerformUnaffiliatedHeroesAction internal deproto (uses Scala GameState, inlined UnaffiliatedHeroMovedAction) ✅
- PR #4611: PerformFoodConsumptionPhaseAction, PerformHostileArmySetupAction, NewYearAction ✅
-
-**All DeterministicSingleResultAction conversions complete!** The `DeterministicSingleResultAction` base class has been deleted.
-
-**RandomSequentialResultsAction → Scala GameState:**
- PR #4624: EndVassalCommandsPhaseAction, EndHandleRiotsPhaseAction, PerformProvinceMoveResolutionAction, PerformProvinceEventsAction, TruceTurnBackPhaseAction, PerformVassalCommandsPhaseAction, PerformVassalDefenseDecisionsAction, PerformReconResolutionAction, NewRoundAction ✅
-
-**All RandomSequentialResultsAction conversions complete!** All now accept Scala GameState.
-
-Next: Phase 6 (Legacy Utilities) or Phase 7 (GRPC Boundary verification).
-
---
-
-## Appendix C: Open Questions
-
-1. ~~**GameState size**: Already resolved - using single case class with 22 fields.~~
-
-2. **Mutable vs Immutable**: Currently using immutable case classes with `copy`. Is this performant enough for game state updates?
-
-3. **Shardok Integration**: `ResolveBattleAction` communicates with Shardok. Should the Shardok interface use protos (external service) or Scala models?
-
-4. **View Generation**: `GameStateViewDiffer` works with view protos for client updates. Should views also have Scala models, or is proto acceptable for client-facing projections?
-
-5. **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?
-
---
-
-## Appendix D: Lessons Learned (from Phases 2-3)
-
-### What Worked Well
-
-1. **Incremental approach** - Each phase produces a working build. Tests catch issues immediately.
-
-2. **Converter pattern** - Having `GameStateConverter.toProto()`/`fromProto()` allows gradual migration. Callers can convert at their boundaries without changing everything at once.
-
-3. **Type aliases help readability** - Using `import ... as DateProto` and `import ... as ScalaDate` makes the code clearer when both types coexist during migration.
-
-### Challenges Encountered
-
-1. **Test mock expectations need updating** - When a method's return type changes (e.g., `stateAfter` returning Scala GameState instead of proto), all mock expectations need to match the new type. This can cascade through many test files.
-
-2. **ActionWithResultingState still uses proto internally** - The `ActionWithResultingState` case class contains proto `GameState` and `ActionResult`. This means callers sometimes need to convert even when we'd prefer not to. Consider converting this class in a future phase.
-
-3. **Build file dependencies** - Each source file change may require BUILD.bazel updates for new imports. Running `bazel run gazelle` helps but manual review is sometimes needed.
-
-### Recommendations for Future Phases
-
-1. **Run tests early and often** - Build failures reveal type mismatches quickly. Fix one file at a time rather than trying to change everything before testing.
-
-2. **Update tests alongside source** - When changing a trait's return type, update the tests for that trait's implementations in the same PR.
-
-3. **Consider deferring ActionWithResultingState conversion** - This is used in the event-sourcing history and may be better left as proto until we're ready to migrate persistence format.
@@ -0,0 +1,940 @@
+# Eagle0 Productionization Plan
+
+## Executive Summary
+
+This document outlines a plan to move Eagle0's Eagle and Shardok servers from a home Mac to cloud infrastructure while maintaining a QA environment on the Mac. The architecture uses DigitalOcean (already integrated via Spaces) with containerized deployments and GitHub Actions CI/CD.
+
+## Current Architecture
+
+```
+Unity Client
+     │
+     │ gRPC/TLS (eagle0.net:443)
+     ▼
+nginx (home Mac, via router port forward)
+     │
+     ├─► Eagle Server (Scala/JVM, port 40032)
+     │        │
+     │        │ internal gRPC (port 40042)
+     │        ▼
+     └─► Shardok Server (C++, port 40042/40052)
+
+Storage: DigitalOcean Spaces (sfo3.digitaloceanspaces.com)
+DNS: eagle0.net → home IP
+```
+
+**Key observations:**
+- Already using DigitalOcean Spaces for S3-compatible storage
+- Eagle server is a deployable JAR (`eagle_server_deploy.jar`)
+- Shardok server is a native C++ binary
+- nginx handles TLS termination and gRPC routing
+- Self-hosted GitHub Actions runner on Mac
+
+---
+
+## Target Architecture
+
+### Production Environment (DigitalOcean)
+
+```
+Unity Client
+     │
+     ├─► eagle0.net (Production)
+     │        │
+     │        ▼
+     │   DigitalOcean Load Balancer (TLS termination)
+     │        │
+     │        ▼
+     │   ┌─────────────────────────────────────┐
+     │   │     DigitalOcean Droplet(s)         │
+     │   │  ┌─────────────┬─────────────────┐  │
+     │   │  │   Eagle     │    Shardok      │  │
+     │   │  │   (Docker)  │    (Docker)     │  │
+     │   │  │   :40032    │    :40042       │  │
+     │   │  └─────────────┴─────────────────┘  │
+     │   └─────────────────────────────────────┘
+     │
+     └─► qa.eagle0.net (QA - home Mac, unchanged)
+              │
+              ▼
+         nginx → Eagle/Shardok (current setup)
+```
+
+### Environment Switching
+
+The Unity client already supports configurable server URLs via the connection screen:
+- **Production:** `eagle0.net` (default)
+- **QA:** `qa.eagle0.net`
+
+No client code changes needed - users can simply type the desired URL.
+
+---
+
+## Cloud Provider: DigitalOcean
+
+### Why DigitalOcean
+
+1. **Already integrated** - S3 Spaces storage at `sfo3.digitaloceanspaces.com` with credentials configured
+2. **Simple pricing** - Predictable monthly costs, no surprise bills
+3. **Good performance** - SFO3 datacenter is geographically close
+4. **Managed services** - Load balancers, managed databases if needed later
+5. **Not AWS/GCP** - Per your requirements
+
+### Alternative Considered: Hetzner
+
+- Cheaper for compute ($3.29/mo for 2 vCPU/4GB vs DO's $24/mo)
+- Good EU presence but less US coverage
+- No managed load balancer (need to run HAProxy/nginx yourself)
+- **Recommendation:** Start with DigitalOcean for simplicity; migrate to Hetzner later if cost becomes a concern
+
+---
+
+## Infrastructure Components
+
+### 1. Compute: DigitalOcean Droplets
+
+#### Resource Characteristics
+
+- **Eagle server:** CPU-light, possibly RAM-heavy (JVM). Should be always available.
+- **Shardok server:** Very CPU-heavy (AI algorithms). Only needed during tactical battles. Startup time <1 second.
+
+#### Recommended: On-Demand Shardok (Same Droplet)
+
+For current low player count, optimize for cost while maintaining availability:
+
+| Component | Config | Monthly Cost |
+|-----------|--------|--------------|
+| Droplet | s-2vcpu-4gb | $24/mo |
+| Eagle | Always running | - |
+| Shardok | Started on-demand by Eagle, stopped after idle | - |
+
+**How it works:**
+1. Eagle server runs 24/7 - game is always available
+2. When battle starts, Eagle launches Shardok container/process (<1s startup)
+3. After battle ends, idle timer starts (e.g., 5 minutes)
+4. On timeout, Eagle stops Shardok to free CPU
+5. If new battle starts during idle period, Shardok is already warm
+
+**Shardok lifecycle management** (implement in Eagle):
+```scala
+// Pseudocode for Eagle's Shardok management
+object ShardokManager {
+  private var process: Option[Process] = None
+  private var idleTimer: Option[Timer] = None
+
+  def ensureRunning(): Unit = {
+    cancelIdleTimer()
+    if (process.isEmpty) {
+      process = Some(startShardokProcess())
+      waitForHealthCheck()
+    }
+  }
+
+  def onBattleEnd(): Unit = {
+    idleTimer = Some(scheduleShutdown(5.minutes))
+  }
+
+  private def shutdown(): Unit = {
+    process.foreach(_.destroy())
+    process = None
+  }
+}
+```
+
+#### Future Scaling Options
+
+As player count grows and Shardok needs more CPU:
+
+**Option A: Upgrade Droplet (Simplest)**
+
+| Droplet | vCPU | RAM | Cost | Use Case |
+|---------|------|-----|------|----------|
+| s-2vcpu-4gb | 2 shared | 4 GB | $24/mo | Current (few players) |
+| s-4vcpu-8gb | 4 shared | 8 GB | $48/mo | Moderate usage |
+| c-4 | 4 dedicated | 8 GB | $84/mo | CPU-intensive battles |
+| c-8 | 8 dedicated | 16 GB | $168/mo | Multiple concurrent battles |
+
+**Option B: Separate Shardok Droplet (API-driven)**
+
+For heavy Shardok usage with cost optimization:
+
+- **Eagle droplet:** s-1vcpu-2gb ($12/mo) - always on
+- **Shardok droplet:** Created on-demand via DigitalOcean API
+  - c-4 CPU-optimized: $0.125/hour
+  - c-8 CPU-optimized: $0.25/hour
+  - Created when battle starts, destroyed after idle
+  - 30-60s droplet creation time (acceptable if battles are requested in advance)
+
+**Option C: Fly.io for Shardok (Scale-to-Zero)**
+
+For true pay-per-use with fast cold starts:
+
+- **Eagle:** DigitalOcean or Fly.io (~$10/mo)
+- **Shardok:** Fly.io with auto-scaling
+  - Performance VMs: ~$0.0000022/second when running
+  - Cold start: 2-5 seconds
+  - Scales to zero when idle
+
+Requires learning Fly.io but offers best cost efficiency for sporadic usage.
+
+**Option D: Multiple Shardok Instances (High Scale)**
+
+For many concurrent battles:
+
+- **Eagle:** Dedicated droplet with more RAM
+- **Shardok pool:** Multiple Shardok containers/droplets
+- Eagle routes battles to available Shardok instances
+- Could use Kubernetes or Docker Swarm for orchestration
+
+This is overkill for now but documented for future reference.
+
+### 2. Load Balancer
+
+**DigitalOcean Load Balancer:** $12/mo
+
+- TLS termination with Let's Encrypt
+- Health checks
+- Sticky sessions (if needed)
+- Can add more droplets later for HA
+
+**Alternative:** Run nginx on the droplet for $0 extra, but lose automatic failover.
+
+### 3. Storage
+
+**Already configured:** DigitalOcean Spaces
+- Bucket: `eagle0`
+- Region: `sfo3`
+- Used for game saves and assets
+- Cost: $5/mo base + $0.02/GB storage + $0.01/GB transfer
+
+### 4. DNS
+
+**Option A: DigitalOcean DNS (Recommended)**
+- Free with droplets
+- Easy integration
+- API for automated updates
+
+**Option B: Keep current DNS provider**
+- Update A records manually or via script
+
+**DNS Records:**
+```
+eagle0.net          A     <DO Load Balancer IP>
+qa.eagle0.net       A     <Home IP> (unchanged)
+*.eagle0.net        A     <DO Load Balancer IP> (wildcard for future)
+```
+
+### 5. Firewall
+
+**DigitalOcean Cloud Firewall:** Free
+
+```
+Inbound Rules:
+- TCP 443 (HTTPS/gRPC) from anywhere → Load Balancer
+- TCP 22 (SSH) from your IP only → Droplets
+- TCP 40032 (Eagle) from Load Balancer only
+- TCP 40042 (Shardok) from Load Balancer only
+
+Outbound Rules:
+- All traffic allowed (for external APIs, Spaces, etc.)
+```
+
+---
+
+## Container Strategy
+
+### Dockerfiles
+
+**Eagle Server** (`ci/eagle_run.Dockerfile` - already exists, needs enhancement):
+
+```dockerfile
+FROM eclipse-temurin:17-jre-alpine
+
+# Add non-root user
+RUN addgroup -S eagle && adduser -S eagle -G eagle
+
+WORKDIR /app
+
+# Copy the deploy JAR
+COPY --chown=eagle:eagle deploy/eagle_server_deploy.jar ./
+
+# Copy game resources
+COPY --chown=eagle:eagle src/main/resources/net/eagle0/eagle/ ./resources/
+
+USER eagle
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
+  CMD wget -q --spider http://localhost:40032/health || exit 1
+
+EXPOSE 40032
+
+ENTRYPOINT ["java", "-Xmx4g", "-jar", "eagle_server_deploy.jar"]
+CMD ["--eagle-grpc-port", "40032", "--shardok-interface-remote-address", "shardok:40042", "--gpt-model-name", "gpt-4"]
+```
+
+**Shardok Server** (new: `ci/shardok_run.Dockerfile`):
+
+```dockerfile
+FROM ubuntu:22.04
+
+# Install runtime dependencies
+RUN apt-get update && apt-get install -y \
+    libstdc++6 \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+# Add non-root user
+RUN useradd -r -s /bin/false shardok
+
+WORKDIR /app
+
+# Copy the Shardok binary and dependencies
+COPY --chown=shardok:shardok bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server ./
+COPY --chown=shardok:shardok src/main/resources/net/eagle0/shardok/maps/ ./maps/
+
+USER shardok
+
+# Health check (need to implement gRPC health endpoint)
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
+  CMD ./shardok-server --health-check || exit 1
+
+EXPOSE 40042 40052
+
+ENTRYPOINT ["./shardok-server"]
+```
+
+**Docker Compose** (new: `docker-compose.prod.yml`):
+
+```yaml
+version: '3.8'
+
+services:
+  eagle:
+    build:
+      context: .
+      dockerfile: ci/eagle_run.Dockerfile
+    image: eagle0/eagle-server:${VERSION:-latest}
+    ports:
+      - "40032:40032"
+    environment:
+      - SHARDOK_ADDRESS=shardok:40042
+      - GPT_MODEL_NAME=${GPT_MODEL_NAME:-gpt-4}
+      - JAVA_OPTS=-Xmx4g -XX:+UseG1GC
+    depends_on:
+      - shardok
+    restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "100m"
+        max-file: "5"
+
+  shardok:
+    build:
+      context: .
+      dockerfile: ci/shardok_run.Dockerfile
+    image: eagle0/shardok-server:${VERSION:-latest}
+    ports:
+      - "40042:40042"
+      - "40052:40052"
+    restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "100m"
+        max-file: "5"
+```
+
+---
+
+## Build Pipeline
+
+### Build Artifacts
+
+The build process produces:
+1. **Eagle JAR:** `bazel-bin/src/main/scala/net/eagle0/eagle/eagle_server_deploy.jar`
+2. **Shardok binary:** `bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server`
+
+### Cross-Compilation for Linux
+
+Current builds target macOS (self-hosted runner). For production Linux deployment:
+
+**Option A: Build in Docker (Recommended)**
+```bash
+# Build Eagle (JVM - platform independent)
+bazel build //src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar
+
+# Build Shardok in Linux container
+docker run --rm -v $(pwd):/workspace -w /workspace \
+  ubuntu:22.04 \
+  bash -c "apt-get update && apt-get install -y build-essential && bazel build -c opt //src/main/cpp/net/eagle0/shardok:shardok-server"
+```
+
+**Option B: Use GitHub-hosted Linux runner**
+- Add `runs-on: ubuntu-latest` workflow
+- Builds directly on Linux
+- May need to cache Bazel to avoid long build times
+
+**Option C: Cross-compile on Mac**
+- Configure Bazel for Linux cross-compilation
+- More complex setup but faster iteration
+
+**Recommendation:** Option A (Docker build) for Shardok, since Eagle's JAR is platform-independent.
+
+---
+
+## CI/CD Pipeline
+
+### GitHub Actions Workflows
+
+**New workflow:** `.github/workflows/deploy_production.yml`
+
+```yaml
+name: Deploy to Production
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'src/main/scala/**'
+      - 'src/main/cpp/**'
+      - 'src/main/protobuf/**'
+      - 'ci/*.Dockerfile'
+      - 'docker-compose.prod.yml'
+  workflow_dispatch:
+    inputs:
+      environment:
+        description: 'Deployment environment'
+        required: true
+        default: 'production'
+        type: choice
+        options:
+          - production
+          - staging
+
+env:
+  REGISTRY: registry.digitalocean.com
+  EAGLE_IMAGE: eagle0/eagle-server
+  SHARDOK_IMAGE: eagle0/shardok-server
+
+jobs:
+  build-eagle:
+    runs-on: self-hosted
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: false
+
+      - name: Set version
+        id: version
+        run: echo "version=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+      - name: Build Eagle server JAR
+        run: bazel build //src/main/scala/net/eagle0/eagle:eagle_server_deploy.jar
+
+      - name: Copy artifacts
+        run: |
+          mkdir -p deploy
+          cp bazel-bin/src/main/scala/net/eagle0/eagle/eagle_server_deploy.jar deploy/
+
+      - name: Build Docker image
+        run: |
+          docker build -f ci/eagle_run.Dockerfile -t ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:${{ steps.version.outputs.version }} .
+          docker tag ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:${{ steps.version.outputs.version }} ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:latest
+
+      - name: Push to registry
+        run: |
+          echo "${{ secrets.DO_REGISTRY_TOKEN }}" | docker login ${{ env.REGISTRY }} -u ${{ secrets.DO_REGISTRY_TOKEN }} --password-stdin
+          docker push ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:${{ steps.version.outputs.version }}
+          docker push ${{ env.REGISTRY }}/${{ env.EAGLE_IMAGE }}:latest
+
+  build-shardok:
+    runs-on: ubuntu-latest
+    needs: []
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          lfs: false
+
+      - name: Set version
+        id: version
+        run: echo "version=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+
+      - name: Set up Bazel
+        uses: bazelbuild/setup-bazelisk@v2
+
+      - name: Cache Bazel
+        uses: actions/cache@v3
+        with:
+          path: ~/.cache/bazel
+          key: bazel-linux-${{ hashFiles('MODULE.bazel', 'WORKSPACE') }}
+
+      - name: Build Shardok server
+        run: bazel build -c opt //src/main/cpp/net/eagle0/shardok:shardok-server
+
+      - name: Build Docker image
+        run: |
+          mkdir -p bazel-bin/src/main/cpp/net/eagle0/shardok/
+          cp bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server bazel-bin/src/main/cpp/net/eagle0/shardok/
+          docker build -f ci/shardok_run.Dockerfile -t ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:${{ steps.version.outputs.version }} .
+          docker tag ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:${{ steps.version.outputs.version }} ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:latest
+
+      - name: Push to registry
+        run: |
+          echo "${{ secrets.DO_REGISTRY_TOKEN }}" | docker login ${{ env.REGISTRY }} -u ${{ secrets.DO_REGISTRY_TOKEN }} --password-stdin
+          docker push ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:${{ steps.version.outputs.version }}
+          docker push ${{ env.REGISTRY }}/${{ env.SHARDOK_IMAGE }}:latest
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [build-eagle, build-shardok]
+    environment: production
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Deploy to DigitalOcean
+        uses: appleboy/ssh-action@v1.0.0
+        with:
+          host: ${{ secrets.DO_DROPLET_IP }}
+          username: deploy
+          key: ${{ secrets.DO_SSH_KEY }}
+          script: |
+            cd /opt/eagle0
+
+            # Pull latest images
+            docker-compose -f docker-compose.prod.yml pull
+
+            # Rolling restart (zero-downtime if load balancer configured)
+            docker-compose -f docker-compose.prod.yml up -d --remove-orphans
+
+            # Wait for health checks
+            sleep 30
+            docker-compose -f docker-compose.prod.yml ps
+
+            # Cleanup old images
+            docker image prune -f
+
+      - name: Verify deployment
+        run: |
+          # Health check endpoint
+          curl -f https://eagle0.net/health || exit 1
+
+      - name: Notify on failure
+        if: failure()
+        run: |
+          # Add Slack/Discord notification here
+          echo "Deployment failed!"
+```
+
+### Deployment Steps
+
+1. **On push to main:**
+   - Build Eagle JAR (self-hosted Mac runner - for consistency)
+   - Build Shardok binary (GitHub-hosted Ubuntu runner)
+   - Build Docker images
+   - Push to DigitalOcean Container Registry
+
+2. **Deploy to droplet:**
+   - SSH to production server
+   - Pull new images
+   - `docker-compose up -d` (rolling update)
+   - Verify health checks
+
+3. **Rollback:**
+   ```bash
+   # On server
+   docker-compose -f docker-compose.prod.yml down
+   docker-compose -f docker-compose.prod.yml pull eagle0/eagle-server:<previous-version>
+   docker-compose -f docker-compose.prod.yml up -d
+   ```
+
+---
+
+## Server Setup
+
+### Initial Droplet Setup
+
+```bash
+#!/bin/bash
+# Run on fresh DigitalOcean droplet (Ubuntu 22.04)
+
+# Update system
+apt-get update && apt-get upgrade -y
+
+# Install Docker
+curl -fsSL https://get.docker.com | sh
+systemctl enable docker
+systemctl start docker
+
+# Install Docker Compose
+apt-get install -y docker-compose-plugin
+
+# Create deploy user
+useradd -m -s /bin/bash -G docker deploy
+mkdir -p /home/deploy/.ssh
+# Add your SSH public key to /home/deploy/.ssh/authorized_keys
+
+# Create app directory
+mkdir -p /opt/eagle0
+chown deploy:deploy /opt/eagle0
+
+# Configure Docker to use DigitalOcean Container Registry
+docker login registry.digitalocean.com
+
+# Create systemd service for auto-start
+cat > /etc/systemd/system/eagle0.service << 'EOF'
+[Unit]
+Description=Eagle0 Game Servers
+Requires=docker.service
+After=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=/opt/eagle0
+ExecStart=/usr/bin/docker compose -f docker-compose.prod.yml up -d
+ExecStop=/usr/bin/docker compose -f docker-compose.prod.yml down
+User=deploy
+Group=deploy
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+systemctl enable eagle0
+```
+
+### Load Balancer Configuration
+
+**DigitalOcean Load Balancer settings:**
+
+- **Forwarding Rules:**
+  - HTTPS 443 → HTTP 40032 (Eagle)
+  - gRPC is HTTP/2, handled automatically
+
+- **Health Checks:**
+  - Protocol: HTTP
+  - Port: 40032
+  - Path: `/health` (need to implement)
+
+- **SSL:**
+  - Let's Encrypt certificate for `eagle0.net`
+
+- **Settings:**
+  - Sticky sessions: Disabled (gRPC streams handle this)
+  - Proxy protocol: Disabled
+
+### nginx on Droplet (Alternative to LB)
+
+If using nginx instead of managed LB:
+
+```nginx
+# /etc/nginx/sites-available/eagle0
+upstream eagle_backend {
+    server 127.0.0.1:40032;
+    keepalive 100;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name eagle0.net;
+
+    ssl_certificate /etc/letsencrypt/live/eagle0.net/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/eagle0.net/privkey.pem;
+
+    # gRPC settings
+    location /net.eagle0.eagle.api.Eagle {
+        grpc_pass grpc://eagle_backend;
+        grpc_read_timeout 1200s;
+        grpc_send_timeout 1200s;
+        grpc_socket_keepalive on;
+
+        # Rate limiting
+        limit_req zone=eagle burst=50 nodelay;
+    }
+
+    # Health check endpoint
+    location /health {
+        proxy_pass http://127.0.0.1:40032/health;
+    }
+}
+
+# Rate limit zone
+limit_req_zone $binary_remote_addr zone=eagle:10m rate=100r/s;
+```
+
+---
+
+## Environment Configuration
+
+### Secrets Management
+
+**GitHub Secrets (for CI/CD):**
+- `DO_REGISTRY_TOKEN` - DigitalOcean Container Registry token
+- `DO_DROPLET_IP` - Production server IP
+- `DO_SSH_KEY` - SSH private key for deployment
+- `OPENAI_API_KEY` - For LLM integration (if used in production)
+- `DO_SPACES_KEY` - Already exists for S3
+
+**On Server (environment variables):**
+```bash
+# /opt/eagle0/.env
+GPT_MODEL_NAME=gpt-4
+OPENAI_API_KEY=sk-...
+DO_SPACES_KEY=...
+DO_SPACES_SECRET=...
+JAVA_OPTS=-Xmx4g -XX:+UseG1GC -XX:MaxGCPauseMillis=200
+```
+
+### Configuration Files
+
+**Production config** (`/opt/eagle0/config/eagle0.conf`):
+```
+monteCarloIterations = 150000
+monteCarloThreads = 4
+grpcAddress = 0.0.0.0:40042
+```
+
+---
+
+## Monitoring & Observability
+
+### Logging
+
+**Docker logging driver:** json-file with rotation
+- Logs stored in `/var/lib/docker/containers/<id>/`
+- Max 5 files of 100MB each
+
+**Log aggregation options:**
+1. **DigitalOcean Logs** - $0 for basic, integrates with Droplets
+2. **Papertrail** - $7/mo for 1GB, good search
+3. **Self-hosted Loki** - Free, more complex
+
+### Metrics
+
+**Prometheus + Grafana** (optional, for advanced monitoring):
+```yaml
+# Add to docker-compose.prod.yml
+  prometheus:
+    image: prom/prometheus
+    volumes:
+      - ./prometheus.yml:/etc/prometheus/prometheus.yml
+    ports:
+      - "9090:9090"
+
+  grafana:
+    image: grafana/grafana
+    ports:
+      - "3000:3000"
+    environment:
+      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}
+```
+
+**Key metrics to track:**
+- Connection count
+- Request latency (p50, p95, p99)
+- Error rate
+- CPU/memory usage
+- Shardok AI search depth/time
+
+### Alerting
+
+**DigitalOcean Monitoring Alerts:**
+- CPU > 80% for 5 minutes
+- Memory > 90%
+- Disk > 85%
+- Droplet unreachable
+
+**Uptime monitoring:**
+- Use UptimeRobot (free tier) or Better Uptime
+- Check `https://eagle0.net/health` every minute
+
+---
+
+## Cost Estimate
+
+### Recommended Starting Configuration
+
+| Component | Monthly Cost | Notes |
+|-----------|-------------|-------|
+| Droplet (s-2vcpu-4gb) | $24 | Eagle always-on, Shardok on-demand |
+| Spaces | ~$5 | Already paying |
+| Container Registry | $5 | For Docker images |
+| DNS | $0 | Included |
+| Bandwidth | ~$0 | 1TB free, then $0.01/GB |
+| **Total** | **~$34/mo** | |
+
+### Optional Add-ons
+
+| Component | Monthly Cost | Notes |
+|-----------|-------------|-------|
+| Load Balancer | +$12 | Only if need HA/failover |
+| Monitoring (Papertrail) | +$7 | Better log search |
+
+### Scaling Costs
+
+| Scenario | Droplet | Monthly Cost |
+|----------|---------|--------------|
+| Current (few players) | s-2vcpu-4gb | $24 |
+| Growing usage | s-4vcpu-8gb | $48 |
+| CPU-intensive battles | c-4 (dedicated) | $84 |
+| High concurrency | c-8 (dedicated) | $168 |
+| Separate Shardok (on-demand) | s-1vcpu-2gb + c-4 hourly | $12 + usage |
+
+---
+
+## Migration Plan
+
+### Phase 1: Infrastructure Setup (Day 1)
+
+1. Create DigitalOcean resources:
+   - Droplet in SFO3 region
+   - Container Registry
+   - (Optional) Load Balancer
+
+2. Configure DNS:
+   - Point `eagle0.net` to new infrastructure
+   - Keep `qa.eagle0.net` pointing to home IP
+
+3. Set up server:
+   - Run initial setup script
+   - Configure Docker and docker-compose
+   - Test SSH access
+
+### Phase 2: Build Pipeline (Day 2)
+
+1. Create Dockerfiles:
+   - Enhance `ci/eagle_run.Dockerfile`
+   - Create `ci/shardok_run.Dockerfile`
+
+2. Create `docker-compose.prod.yml`
+
+3. Set up GitHub Actions:
+   - Add deployment workflow
+   - Configure secrets
+   - Test build pipeline
+
+### Phase 3: Deployment (Day 3)
+
+1. Deploy to production:
+   - Push first images
+   - Start containers
+   - Verify health checks
+
+2. Configure TLS:
+   - Set up Let's Encrypt
+   - Update nginx/LB configuration
+
+3. Update DNS:
+   - Switch `eagle0.net` to production
+   - Verify client can connect
+
+### Phase 4: Validation (Day 4)
+
+1. Test gameplay:
+   - Connect from Unity client
+   - Play through Eagle gameplay
+   - Test Shardok combat
+
+2. Monitor:
+   - Check logs for errors
+   - Verify resource usage
+   - Test reconnection behavior
+
+3. Document:
+   - Update runbooks
+   - Document rollback procedures
+
+### Phase 5: QA Environment (Day 5)
+
+1. Configure `qa.eagle0.net`:
+   - Keep pointing to home Mac
+   - Ensure nginx routes correctly
+
+2. Test environment switching:
+   - Connect to production
+   - Switch to QA
+   - Verify different game states
+
+---
+
+## Rollback Procedure
+
+### Quick Rollback (< 5 minutes)
+
+```bash
+# SSH to production server
+ssh deploy@<droplet-ip>
+
+# Roll back to previous version
+cd /opt/eagle0
+docker-compose -f docker-compose.prod.yml down
+docker pull registry.digitalocean.com/eagle0/eagle-server:<previous-tag>
+docker pull registry.digitalocean.com/eagle0/shardok-server:<previous-tag>
+VERSION=<previous-tag> docker-compose -f docker-compose.prod.yml up -d
+```
+
+### Full Rollback to Home Mac
+
+1. Update DNS: Point `eagle0.net` back to home IP
+2. Ensure home Mac servers are running
+3. Wait for DNS propagation (5-30 minutes)
+
+---
+
+## Security Checklist
+
+- [ ] SSH key authentication only (disable password)
+- [ ] Firewall configured (only 443, 22 from trusted IPs)
+- [ ] TLS 1.3 enforced
+- [ ] Secrets in environment variables, not in code
+- [ ] Container runs as non-root user
+- [ ] Rate limiting on gRPC endpoints
+- [ ] Regular security updates (`unattended-upgrades`)
+- [ ] Remove Shardok internal interface from public nginx (per CONNECTION_ARCHITECTURE.md)
+
+---
+
+## Resolved Questions
+
+1. **Game state migration:** No migration needed. Saves are currently local only. The codebase has a `Persister` pattern (with existing AWS support) that could be adapted to save to DO Spaces in the future.
+
+2. **LLM API keys:** Yes, OpenAI API keys are needed on the Eagle server. Add `OPENAI_API_KEY` to the `.env` file on the production droplet.
+
+3. **Multiple regions:** Not needed for now. Single SFO3 region is sufficient.
+
+## Remaining Open Questions
+
+1. **Backup strategy:** Should we add automated backups for local persistence, or migrate to DO Spaces persistence first?
+
+2. **Autoscaling:** Is traffic predictable enough to use fixed instance, or need autoscaling later?
+
+---
+
+## Next Steps
+
+### Phase 1: Infrastructure
+1. **Approve this plan** - Review and discuss any changes
+2. **Create DigitalOcean resources** - Droplet (s-2vcpu-4gb), Container Registry
+3. **Set up droplet** - Docker, deploy user, firewall, nginx with TLS
+
+### Phase 2: Containerization
+4. **Implement Dockerfiles** - Eagle and Shardok containers
+5. **Implement Shardok lifecycle management** - Eagle starts/stops Shardok on-demand
+   - Add `ShardokProcessManager` to Eagle server
+   - Start Shardok when battle requested
+   - Stop after idle timeout (5 min)
+   - Health check before routing traffic
+
+### Phase 3: CI/CD
+6. **Set up GitHub Actions** - Build and push Docker images
+7. **Add deployment workflow** - SSH deploy to droplet
+
+### Phase 4: Migration
+8. **Deploy to production** - Push images, start services
+9. **Update DNS** - Point eagle0.net to droplet
+10. **Validate** - Test gameplay, monitor logs
+11. **Configure QA** - Ensure qa.eagle0.net still works (home Mac)
@@ -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",
@@ -0,0 +1,473 @@
+#!/bin/bash
+#
+# generate_changelog.sh
+#
+# Generates a weekly changelog from merged PRs, uses Claude to create a synopsis,
+# and sends an HTML email via Fastmail JMAP API.
+#
+# Usage: ./scripts/generate_changelog.sh [--dry-run]
+#
+# Configuration files (in ~/.config/eagle0/):
+#   fastmail_token      - API token (required)
+#   changelog_recipient - Email addresses, one per line (optional, defaults to sender)
+#
+# To set up:
+#   mkdir -p ~/.config/eagle0
+#   echo 'your-token' > ~/.config/eagle0/fastmail_token
+#   chmod 600 ~/.config/eagle0/fastmail_token
+#
+#   # Optional: configure recipients (one per line, # for comments)
+#   cat > ~/.config/eagle0/changelog_recipient << EOF
+#   alice@example.com
+#   bob@example.com
+#   EOF
+#
+# The script tracks its last run using a git tag 'changelog-last-run'.
+# On first run (no tag), it defaults to the previous Friday at 4pm.
+
+set -euo pipefail
+
+# Ensure homebrew binaries are in PATH
+export PATH="/opt/homebrew/bin:$PATH"
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
+TAG_NAME="changelog-last-run"
+DRY_RUN=false
+FASTMAIL_API="https://api.fastmail.com/jmap/api/"
+CONFIG_DIR="$HOME/.config/eagle0"
+TOKEN_FILE="$CONFIG_DIR/fastmail_token"
+RECIPIENT_FILE="$CONFIG_DIR/changelog_recipient"
+
+# Load API token from file or environment
+load_api_token() {
+    # Environment variable takes precedence
+    if [[ -n "${FASTMAIL_API_TOKEN:-}" ]]; then
+        return 0
+    fi
+
+    # Try loading from config file
+    if [[ -f "$TOKEN_FILE" ]]; then
+        FASTMAIL_API_TOKEN=$(cat "$TOKEN_FILE" | tr -d '[:space:]')
+        if [[ -n "$FASTMAIL_API_TOKEN" ]]; then
+            echo "Loaded API token from $TOKEN_FILE"
+            export FASTMAIL_API_TOKEN
+            return 0
+        fi
+    fi
+
+    return 1
+}
+
+# Load recipient emails from config file (one per line)
+# Returns JSON array fragment like: {"email": "a@b.com"}, {"email": "c@d.com"}
+load_recipients_json() {
+    local recipients=""
+    if [[ -f "$RECIPIENT_FILE" ]]; then
+        while IFS= read -r line || [[ -n "$line" ]]; do
+            # Skip empty lines and comments
+            line=$(echo "$line" | tr -d '[:space:]')
+            [[ -z "$line" || "$line" == \#* ]] && continue
+
+            if [[ -n "$recipients" ]]; then
+                recipients="$recipients, "
+            fi
+            recipients="$recipients{\"email\": \"$line\"}"
+        done < "$RECIPIENT_FILE"
+    fi
+    echo "$recipients"
+}
+
+# Get human-readable list of recipients
+load_recipients_display() {
+    if [[ -f "$RECIPIENT_FILE" ]]; then
+        grep -v '^#' "$RECIPIENT_FILE" | grep -v '^[[:space:]]*$' | tr '\n' ', ' | sed 's/, $//'
+    fi
+}
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --dry-run)
+            DRY_RUN=true
+            shift
+            ;;
+        *)
+            echo "Unknown option: $1"
+            echo "Usage: $0 [--dry-run]"
+            exit 1
+            ;;
+    esac
+done
+
+cd "$REPO_ROOT"
+
+# Get the cutoff date - either from tag or previous Friday 4pm
+get_cutoff_date() {
+    # Try to get the date from the tag
+    if git rev-parse "$TAG_NAME" >/dev/null 2>&1; then
+        # Get the commit date of the tagged commit
+        git log -1 --format="%aI" "$TAG_NAME"
+    else
+        # Calculate previous Friday at 4pm
+        # Get current day of week (1=Monday, 7=Sunday)
+        local dow=$(date +%u)
+        local days_since_friday
+
+        if [[ $dow -ge 5 ]]; then
+            # Friday (5), Saturday (6), or Sunday (7)
+            days_since_friday=$((dow - 5))
+        else
+            # Monday (1) through Thursday (4)
+            days_since_friday=$((dow + 2))
+        fi
+
+        # Get previous Friday at 4pm in ISO format
+        if [[ "$(uname)" == "Darwin" ]]; then
+            date -v-"${days_since_friday}d" -v16H -v0M -v0S +"%Y-%m-%dT%H:%M:%S%z"
+        else
+            date -d "$days_since_friday days ago 16:00:00" --iso-8601=seconds
+        fi
+    fi
+}
+
+# Fetch merged PRs since the cutoff date
+fetch_merged_prs() {
+    local since_date="$1"
+    local output_file="$2"
+
+    echo "Fetching PRs merged since: $since_date"
+
+    # Use gh to search for merged PRs
+    gh pr list \
+        --state merged \
+        --base main \
+        --json number,title,body,mergedAt,author \
+        --jq ".[] | select(.mergedAt >= \"$since_date\")" \
+        > "$output_file.json"
+
+    # Format the output nicely
+    echo "# Merged PRs since $since_date" > "$output_file"
+    echo "" >> "$output_file"
+
+    # Process each PR
+    jq -r '
+        "## PR #\(.number): \(.title)\n" +
+        "Author: \(.author.login)\n" +
+        "Merged: \(.mergedAt)\n\n" +
+        "### Description\n" +
+        (.body // "(No description)") +
+        "\n\n---\n"
+    ' "$output_file.json" >> "$output_file"
+
+    # Count PRs
+    local pr_count=$(jq -s 'length' "$output_file.json")
+    echo "Found $pr_count merged PRs"
+
+    rm -f "$output_file.json"
+
+    if [[ $pr_count -eq 0 ]]; then
+        echo "No PRs found since $since_date"
+        return 1
+    fi
+
+    return 0
+}
+
+# Generate synopsis using Claude
+generate_synopsis() {
+    local input_file="$1"
+    local output_file="$2"
+
+    echo "Generating synopsis with Claude..."
+
+    # Create a prompt file to avoid shell escaping issues
+    local prompt_file="/tmp/eagle0_prompt_$$.txt"
+    # Get repo URL for PR links
+    local repo_url=$(gh repo view --json url -q '.url')
+
+    cat > "$prompt_file" <<PROMPT_HEADER
+You are summarizing changes for a weekly engineering update email.
+
+Read the following list of merged PRs and create a concise synopsis grouped by theme/feature/area of the codebase.
+
+Structure:
+1. <h1> title (e.g., "Eagle0 Weekly Update")
+2. <h2>BLUF</h2> (Bottom Line Up Front) - A short prose paragraph (2-4 sentences) highlighting the 1-3 most important changes this week and what to look for when testing. This should be conversational and help readers quickly understand what matters most.
+3. Synopsis sections (<h2> headings with bullet point summaries)
+4. <hr> divider
+5. <h2>PR Details</h2> with the same groupings, but smaller (<h3> headings) and listing PR links
+   - Format each PR as: <a href="${repo_url}/pull/NUMBER">#NUMBER</a>: Title
+
+Guidelines for the SYNOPSIS sections:
+- Group related changes together under clear headings (use <h2> tags)
+- Use bullet points (<ul><li>) for individual changes
+- Highlight any significant new features, breaking changes, or important fixes
+- Keep the tone professional but accessible
+- Don't include PR numbers in the synopsis - focus on what changed and why it matters
+
+IMPORTANT: Output valid HTML that can be used directly in an email body. Do NOT wrap in \`\`\`html code blocks - just output the raw HTML.
+
+Here are the merged PRs:
+
+PROMPT_HEADER
+
+    cat "$input_file" >> "$prompt_file"
+    echo "" >> "$prompt_file"
+    echo "Generate the synopsis now:" >> "$prompt_file"
+
+    # Use Claude CLI to generate the synopsis, wrapped in proper HTML with charset
+    local raw_output="/tmp/eagle0_raw_$$.html"
+    cat "$prompt_file" | claude --print > "$raw_output"
+
+    # Wrap in HTML document with UTF-8 charset
+    cat > "$output_file" <<'HTML_HEAD'
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+</head>
+<body>
+HTML_HEAD
+    cat "$raw_output" >> "$output_file"
+    echo "</body></html>" >> "$output_file"
+
+    rm -f "$prompt_file" "$raw_output"
+    echo "Synopsis generated at: $output_file"
+}
+
+# Get Fastmail session info (account ID, identity ID, drafts mailbox ID)
+get_fastmail_session() {
+    echo "Fetching Fastmail session info..." >&2
+
+    # Get session
+    local session=$(curl -s \
+        -H "Authorization: Bearer $FASTMAIL_API_TOKEN" \
+        "https://api.fastmail.com/jmap/session")
+
+    # Extract account ID (first account)
+    FASTMAIL_ACCOUNT_ID=$(echo "$session" | jq -r '.primaryAccounts["urn:ietf:params:jmap:mail"]')
+
+    if [[ -z "$FASTMAIL_ACCOUNT_ID" || "$FASTMAIL_ACCOUNT_ID" == "null" ]]; then
+        echo "Error: Could not get Fastmail account ID. Check your API token." >&2
+        return 1
+    fi
+    echo "Account ID: $FASTMAIL_ACCOUNT_ID" >&2
+
+    # Get identity ID
+    local identity_response=$(curl -s \
+        -H "Authorization: Bearer $FASTMAIL_API_TOKEN" \
+        -H "Content-Type: application/json" \
+        -X POST \
+        -d "{
+            \"using\": [\"urn:ietf:params:jmap:core\", \"urn:ietf:params:jmap:mail\", \"urn:ietf:params:jmap:submission\"],
+            \"methodCalls\": [
+                [\"Identity/get\", {\"accountId\": \"$FASTMAIL_ACCOUNT_ID\"}, \"0\"]
+            ]
+        }" \
+        "$FASTMAIL_API")
+
+    FASTMAIL_IDENTITY_ID=$(echo "$identity_response" | jq -r '.methodResponses[0][1].list[0].id')
+    FASTMAIL_FROM_EMAIL=$(echo "$identity_response" | jq -r '.methodResponses[0][1].list[0].email')
+
+    if [[ -z "$FASTMAIL_IDENTITY_ID" || "$FASTMAIL_IDENTITY_ID" == "null" ]]; then
+        echo "Error: Could not get Fastmail identity ID." >&2
+        return 1
+    fi
+    echo "Identity ID: $FASTMAIL_IDENTITY_ID (${FASTMAIL_FROM_EMAIL})" >&2
+
+    # Get drafts mailbox ID
+    local mailbox_response=$(curl -s \
+        -H "Authorization: Bearer $FASTMAIL_API_TOKEN" \
+        -H "Content-Type: application/json" \
+        -X POST \
+        -d "{
+            \"using\": [\"urn:ietf:params:jmap:core\", \"urn:ietf:params:jmap:mail\"],
+            \"methodCalls\": [
+                [\"Mailbox/query\", {\"accountId\": \"$FASTMAIL_ACCOUNT_ID\", \"filter\": {\"role\": \"drafts\"}}, \"0\"]
+            ]
+        }" \
+        "$FASTMAIL_API")
+
+    FASTMAIL_DRAFTS_ID=$(echo "$mailbox_response" | jq -r '.methodResponses[0][1].ids[0]')
+
+    if [[ -z "$FASTMAIL_DRAFTS_ID" || "$FASTMAIL_DRAFTS_ID" == "null" ]]; then
+        echo "Error: Could not get Fastmail drafts mailbox ID." >&2
+        return 1
+    fi
+    echo "Drafts mailbox ID: $FASTMAIL_DRAFTS_ID" >&2
+
+    return 0
+}
+
+# Send email via Fastmail JMAP API
+send_email_fastmail() {
+    local synopsis_file="$1"
+    local recipients_json="$2"  # JSON array fragment: {"email": "a@b.com"}, {"email": "c@d.com"}
+
+    local subject="Eagle0 Weekly Changelog - $(date +%Y-%m-%d)"
+    local html_body=$(cat "$synopsis_file" | jq -Rs .)
+
+    echo "Sending email via Fastmail JMAP API..."
+
+    # Create the email and send it in one request
+    local response=$(curl -s \
+        -H "Authorization: Bearer $FASTMAIL_API_TOKEN" \
+        -H "Content-Type: application/json" \
+        -X POST \
+        -d "{
+            \"using\": [
+                \"urn:ietf:params:jmap:core\",
+                \"urn:ietf:params:jmap:mail\",
+                \"urn:ietf:params:jmap:submission\"
+            ],
+            \"methodCalls\": [
+                [\"Email/set\", {
+                    \"accountId\": \"$FASTMAIL_ACCOUNT_ID\",
+                    \"create\": {
+                        \"draft\": {
+                            \"from\": [{\"email\": \"$FASTMAIL_FROM_EMAIL\"}],
+                            \"to\": [$recipients_json],
+                            \"subject\": \"$subject\",
+                            \"mailboxIds\": {\"$FASTMAIL_DRAFTS_ID\": true},
+                            \"keywords\": {\"\$draft\": true},
+                            \"htmlBody\": [{\"partId\": \"body\", \"type\": \"text/html\"}],
+                            \"bodyValues\": {
+                                \"body\": {
+                                    \"charset\": \"utf-8\",
+                                    \"value\": $html_body
+                                }
+                            }
+                        }
+                    }
+                }, \"0\"],
+                [\"EmailSubmission/set\", {
+                    \"accountId\": \"$FASTMAIL_ACCOUNT_ID\",
+                    \"onSuccessDestroyEmail\": [\"#sendIt\"],
+                    \"create\": {
+                        \"sendIt\": {
+                            \"emailId\": \"#draft\",
+                            \"identityId\": \"$FASTMAIL_IDENTITY_ID\"
+                        }
+                    }
+                }, \"1\"]
+            ]
+        }" \
+        "$FASTMAIL_API")
+
+    # Check for errors
+    local error=$(echo "$response" | jq -r '.methodResponses[0][1].notCreated.draft.description // empty')
+    if [[ -n "$error" ]]; then
+        echo "Error creating email: $error" >&2
+        echo "Full response: $response" >&2
+        return 1
+    fi
+
+    local send_error=$(echo "$response" | jq -r '.methodResponses[1][1].notCreated.sendIt.description // empty')
+    if [[ -n "$send_error" ]]; then
+        echo "Error sending email: $send_error" >&2
+        echo "Full response: $response" >&2
+        return 1
+    fi
+
+    echo "Email sent successfully"
+}
+
+# Update the tag to mark this run
+update_tag() {
+    echo "Updating $TAG_NAME tag..."
+
+    # Delete existing tag if present
+    git tag -d "$TAG_NAME" 2>/dev/null || true
+    git push origin --delete "$TAG_NAME" 2>/dev/null || true
+
+    # Create new tag at HEAD
+    git tag "$TAG_NAME"
+    git push origin "$TAG_NAME"
+
+    echo "Tag updated to current HEAD"
+}
+
+# Main
+main() {
+    echo "=== Eagle0 Weekly Changelog Generator ==="
+    echo ""
+
+    # Load API token (only required for actual send)
+    if [[ "$DRY_RUN" != "true" ]]; then
+        if ! load_api_token; then
+            echo "Error: No Fastmail API token found."
+            echo ""
+            echo "To create a token:"
+            echo "1. Go to Fastmail Settings -> Password & Security -> API tokens"
+            echo "2. Create a new token with 'Email submission' scope"
+            echo "3. Save it using one of these methods:"
+            echo ""
+            echo "   Option A (recommended): Store in config file"
+            echo "     mkdir -p ~/.config/eagle0"
+            echo "     echo 'your-token' > ~/.config/eagle0/fastmail_token"
+            echo "     chmod 600 ~/.config/eagle0/fastmail_token"
+            echo ""
+            echo "   Option B: Set environment variable"
+            echo "     export FASTMAIL_API_TOKEN='your-token'"
+            exit 1
+        fi
+    fi
+
+    # Get cutoff date
+    local cutoff_date=$(get_cutoff_date)
+    echo "Cutoff date: $cutoff_date"
+
+    # Create temp files
+    local pr_file="/tmp/eagle0_prs_$(date +%s).md"
+    local synopsis_file="/tmp/eagle0_synopsis_$(date +%s).html"
+
+    # Fetch PRs
+    if ! fetch_merged_prs "$cutoff_date" "$pr_file"; then
+        echo "No changes to report. Exiting."
+        exit 0
+    fi
+
+    echo ""
+    echo "PR details saved to: $pr_file"
+
+    # Generate synopsis
+    generate_synopsis "$pr_file" "$synopsis_file"
+
+    if [[ "$DRY_RUN" == "true" ]]; then
+        echo ""
+        echo "=== DRY RUN - Synopsis content ==="
+        cat "$synopsis_file"
+        echo ""
+        echo "=== DRY RUN - Skipping email send and tag update ==="
+    else
+        # Get Fastmail session info
+        if ! get_fastmail_session; then
+            echo "Failed to get Fastmail session info. Exiting."
+            exit 1
+        fi
+
+        # Determine recipients (from config file, or default to sender)
+        local recipients_json=$(load_recipients_json)
+        if [[ -z "$recipients_json" ]]; then
+            recipients_json="{\"email\": \"$FASTMAIL_FROM_EMAIL\"}"
+            echo "No recipients configured, sending to self ($FASTMAIL_FROM_EMAIL)"
+        else
+            local recipients_display=$(load_recipients_display)
+            echo "Sending to: $recipients_display"
+        fi
+
+        # Send email
+        send_email_fastmail "$synopsis_file" "$recipients_json"
+
+        # Update tag for next run
+        update_tag
+    fi
+
+    echo ""
+    echo "Done!"
+    echo "PR details: $pr_file"
+    echo "Synopsis: $synopsis_file"
+}
+
+main
@@ -65,11 +65,6 @@ private:
            const GameStateW& guessedState,
            const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;

-    [[nodiscard]] auto ChooseCommandIndex(
-            const GameSettingsSPtr& settings,
-            const net::eagle0::shardok::api::GameStateView& gsv,
-            const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;
-
 public:
    explicit ShardokAIClient(
            PlayerId playerId,
@@ -86,6 +81,12 @@ public:
    [[nodiscard]] auto ChooseCommandIndex(const ShardokEngine& engine) const
            -> CommandChoiceResults;

+    // Overload that works on copies of state - allows caller to release lock during AI thinking
+    [[nodiscard]] auto ChooseCommandIndex(
+            const GameSettingsSPtr& settings,
+            const net::eagle0::shardok::api::GameStateView& gsv,
+            const CommandListSPtr& realAvailableCommands) const -> CommandChoiceResults;
+
    // MCTS configuration methods (only relevant when using MCTS algorithm)
    [[nodiscard]] auto GetMCTSConfig() const -> const mcts::MCTSConfig& { return mctsConfig; }
    void SetMCTSConfig(const mcts::MCTSConfig& config) { mctsConfig = config; }
@@ -81,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);

@@ -111,17 +111,67 @@ void ShardokGameController::DoAIThread() {
    if (aiClients.empty()) { printf("No AI players, exiting AI thread.\n"); }

    while (aiThreadKeepGoing) {
-        while (incomingRegistrations > 0) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        // Phase 1: Gather data for AI decision (brief lock)
+        shared_ptr<ShardokAIClient> aiClient;
+        PlayerId playerId;
+        GameSettingsSPtr settings;
+        net::eagle0::shardok::api::GameStateView gsv;
+        CommandListSPtr availableCommands;
+        size_t expectedHistoryCount;
+
+        {
+            unique_lock lk(masterLock);
+
+            if (engine->GameIsOver()) {
+                aiThreadKeepGoing = false;
+                continue;
+            }
+
+            playerId = engine->GetCurrentPlayerId();
+            aiClient = LockedAIClientForPid(playerId);
+
+            if (!aiClient) {
+                // Not an AI player's turn - wait for signal
+                aiCondition.wait(lk);
+                aiThreadKeepGoing = aiThreadKeepGoing && !engine->GameIsOver();
+                continue;
+            }
+
+            // Get copies of everything the AI needs
+            settings = engine->GetGameSettings();
+            gsv = engine->GetGameStateView(playerId);
+            availableCommands = engine->GetAvailableCommandsForAIPlayer(playerId);
+            expectedHistoryCount = engine->GetUnfilteredHistoryCount();
+        }
+        // Lock released - polls can now get through
+
+        if (availableCommands->empty()) {
+            printf("no commands for player %d\n", playerId);
+            continue;
        }

-        unique_lock lk(masterLock);
-        if (LockedCheckOneAICommand()) {
+        // Phase 2: AI thinks (NO LOCK - this is the slow part)
+        const auto results = aiClient->ChooseCommandIndex(settings, gsv, availableCommands);
+
+        // Phase 3: Post the command (brief lock)
+        {
+            unique_lock lk(masterLock);
+
+            // Verify state hasn't changed while we were thinking
+            if (engine->GetUnfilteredHistoryCount() != expectedHistoryCount) {
+                // State changed (e.g., human posted command) - re-evaluate
+                printf("AI: State changed while thinking, re-evaluating\n");
+                continue;
+            }
+
+            if (engine->GameIsOver()) {
+                aiThreadKeepGoing = false;
+                continue;
+            }
+
+            engine->PostCommand(playerId, results.chosenIndex);
            LockedNotifyClients();
-            aiThreadKeepGoing = aiThreadKeepGoing && !engine->GameIsOver();
-        } else {
-            aiCondition.wait(lk);
-            aiThreadKeepGoing = aiThreadKeepGoing && !engine->GameIsOver();
+            aiThreadKeepGoing = !engine->GameIsOver();
        }
    }
    printf("Exiting AI thread.\n");
@@ -136,24 +186,6 @@ ShardokGameController::~ShardokGameController() {
    aiThread.join();
 }

-auto ShardokGameController::LockedCheckOneAICommand() -> bool {
-    if (engine->GameIsOver()) {
-        printf("Game is over!\n");
-        return false;
-    }
-
-    const PlayerId currentPid = engine->GetCurrentPlayerId();
-    if (const shared_ptr<ShardokAIClient> currentPlayerClient = LockedAIClientForPid(currentPid)) {
-        const int index = currentPlayerClient->ChooseCommandIndex(*engine).chosenIndex;
-
-        engine->PostCommand(currentPid, index);
-        LockedNotifyClients();
-        return true;
-    }
-
-    return false;
-}
-
 void CheckFactionId(
        const unique_ptr<ShardokEngine> &engine,
        const PlayerId shardokPlayerId,
@@ -229,6 +261,7 @@ void ShardokGameController::PostPlacementCommands(
 }

 auto ShardokGameController::GetCurrentGameStateBytes() -> byte_vector {
+    scoped_lock<mutex> guard(masterLock);
    return engine->GetCurrentGameStateBytes();
 }

@@ -292,6 +325,9 @@ auto ShardokGameController::GetUpdates(const int64_t startingActionId) -> AllUpd
                -1,
                engine->FilterNewResults(-1, startingActionId),
                nullptr);
+
+        auto gameStateBytes = engine->GetCurrentGameStateBytes();
+        updates.currentGameState.swap(gameStateBytes);
    }

    return updates;
@@ -321,4 +357,74 @@ auto ShardokGameController::ResolvedPlayerInfos()
    return engine->GetPlayerInfos();
 }

+void ShardokGameController::RegisterSubscriber(std::shared_ptr<StreamSubscriber> subscriber) {
+    scoped_lock<mutex> guard(subscriberLock);
+    subscribers.push_back(subscriber);
+}
+
+void ShardokGameController::UnregisterSubscriber(const StreamSubscriber *subscriber) {
+    scoped_lock<mutex> guard(subscriberLock);
+    subscribers.erase(
+            std::remove_if(
+                    subscribers.begin(),
+                    subscribers.end(),
+                    [subscriber](const std::weak_ptr<StreamSubscriber> &weakSub) {
+                        auto sub = weakSub.lock();
+                        return !sub || sub.get() == subscriber;
+                    }),
+            subscribers.end());
+}
+
+auto ShardokGameController::WaitForUpdatesAndPush(
+        std::shared_ptr<StreamSubscriber> subscriber,
+        int64_t startingActionId) -> bool {
+    int64_t lastPushedActionId = startingActionId;
+
+    while (subscriber->IsActive()) {
+        bool gameOver = false;
+        GameOverInfo gameOverInfo{};
+
+        {
+            unique_lock<mutex> guard(masterLock);
+
+            // Wait for updates or game over
+            updateCondition.wait(guard, [this, lastPushedActionId] {
+                return engine->GetUnfilteredHistoryCount() >
+                               static_cast<size_t>(lastPushedActionId) ||
+                       engine->GameIsOver();
+            });
+
+            if (!subscriber->IsActive()) { return false; }
+
+            gameOver = engine->GameIsOver();
+
+            if (gameOver) {
+                gameOverInfo.gameStatus = fb::ToProto(engine->GetGameStatus());
+                gameOverInfo.playerInfos = engine->GetPlayerInfos();
+                gameOverInfo.endGameUnits = engine->EndGameUnits();
+            }
+        }
+        // Lock released - GetUpdates will acquire its own lock
+
+        if (gameOver) {
+            subscriber->OnGameOver(gameOverInfo);
+            return true;
+        }
+
+        // Get updates outside the lock (GetUpdates acquires masterLock internally)
+        AllUpdates updates = GetUpdates(lastPushedActionId);
+        lastPushedActionId = updates.newUnfilteredCount;
+
+        if (!updates.mainResults.empty()) {
+            subscriber->OnUpdate(
+                    updates.mainResults,
+                    updates.filteredResults,
+                    updates.newUnfilteredCount,
+                    updates.currentGameState);
+        }
+    }
+
+    return false;  // Subscriber disconnected
+}
+
 }  // namespace shardok
@@ -10,6 +10,7 @@
 #define ShardokGameController_hpp

 #include <functional>
+#include <memory>
 #include <mutex>
 #include <utility>
 #include <vector>
@@ -29,6 +30,50 @@ using std::shared_ptr;
 using std::unique_ptr;
 using std::weak_ptr;

+// Forward declaration
+class ShardokGameController;
+
+/// Info about a game that has ended, for notifying subscribers
+struct GameOverInfo {
+    vector<net::eagle0::shardok::common::PlayerInfo> playerInfos;
+    vector<net::eagle0::shardok::storage::ResolvedUnit> endGameUnits;
+    net::eagle0::shardok::common::GameStatus gameStatus;
+};
+
+/// Updates for a single player (includes faction ID for client routing)
+struct OnePlayerUpdates {
+    int32_t eagleFactionId;
+    vector<ActionResultView> resultViews;
+    shared_ptr<AvailableCommands> availableCommands;
+
+    OnePlayerUpdates(
+            const int32_t fid,
+            const vector<ActionResultView>& arvs,
+            const shared_ptr<AvailableCommands>& acs)
+        : eagleFactionId(fid),
+          resultViews(arvs),
+          availableCommands(acs) {}
+};
+
+/// Interface for subscribers that receive streaming updates from a game
+class StreamSubscriber {
+public:
+    virtual ~StreamSubscriber() = default;
+
+    /// Called when new game updates are available
+    virtual void OnUpdate(
+            const vector<ActionResult>& mainResults,
+            const vector<OnePlayerUpdates>& filteredResults,
+            int32_t newUnfilteredCount,
+            const byte_vector& currentGameState) = 0;
+
+    /// Called when the game ends
+    virtual void OnGameOver(const GameOverInfo& info) = 0;
+
+    /// Returns true if this subscriber is still active and should receive updates
+    [[nodiscard]] virtual auto IsActive() const -> bool = 0;
+};
+
 class ShardokGameController {
 private:
    // This lock should be held any time we call into engine or modify clients.
@@ -39,10 +84,17 @@ private:
    // Fires whenever there is a new game state update.
    mutable std::condition_variable updateCondition{};

+    // Stream subscribers - protected by separate lock to avoid deadlock with masterLock
+    mutable std::mutex subscriberLock{};
+    std::vector<std::weak_ptr<StreamSubscriber>> subscribers{};
+
    string serializedRequest;

    unique_ptr<ShardokEngine> engine;

+    // Cached immutable data - safe to access without lock since it never changes after construction
+    const GameId cachedGameId;
+
    std::atomic_int incomingRegistrations = 0;

    const string mapName;
@@ -60,11 +112,9 @@ private:

    void LockedNotifyClients() const;

-    auto LockedCheckOneAICommand() -> bool;
-
    auto LockedAIClientForPid(PlayerId pid) const -> shared_ptr<ShardokAIClient>;

-    static vector<shared_ptr<ShardokAIClient>> MakeAIClients(const unique_ptr<ShardokEngine> &e);
+    static vector<shared_ptr<ShardokAIClient>> MakeAIClients(const unique_ptr<ShardokEngine>& e);

    void DoAIThread();

@@ -75,6 +125,7 @@ public:
            string serializedRequest = "")
        : serializedRequest(std::move(serializedRequest)),
          engine(std::move(e)),
+          cachedGameId(engine->GetGameId()),
          mapName(std::move(mapName)),
          logFilePath(MakeLogFilePath()),
          aiClients(MakeAIClients(engine)),
@@ -98,26 +149,13 @@ public:
            PlayerId shardokPlayerId,
            int eagleFactionId,
            int64_t token,
-            const vector<UnitPlacementInfo> &infos);
-
-    struct OnePlayerUpdates {
-        int32_t eagleFactionId;
-        vector<ActionResultView> resultViews;
-        shared_ptr<AvailableCommands> availableCommands;
-
-        OnePlayerUpdates(
-                const int32_t fid,
-                const vector<ActionResultView> &arvs,
-                const shared_ptr<AvailableCommands> &acs)
-            : eagleFactionId(fid),
-              resultViews(arvs),
-              availableCommands(acs) {}
-    };
+            const vector<UnitPlacementInfo>& infos);

    struct AllUpdates {
        vector<ActionResult> mainResults;
        vector<OnePlayerUpdates> filteredResults;
        int32_t newUnfilteredCount;
+        byte_vector currentGameState;
    };
    auto GetUpdates(int64_t startingActionId) -> AllUpdates;
    auto GetCurrentGameStateBytes() -> byte_vector;
@@ -127,13 +165,23 @@ public:
    auto ResolvedPlayerInfos() -> vector<net::eagle0::shardok::common::PlayerInfo>;
    auto EndGameUnits() -> vector<net::eagle0::shardok::storage::ResolvedUnit>;

-    [[nodiscard]] auto GetGameId() const -> GameId { return engine->GetGameId(); }
-
-    [[nodiscard]] auto GetHexMap() const -> const HexMap * {
-        return engine->GetCurrentGameState()->hex_map();
-    }
+    [[nodiscard]] auto GetGameId() const -> GameId { return cachedGameId; }

    [[nodiscard]] auto GetLogFilePath() const -> string { return logFilePath; }
+
+    /// Register a subscriber to receive streaming updates for this game.
+    /// The subscriber will receive updates until it becomes inactive or is unregistered.
+    void RegisterSubscriber(std::shared_ptr<StreamSubscriber> subscriber);
+
+    /// Unregister a subscriber. Safe to call even if the subscriber was never registered.
+    void UnregisterSubscriber(const StreamSubscriber* subscriber);
+
+    /// Wait for game updates, pushing them to the given subscriber.
+    /// Blocks until the game ends or the subscriber becomes inactive.
+    /// Returns true if the game ended normally, false if subscriber disconnected.
+    auto WaitForUpdatesAndPush(
+            std::shared_ptr<StreamSubscriber> subscriber,
+            int64_t startingActionId) -> bool;
 };
 }  // namespace shardok

@@ -529,6 +529,130 @@ auto FromInternalStatus(
    throw ShardokInternalErrorException("Bad unit status on resolved unit");
 }

+auto EagleInterfaceImpl::SubscribeToGame(
+        ServerContext *context,
+        const GameSubscriptionRequest *request,
+        grpc::ServerWriter<GameStatusResponse> *writer) -> Status {
+    shared_ptr<ShardokGameController> controller;
+    try {
+        controller = ControllerForGame(request->game_id(), request->game_setup_info());
+    } catch (NewGameException &e) { return e.GetStatus(); }
+
+    if (!controller) { return Status(StatusCode::NOT_FOUND, "Game not found"); }
+
+    // Send initial state
+    GameStatusResponse initialResponse;
+    PopulateGameStatusResponse(
+            controller,
+            request->game_setup_info().known_result_count(),
+            &initialResponse);
+    if (!writer->Write(initialResponse)) {
+        return Status::OK;  // Client disconnected
+    }
+
+    // If game was already over, we're done
+    if (initialResponse.has_game_over_response()) { return Status::OK; }
+
+    // Track the actual count after initial response to avoid duplicate sends
+    const int64_t countAfterInitialResponse =
+            initialResponse.has_game_update_response()
+                    ? initialResponse.game_update_response().total_action_result_count()
+                    : request->game_setup_info().known_result_count();
+
+    // Create a subscriber that writes to the gRPC stream
+    class GrpcStreamSubscriber : public StreamSubscriber {
+    private:
+        grpc::ServerWriter<GameStatusResponse> *writer_;
+        ServerContext *context_;
+        std::atomic<bool> active_{true};
+        std::string gameId_;
+
+    public:
+        GrpcStreamSubscriber(
+                grpc::ServerWriter<GameStatusResponse> *w,
+                ServerContext *ctx,
+                std::string gameId)
+            : writer_(w),
+              context_(ctx),
+              gameId_(std::move(gameId)) {}
+
+        void OnUpdate(
+                const vector<ActionResult> &mainResults,
+                const vector<OnePlayerUpdates> &filteredResults,
+                int32_t newUnfilteredCount,
+                const byte_vector &currentGameState) override {
+            if (!active_) return;
+
+            GameStatusResponse response;
+            response.set_game_id(gameId_);
+
+            response.mutable_game_update_response()->mutable_update_responses()->Add(
+                    begin(mainResults),
+                    end(mainResults));
+
+            // Add filtered results for each player with their faction IDs
+            for (const auto &playerUpdate : filteredResults) {
+                auto *filtered =
+                        response.mutable_game_update_response()->add_filtered_update_responses();
+                filtered->set_eagle_faction_id(playerUpdate.eagleFactionId);
+                filtered->mutable_action_result_views()->Add(
+                        begin(playerUpdate.resultViews),
+                        end(playerUpdate.resultViews));
+                if (playerUpdate.availableCommands) {
+                    *filtered->mutable_available_commands() = *playerUpdate.availableCommands;
+                }
+            }
+
+            response.mutable_game_update_response()->set_total_action_result_count(
+                    newUnfilteredCount);
+            *response.mutable_game_update_response()->mutable_current_game_state() =
+                    std::string(currentGameState.begin(), currentGameState.end());
+
+            if (!writer_->Write(response)) { active_ = false; }
+        }
+
+        void OnGameOver(const GameOverInfo &info) override {
+            if (!active_) return;
+
+            GameStatusResponse response;
+            response.set_game_id(gameId_);
+
+            PopulateGameOverResponse(
+                    gameId_,
+                    info.gameStatus,
+                    info.playerInfos,
+                    info.endGameUnits,
+                    response.mutable_game_over_response());
+
+            writer_->Write(response);
+            active_ = false;
+        }
+
+        [[nodiscard]] auto IsActive() const -> bool override {
+            return active_ && !context_->IsCancelled();
+        }
+    };
+
+    auto subscriber =
+            std::make_shared<GrpcStreamSubscriber>(writer, context, controller->GetGameId());
+
+    controller->RegisterSubscriber(subscriber);
+
+    // Wait for updates and push them until game ends or subscriber disconnects
+    // Use countAfterInitialResponse to avoid re-sending results already in initial response
+    bool gameEnded = controller->WaitForUpdatesAndPush(subscriber, countAfterInitialResponse);
+
+    controller->UnregisterSubscriber(subscriber.get());
+
+    if (gameEnded) {
+        printf("SubscribeToGame: Game ended normally\n");
+    } else {
+        printf("SubscribeToGame: Subscriber disconnected\n");
+    }
+
+    return Status::OK;
+}
+
 }  // namespace shardok

 #ifndef NDEBUG
@@ -33,6 +33,7 @@ using grpc::Status;
 using net::eagle0::common::GameSetupInfo;
 using net::eagle0::common::GameStatusRequest;
 using net::eagle0::common::GameStatusResponse;
+using net::eagle0::common::GameSubscriptionRequest;
 using net::eagle0::common::HexMapNamesRequest;
 using net::eagle0::common::HexMapNamesResponse;
 using net::eagle0::common::HexMapRequest;
@@ -78,6 +79,11 @@ public:
            ServerContext* context,
            const HexMapNamesRequest* request,
            HexMapNamesResponse* response) -> Status override;
+
+    auto SubscribeToGame(
+            ServerContext* context,
+            const GameSubscriptionRequest* request,
+            grpc::ServerWriter<GameStatusResponse>* writer) -> Status override;
 };
 }  // namespace shardok

@@ -149,6 +149,7 @@
    <Compile Include="Assets/Eagle/Notifications/ARNNotifications/TruceRejectedDetailsNotificationGenerator.cs" />
    <Compile Include="Assets/Eagle/Notifications/RiotSuppressedNotificationGenerator.cs" />
    <Compile Include="Assets/Modern UI Pack/Scripts/Modal Window/ModalWindowManagerEditor.cs" />
+    <Compile Include="Assets/common/GUIUtils/AutoScrollingText.cs" />
    <Compile Include="Assets/Bluetooth/NativeDiceInterfaceImports.cs" />
    <Compile Include="Assets/Eagle/Notifications/ProvinceConqueredNotificationGenerator.cs" />
    <Compile Include="Assets/Eagle/Table Rows/ExtraTroopsRowController.cs" />
@@ -449,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) {}
 }
@@ -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;

@@ -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); }
    }
-}
+}
@@ -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 =>
@@ -120,6 +120,19 @@ namespace eagle {
            }
        }

+        /// <summary>
+        /// Force the circuit breaker to allow an immediate reconnect attempt.
+        /// Resets the state to HalfOpen so the next connection will be a test.
+        /// </summary>
+        public void ForceReconnect() {
+            lock (this) {
+                if (_state == State.Open) {
+                    _state = State.HalfOpen;
+                    _logger.LogLine("[CIRCUIT] OPEN → HALF_OPEN (forced by user)");
+                }
+            }
+        }
+
        /// <summary>
        /// Get human-readable status for UI display.
        /// </summary>
@@ -138,7 +151,7 @@ namespace eagle {
                            var timeUntilTest = OpenTimeoutSeconds -
                                                (DateTime.UtcNow - _openedAt.Value).TotalSeconds;
                            if (timeUntilTest > 0) {
-                                return $"Server unavailable. Retrying in {(int)timeUntilTest}s";
+                                return $"Server unavailable. Retrying in {Math.Min(10, (int)timeUntilTest)}s";
                            }
                        }
                        return "Server unavailable. Testing...";
@@ -1,8 +1,23 @@
 using System;
+using Net.Eagle0.Eagle.Api;
 using TMPro;
 using UnityEngine;
+using UnityEngine.UI;

 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.
@@ -10,6 +25,10 @@ namespace eagle {
    public class ConnectionStatusUI : MonoBehaviour {
        private TextMeshProUGUI _textComponent;
        private PersistentClientConnection _connection;
+        private IGameStateProvider _gameStateProvider;
+
+        [Tooltip("Optional button to force immediate reconnection when server is down")]
+        public Button retryButton;

        // Update interval in seconds
        private const float UpdateInterval = 0.5f;
@@ -24,9 +43,10 @@ namespace eagle {
                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
+            if (retryButton != null) {
+                retryButton.onClick.AddListener(OnRetryClicked);
+                retryButton.gameObject.SetActive(false);
+            }
        }

        /// <summary>
@@ -36,6 +56,14 @@ namespace eagle {
            _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; }

@@ -50,11 +78,12 @@ namespace eagle {
            // Check circuit breaker state first - it takes precedence
            var circuitState = _connection.CircuitBreaker.CurrentState;
            if (circuitState == ConnectionCircuitBreaker.State.Open) {
+                SetRetryButtonVisible(true);
                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);
+                        int seconds = Math.Min(10, (int)Math.Ceiling(timeUntilTest.TotalSeconds));
                        _textComponent.text =
                                $"<color=red>●</color> Server down. Retry in {seconds}s";
                        return;
@@ -63,6 +92,7 @@ namespace eagle {
                _textComponent.text = "<color=red>●</color> Server unavailable";
                return;
            } else if (circuitState == ConnectionCircuitBreaker.State.HalfOpen) {
+                SetRetryButtonVisible(false);
                _textComponent.text = "<color=yellow>●</color> Testing connection...";
                return;
            }
@@ -71,8 +101,13 @@ namespace eagle {
            var state = _connection.CurrentState;
            var nextAttempt = _connection.NextReconnectAttempt;

+            // Show retry button if we're counting down to a reconnect attempt
+            bool isCountingDown = state == ConnectionState.Reconnecting && nextAttempt.HasValue &&
+                                  (nextAttempt.Value - DateTime.UtcNow).TotalSeconds > 0;
+            SetRetryButtonVisible(isCountingDown);
+
            string statusText = state switch {
-                ConnectionState.Connected => "<color=green>●</color> Connected",
+                ConnectionState.Connected => GetConnectedStatusText(),
                ConnectionState.Connecting => "<color=yellow>●</color> Connecting...",
                ConnectionState.Disconnected => "<color=red>●</color> Disconnected",
                ConnectionState.Reconnecting => GetReconnectingText(nextAttempt),
@@ -83,6 +118,34 @@ namespace eagle {
            _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..."; }

@@ -91,8 +154,16 @@ namespace eagle {
                return "<color=yellow>●</color> Reconnecting...";
            }

-            int secondsRemaining = (int)Math.Ceiling(timeUntilRetry.TotalSeconds);
+            int secondsRemaining = Math.Min(10, (int)Math.Ceiling(timeUntilRetry.TotalSeconds));
            return $"<color=orange>●</color> Retry in {secondsRemaining}s";
        }
+
+        private void SetRetryButtonVisible(bool visible) {
+            if (retryButton != null) { retryButton.gameObject.SetActive(visible); }
+        }
+
+        private void OnRetryClicked() {
+            if (_connection != null) { _connection.ForceReconnect(); }
+        }
    }
 }
@@ -165,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) {
@@ -184,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(); }

@@ -222,12 +229,11 @@ namespace eagle {

        void OnApplicationPause(bool pause) {
            if (ModelUpdater == null) { return; }
-            if (pause) {
-                ModelUpdater.StopListeningForUpdates();
-            } else {
-                // Fire-and-forget - subscription is awaited internally and failures are logged
-                _ = ModelUpdater.StartListeningForUpdates();
-            }
+            // Don't unsubscribe on pause - this caused a race condition where the subscriber
+            // could be lost if pause happened before the async StartListeningForUpdates completed.
+            // With MainQueue rate-limiting, keeping the subscription during pause is safe.
+            // Reconnects will continue to work, and updates will queue up and be processed on
+            // resume.
        }

 #if UNITY_EDITOR
@@ -263,6 +269,10 @@ namespace eagle {

            ModelUpdater.ErrorHandler = errorHandler;

+            // 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(); });
@@ -43,7 +43,7 @@ namespace eagle {
        TokenId? CommandToken { get; }
        TokenId LastPostedToken { get; }

-        Dictionary<String, ShardokGameModel> ShardokGameModels { get; }
+        ConcurrentDictionary<String, ShardokGameModel> ShardokGameModels { get; }

        private bool ShardokGameModelIsRunning(ShardokGameModel sgm) =>
                sgm.GameStatus.State == GameStatus.Types.State.GameRunning
@@ -62,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) {
@@ -95,15 +95,22 @@ 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 => {
                            var needsResync = _shardokNeedsResync.GetValueOrDefault(sgm.Key, false);
+                            // Use thread-safe count from gRPC thread updates. Fall back to 0 if
+                            // not yet tracked (avoids accessing non-thread-safe History.Count).
+                            var count = _shardokResultCounts.GetValueOrDefault(sgm.Key, 0);
                            return new IClientConnectionSubscriber.ShardokViewStatus {
                                shardokGameId = sgm.Key,
-                                filteredResultCount = needsResync ? 0 : sgm.Value.History.Count(),
+                                filteredResultCount = needsResync ? 0 : count,
                                requestFullResync = needsResync
                            };
                        })
@@ -122,15 +129,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
@@ -179,7 +198,8 @@ namespace eagle {
                return new List<AvailableCommand>();
            }

-            public Dictionary<String, ShardokGameModel> ShardokGameModels { get; set; }
+            // Thread-safe: accessed from heartbeat timer thread via ShardokViewStatuses
+            public ConcurrentDictionary<String, ShardokGameModel> ShardokGameModels { get; set; }

            public FactionView MaybeDestroyedFaction(FactionId factionId) {
                if (ActiveFactions.TryGetValue(factionId, out var factionView)) {
@@ -221,7 +241,8 @@ namespace eagle {
                    new Dictionary<ProvinceId, OneProvinceAvailableCommands>();

            _currentModel.GsView = new GameStateView();
-            _currentModel.ShardokGameModels = new Dictionary<ShardokGameId, ShardokGameModel>();
+            _currentModel.ShardokGameModels =
+                    new ConcurrentDictionary<ShardokGameId, ShardokGameModel>();

            _currentModel.BattalionTypes = new Dictionary<BattalionTypeId, BattalionType>();

@@ -234,9 +255,9 @@ namespace eagle {

            if (battleView == null) {
                // Battle was removed (e.g., it ended) before we could create the model.
-                // This can happen due to race conditions between Eagle and Shardok updates.
-                Debug.LogWarning(
-                        $"Cannot create ShardokGameModel for {shardokGameId}: battle not found in ShardokBattles (likely already ended)");
+                // 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;
            }

@@ -284,8 +305,18 @@ namespace eagle {

            switch (updateItem.GameUpdateDetailsCase) {
                case GameUpdate.GameUpdateDetailsOneofCase.ActionResultResponse:
-                    _lastUnfilteredResultCount =
-                            updateItem.ActionResultResponse.UnfilteredResultCountAfter;
+                    // 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;
+                    }
+
+                    // Note: _lastUnfilteredResultCount is updated on the gRPC thread in
+                    // UpdateResultCounts() before enqueueing. We don't update it here to avoid
+                    // race conditions where a backlogged MainQueue update overwrites a newer count.
+
                    if (updateItem.ActionResultResponse.ActionResultViews.Any() ||
                        updateItem.ActionResultResponse.AvailableCommands == null ||
                        updateItem.ActionResultResponse.AvailableCommands.Token !=
@@ -311,7 +342,10 @@ namespace eagle {
                            // 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);
+                                _currentModel.ShardokGameModels.TryRemove(
+                                        oneResponse.ShardokGameId,
+                                        out _);
+                                _shardokResultCounts.TryRemove(oneResponse.ShardokGameId, out _);
                                continue;
                            }
                        }
@@ -339,7 +373,10 @@ namespace eagle {
                                    shardokGameModel;
                        } else {
                            // Game ended - remove from active models so UI knows battle is over
-                            _currentModel.ShardokGameModels.Remove(oneResponse.ShardokGameId);
+                            _currentModel.ShardokGameModels.TryRemove(
+                                    oneResponse.ShardokGameId,
+                                    out _);
+                            _shardokResultCounts.TryRemove(oneResponse.ShardokGameId, out _);
                        }
                    }
                    if (UpdateAction != null) UpdateAction.Invoke(_currentModel);
@@ -360,6 +397,29 @@ namespace eagle {
            }
        }

+        /// <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>
@@ -405,6 +465,7 @@ namespace eagle {
                _currentModel.AvailableCommandsByProvince.Clear();
                _currentModel.CommandToken = null;
                _currentModel.LastPostedToken = token;
+                _commandSubmittedTime = DateTime.UtcNow;
                return PersistentConnection.PostEagleCommand(
                        gameId: GameId,
                        token: token,
@@ -424,6 +485,31 @@ namespace eagle {
            _currentModel.BattalionTypes =
                    startingState.BattalionTypes.ToDictionary(bt => bt.TypeId, bt => bt);
            _currentModel.ChronicleEntries = startingState.ChronicleEntries.ToList();
+
+            // For any outstanding battles not in ShardokGameModels, create models and mark for
+            // resync. This ensures fresh clients get Shardok state for ongoing battles.
+            bool needsResubscribe = false;
+            foreach (var battle in _currentModel.ShardokBattles) {
+                if (!_currentModel.ShardokGameModels.ContainsKey(battle.ShardokGameId)) {
+                    var model = MakeGameModel(battle.ShardokGameId);
+                    if (model != null) {
+                        _currentModel.ShardokGameModels[battle.ShardokGameId] = model;
+                        MarkShardokForResync(battle.ShardokGameId);
+                        _connectionLogger.LogLine(
+                                $"[STATE_RESYNC] Created ShardokGameModel for outstanding battle {battle.ShardokGameId}");
+                        needsResubscribe = true;
+                    }
+                }
+            }
+
+            // If we created new ShardokGameModels, re-subscribe to request their full state.
+            // The original subscribe didn't include these battles since we didn't know about them
+            // yet.
+            if (needsResubscribe) {
+                _connectionLogger.LogLine(
+                        "[STATE_RESYNC] Re-subscribing to request full Shardok state for new battles");
+                _ = StartListeningForUpdates();
+            }
        }

        private void HandleUpdates(List<ActionResultView> results) {
@@ -721,6 +807,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.TryRemove(rb, out _);
+                }
+                _shardokResultCounts.TryRemove(rb, out _);
+
                for (int i = 0; i < _currentModel.ShardokBattles.Count; i++) {
                    if (_currentModel.ShardokBattles[i].ShardokGameId == rb) {
                        _currentModel.ShardokBattles.RemoveAt(i);
@@ -766,5 +861,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
    }
 }
@@ -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) {
@@ -11,6 +11,13 @@ 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;
@@ -132,7 +132,10 @@ namespace eagle {

        public void ProvinceHovered(ProvinceId? pid) {
            // Highlight moving armies table
+            // Check row count to avoid index out of range if data changed after table was built
+            var rowCount = movingArmiesTable.RowCount;
            MovingArmies.Each((army, i) => {
+                if (i >= rowCount) return;
                var row = movingArmiesTable.ComponentAt<MovingArmyTableRow>(i);
                if (army.DestinationProvinceId == pid || army.OriginProvinceId == pid) {
                    row.ShadeOn();
@@ -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,
@@ -54,7 +58,13 @@ namespace eagle {
                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 &&
                             HeroListsMatch(n.DisplayedHeroes, displayedHeroes));
@@ -79,6 +89,8 @@ namespace eagle {
        }

        public void DismissAllClicked() {
+            // Increment generation immediately so pending AddNote calls will skip
+            _dismissGeneration++;
            _notes.Clear();
            SetPopupInfos();
        }
@@ -1,30 +1,106 @@
+using System;
 using System.Collections.Generic;
 using Net.Eagle0.Eagle.Common;
 using Net.Eagle0.Eagle.Views;

 namespace eagle.Notifications.ARNNotifications {
+    using ProvinceId = Int32;
+    using HeroId = Int32;
+
    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 Random Random = new();

-        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 readonly Dictionary<Profession, string> ProfessionNames = new() {
+            { Profession.Mage, "Mage" },
+            { Profession.Necromancer, "Necromancer" },
+            { Profession.Engineer, "Engineer" },
+            { Profession.Paladin, "Paladin" },
+            { Profession.Ranger, "Ranger" },
+            { Profession.Champion, "Champion" }
+        };
+
+        private static readonly Dictionary<Profession, List<string>> ProfessionTitles = new() {
+            { Profession.Mage,
+              new List<string> {
+                  "Arcane Awakening",
+                  "The Gift Revealed",
+                  "Touched by Magic",
+                  "Mystical Ascension",
+                  "Power Unbound",
+                  "The Arcane Path",
+                  "Secrets of the Weave",
+                  "Spellborn",
+                  "Wielder of the Unseen",
+                  "Flames of Knowledge"
+              } },
+            { Profession.Necromancer,
+              new List<string> {
+                  "Dark Pact Sealed",
+                  "Beyond the Veil",
+                  "Death's Apprentice",
+                  "Whispers from Beyond",
+                  "The Forbidden Art",
+                  "Shadow Covenant",
+                  "Secrets of the Grave",
+                  "Communion with Darkness",
+                  "The Deathless Path",
+                  "Embrace of Shadow"
+              } },
+            { Profession.Engineer,
+              new List<string> {
+                  "Genius Unleashed",
+                  "Master of Mechanisms",
+                  "The Inventor's Spark",
+                  "Gears of Progress",
+                  "Mind of Innovation",
+                  "Builder of Wonders",
+                  "The Tinkerer's Art",
+                  "Siege Mastery",
+                  "Architect of War",
+                  "Mechanical Brilliance"
+              } },
+            { Profession.Paladin,
+              new List<string> {
+                  "Divine Calling",
+                  "Holy Vows Taken",
+                  "Blessed Champion",
+                  "The Righteous Path",
+                  "Shield of the Faith",
+                  "Anointed Warrior",
+                  "Oath of Light",
+                  "Heaven's Chosen",
+                  "Sacred Duty",
+                  "Defender of the Realm"
+              } },
+            { Profession.Ranger,
+              new List<string> {
+                  "One with the Wild",
+                  "Voice of the Forest",
+                  "The Untamed Path",
+                  "Nature's Guardian",
+                  "Shadow of the Woods",
+                  "Hunter's Instinct",
+                  "Wild Heart",
+                  "The Wanderer's Way",
+                  "Beast Companion",
+                  "Eyes of the Hawk"
+              } },
+            { Profession.Champion,
+              new List<string> {
+                  "Born for Battle",
+                  "Blade Mastery",
+                  "The Warrior's Edge",
+                  "Forged in Combat",
+                  "Unmatched Prowess",
+                  "Heart of Steel",
+                  "The Victor's Path",
+                  "Legend in the Making",
+                  "Master of Arms",
+                  "Glory Awaits"
+              } }
+        };

        private static string GetProfessionName(Profession profession) {
            return ProfessionNames.TryGetValue(profession, out var name) ? name : "Unknown";
@@ -40,8 +116,19 @@ namespace eagle.Notifications.ARNNotifications {
        }

        private static string GetProfessionTitle(Profession profession) {
-            return ProfessionTitles.TryGetValue(profession, out var title) ? title
-                                                                           : "Profession Gained";
+            if (ProfessionTitles.TryGetValue(profession, out var titles) && titles.Count > 0) {
+                return titles[Random.Next(titles.Count)];
+            }
+            return "Profession Gained";
+        }
+
+        private static ProvinceId? FindProvinceForHero(HeroId heroId, IGameModel model) {
+            foreach (var province in model.Provinces.Values) {
+                if (province.FullInfo?.RulingFactionHeroIds.Contains(heroId) == true) {
+                    return province.Id;
+                }
+            }
+            return null;
        }

        private static IEnumerable<Notification> GenerateNotifications(
@@ -49,14 +136,38 @@ namespace eagle.Notifications.ARNNotifications {
                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;
+            List<ProvinceId> affectedProvinces;

-            string textTemplate =
-                    $"{{Hero}} of {factionName} became {article} {professionName}.\n\n";
+            if (details.FactionId == currentModel.PlayerId) {
+                // Player's own hero - vary text based on faction leader status
+                string heroDescription;
+                if (hero.IsFactionLeader) {
+                    heroDescription =
+                            $"Your sworn {DisplayNames.SiblingDescription(hero.PronounGender)}";
+                } else {
+                    heroDescription = "Your vassal";
+                }
+                var heroProvinceId = FindProvinceForHero(details.HeroId, currentModel);
+                if (heroProvinceId.HasValue) {
+                    var provinceName = currentModel.Provinces[heroProvinceId.Value].Name;
+                    textTemplate =
+                            $"{heroDescription} {{Hero}} in {provinceName} became {article} {professionName}.\n\n";
+                    affectedProvinces = new List<ProvinceId> { heroProvinceId.Value };
+                } else {
+                    textTemplate =
+                            $"{heroDescription} {{Hero}} became {article} {professionName}.\n\n";
+                    affectedProvinces = currentModel.ProvincesForFaction(details.FactionId);
+                }
+            } else {
+                // Another faction's hero
+                var factionName = currentModel.FactionName(details.FactionId);
+                textTemplate = $"{{Hero}} of {factionName} became {article} {professionName}.\n\n";
+                affectedProvinces = currentModel.ProvincesForFaction(details.FactionId);
+            }

            var heroPlaceholders = new Dictionary<string, (string nameTextId, string fallback)> {
                { "Hero", (hero.NameTextId, "A hero") }
@@ -31,7 +31,13 @@ namespace eagle.Notifications.ARNNotifications {
            };

            if (playerId.HasValue && playerId.Value == paidToFactionId) {
-                // no notification
+                yield return DynamicTextNotification.StreamingDynamicNotification(
+                        title: "Ransom Accepted",
+                        textTemplate: $"We have accepted the ransom from {currentModel.FactionName(paidByFactionId)} for {{RansomedHero}}.\n\n",
+                        heroPlaceholders: heroPlaceholders,
+                        llmId: notification.LlmId,
+                        provinceIds: new List<ProvinceId>(),
+                        displayedHeroes: new List<HeroView> { ransomedHero, offeringFactionHead });
            } else if (playerId.HasValue && playerId.Value == paidByFactionId) {
                yield return DynamicTextNotification.StreamingDynamicNotification(
                        title: "Ransom Accepted",
@@ -9,6 +9,7 @@ namespace eagle.Notifications {
        private List<GeneratedTextListener> textListeners = new();
        private string textTemplate;
        private Dictionary<string, string> placeholderValues = new();
+        private Dictionary<string, string> fallbackValues = new();

        public DynamicTextNotification(
                string title,
@@ -72,6 +73,9 @@ namespace eagle.Notifications {
                string nameTextId = kvp.Value.nameTextId;
                string fallback = kvp.Value.fallback;

+                // Store fallback so UpdateText can use it for missing placeholders
+                fallbackValues[placeholder] = fallback;
+
                if (!string.IsNullOrEmpty(nameTextId)) {
                    var listener = new GeneratedTextListener(
                            nameTextId,
@@ -95,6 +99,15 @@ namespace eagle.Notifications {

        private void UpdateText() {
            string result = textTemplate;
+
+            // First apply fallbacks for any placeholder without a loaded value
+            foreach (var kvp in fallbackValues) {
+                if (!placeholderValues.ContainsKey(kvp.Key)) {
+                    result = result.Replace($"{{{kvp.Key}}}", kvp.Value);
+                }
+            }
+
+            // Then apply actual loaded values
            foreach (var kvp in placeholderValues) {
                result = result.Replace($"{{{kvp.Key}}}", kvp.Value);
            }
@@ -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);
@@ -46,6 +46,8 @@ namespace eagle {
        private readonly Logger _timingsLogger = Logger.GetLogger("ConnectionLogger");
        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;
@@ -67,6 +69,17 @@ namespace eagle {
        private ConnectionCircuitBreaker _circuitBreaker = new ConnectionCircuitBreaker();
        public ConnectionCircuitBreaker CircuitBreaker => _circuitBreaker;

+        /// <summary>
+        /// Force an immediate reconnection attempt, bypassing the circuit breaker timeout.
+        /// </summary>
+        public void ForceReconnect() {
+            _circuitBreaker.ForceReconnect();
+            _retryTimer?.Dispose();
+            NextReconnectAttempt = null;
+            LogConnectionEvent("force_reconnect", "User requested immediate reconnect");
+            Task.Run(() => Connect());
+        }
+
        private DateTime? GetDeadlineFromNow() {
            return DateTime.UtcNow.AddSeconds(TimeoutSeconds);
        }
@@ -224,12 +237,10 @@ namespace eagle {
                            $"[SUBSCRIBE] Subscription confirmed for game {gameId}, " +
                            $"confirmedResultCount={ack.ConfirmedResultCount}");

-                    // Clear resync flags ONLY after successful acknowledgment
-                    if (subscriber is GameModelUpdater updater) {
-                        foreach (var status in shardokStatuses.Where(s => s.requestFullResync)) {
-                            updater.ClearShardokResyncFlag(status.shardokGameId);
-                        }
-                    }
+                    // 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 {
@@ -363,6 +374,9 @@ namespace eagle {
                    // 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();
@@ -482,6 +496,7 @@ namespace eagle {
                _lastDisconnect = DateTime.UtcNow;
                LogConnectionEvent("disconnect_explicit");
                StopIdleCheckTimer();
+                StopHeartbeatTimer();
                _streamingCall?.Dispose();
                _streamingCall = null;
            }
@@ -491,6 +506,7 @@ namespace eagle {
            lock (this) {
                // Dispose timers first to stop any pending callbacks
                StopIdleCheckTimer();
+                StopHeartbeatTimer();

                if (_retryTimer != null) {
                    _retryTimer.Enabled = false;
@@ -696,9 +712,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) {
@@ -743,7 +782,7 @@ namespace eagle {

                        switch (current.ResponseDetailsCase) {
                            case UpdateStreamResponse.ResponseDetailsOneofCase.HeartbeatResponse:
-                                _remoteEagleClientLogger.LogLine("Got a heartbeat response!");
+                                HandleHeartbeatResponse(current.HeartbeatResponse);
                                break;

                            case UpdateStreamResponse.ResponseDetailsOneofCase.GameUpdate:
@@ -978,5 +1017,123 @@ namespace eagle {
                }
            }
        }
+
+        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");
+            }
+        }
+
+        // Grace period after connect before sync mismatch triggers reconnect.
+        // Allows time to receive and process historical results after fresh subscribe.
+        private const double SyncMismatchGracePeriodSeconds = 60.0;
+
+        private void HandleHeartbeatResponse(HeartbeatResponse response) {
+            _remoteEagleClientLogger.LogLine(
+                    $"[HEARTBEAT] Got response, server_timestamp={response.ServerTimestamp}");
+
+            // Check for sync mismatches reported by server
+            bool hasMismatch = false;
+            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}");
+                    hasMismatch = true;
+                }
+
+                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}");
+                        hasMismatch = true;
+                    }
+                }
+            }
+
+            if (!hasMismatch) return;
+
+            // Grace period after connect - allow time to receive historical results
+            if (_lastSuccessfulConnect.HasValue) {
+                var timeSinceConnect =
+                        (DateTime.UtcNow - _lastSuccessfulConnect.Value).TotalSeconds;
+                if (timeSinceConnect < SyncMismatchGracePeriodSeconds) {
+                    _remoteEagleClientLogger.LogLine(
+                            $"[SYNC_MISMATCH] Ignoring mismatch during grace period ({timeSinceConnect:F1}s < {SyncMismatchGracePeriodSeconds}s)");
+                    return;
+                }
+            }
+
+            // 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");
+        }
    }
 }
@@ -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); }
@@ -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"));
    }
@@ -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();
@@ -385,98 +385,99 @@ namespace Shardok {
                    Model.MyUncommittedUnits.Where(uv => uv.Location.Row == -1).ToList();
        }

+        /// <summary>
+        /// Called when the ShardokGameModel is updated. This is invoked from UpdateAction,
+        /// which is called from ShardokGameModel.HandleUpdates, which runs on MainQueue.
+        /// No need to re-enqueue - we're already on the main thread.
+        /// </summary>
        void ModelUpdated() {
-            MainQueue.Q.Enqueue(() => {
-                if (Model == null) { return; }
-                SetHeroLabels();
-                SetModifiers();
-                UpdateReserves();
+            if (Model == null) { return; }
+            SetHeroLabels();
+            SetModifiers();
+            UpdateReserves();

-                HandleEnemyStartingPositionOverlays();
+            HandleEnemyStartingPositionOverlays();

-                endTurnButton.interactable = false;
+            endTurnButton.interactable = false;

-                if (Model.GameStatus != null &&
-                    (Model.GameStatus.State == GameStatus.Types.State.Victory)) {
-                    turnStatusLabel.text = "Game Over!";
+            if (Model.GameStatus != null &&
+                (Model.GameStatus.State == GameStatus.Types.State.Victory)) {
+                turnStatusLabel.text = "Game Over!";

-                    gameOverText.text = Model.GameStatus.Description;
-                    gameOverCanvas.gameObject.SetActive(true);
+                gameOverText.text = Model.GameStatus.Description;
+                gameOverCanvas.gameObject.SetActive(true);

-                    endTurnButton.GetComponentInChildren<TMP_Text>().text = "Back to Eagle";
-                    endTurnButton.interactable = true;
-                } else if (Model.GameStatus != null && Model.MyTurn) {
-                    gameOverCanvas.gameObject.SetActive(false);
-                    turnStatusLabel.text = "Your Turn";
+                endTurnButton.GetComponentInChildren<TMP_Text>().text = "Back to Eagle";
+                endTurnButton.interactable = true;
+            } else if (Model.GameStatus != null && Model.MyTurn) {
+                gameOverCanvas.gameObject.SetActive(false);
+                turnStatusLabel.text = "Your Turn";

-                    if (Model.InSetUp) {
-                        endTurnButton.GetComponentInChildren<TMP_Text>().text = "Commit";
+                if (Model.InSetUp) {
+                    endTurnButton.GetComponentInChildren<TMP_Text>().text = "Commit";

-                        var unplacedUnitsWithLocations =
-                                Model.MyUncommittedUnits
-                                        .Where(u => u.Location.Row >= 0 && u.Location.Column >= 0)
-                                        .ToList();
+                    var unplacedUnitsWithLocations =
+                            Model.MyUncommittedUnits
+                                    .Where(u => u.Location.Row >= 0 && u.Location.Column >= 0)
+                                    .ToList();

-                        if (!Model.MyTurn) {
-                            endTurnButton.interactable = false;
-                        } else if (unplacedUnitsWithLocations.Count() < 1) {
-                            endTurnButton.GetComponentInChildren<TMP_Text>().text =
-                                    "No units placed";
-                            endTurnButton.interactable = false;
-                        } else if (unplacedUnitsWithLocations.Count() > 10) {
-                            endTurnButton.GetComponentInChildren<TMP_Text>().text =
-                                    "Too many units";
-                            endTurnButton.interactable = false;
-                        } else {
-                            endTurnButton.interactable = true;
-                        }
-
-                        SetDisplayedCommandGroup(0);
+                    if (!Model.MyTurn) {
+                        endTurnButton.interactable = false;
+                    } else if (unplacedUnitsWithLocations.Count() < 1) {
+                        endTurnButton.GetComponentInChildren<TMP_Text>().text = "No units placed";
+                        endTurnButton.interactable = false;
+                    } else if (unplacedUnitsWithLocations.Count() > 10) {
+                        endTurnButton.GetComponentInChildren<TMP_Text>().text = "Too many units";
+                        endTurnButton.interactable = false;
                    } else {
-                        endTurnButton.GetComponentInChildren<TMP_Text>().text = "End Turn";
-                    }
-
-                    if (Model.HasAvailableCommandWhere(
-                                command => commandTypeUIManager.CommandGroupForType(command.Type) ==
-                                           CommandTypeUIManager.EndTurnCommandGroup)) {
                        endTurnButton.interactable = true;
                    }

-                    SelectAppropriateDefaultCommand();
+                    SetDisplayedCommandGroup(0);
                } else {
-                    turnStatusLabel.text = $"{Model.CurrentPlayerName}'s Turn";
+                    endTurnButton.GetComponentInChildren<TMP_Text>().text = "End Turn";
                }

-                locationNameText.text = Model.LocationName;
-
-                if (Model.History.Count > 0) {
-                    string monthString = new DateTime(777, Model.Month, 1)
-                                                 .ToString("MMMM", CultureInfo.InvariantCulture);
-                    roundInfoText.text = $"{monthString} {Model.CurrentRound}";
-                    Weather weather = Model.Weather;
-                    if (weather != null) {
-                        roundInfoText.text += ", " + ProtoExtensions.WeatherToString(weather);
-                    }
+                if (Model.HasAvailableCommandWhere(
+                            command => commandTypeUIManager.CommandGroupForType(command.Type) ==
+                                       CommandTypeUIManager.EndTurnCommandGroup)) {
+                    endTurnButton.interactable = true;
                }

-                if (Model.History.Count == 0) {
-                    turnHistoryButtonText.text = NoHistoryText;
-                } else if (Model.History.Count > _lastRetrievedHistoryCount) {
-                    for (int i = _lastRetrievedHistoryCount; i < Model.History.Count; i++) {
-                        var historyEntry = Model.History[i];
-                        turnHistoryPanel.AddLine(GetActionResultDescription(historyEntry));
+                SelectAppropriateDefaultCommand();
+            } else {
+                turnStatusLabel.text = $"{Model.CurrentPlayerName}'s Turn";
+            }

-                        ActionType type = historyEntry.Type;
-                        var thisSound = soundManager.SoundForType(type);
-                        if (thisSound != null) { audioClipSource.PlayOneShot(thisSound, 1.0f); }
-                    }
-                    _lastRetrievedHistoryCount = Model.History.Count;
-                    turnHistoryButtonText.text = GetActionResultDescription(Model.History.Last());
-                    SetModifiers();
+            locationNameText.text = Model.LocationName;
+
+            if (Model.History.Count > 0) {
+                string monthString = new DateTime(777, Model.Month, 1)
+                                             .ToString("MMMM", CultureInfo.InvariantCulture);
+                roundInfoText.text = $"{monthString} {Model.CurrentRound}";
+                Weather weather = Model.Weather;
+                if (weather != null) {
+                    roundInfoText.text += ", " + ProtoExtensions.WeatherToString(weather);
                }
+            }

-                SetupArmiesTable();
-            });
+            if (Model.History.Count == 0) {
+                turnHistoryButtonText.text = NoHistoryText;
+            } else if (Model.History.Count > _lastRetrievedHistoryCount) {
+                for (int i = _lastRetrievedHistoryCount; i < Model.History.Count; i++) {
+                    var historyEntry = Model.History[i];
+                    turnHistoryPanel.AddLine(GetActionResultDescription(historyEntry));
+
+                    ActionType type = historyEntry.Type;
+                    var thisSound = soundManager.SoundForType(type);
+                    if (thisSound != null) { audioClipSource.PlayOneShot(thisSound, 1.0f); }
+                }
+                _lastRetrievedHistoryCount = Model.History.Count;
+                turnHistoryButtonText.text = GetActionResultDescription(Model.History.Last());
+                SetModifiers();
+            }
+
+            SetupArmiesTable();
        }

        private void SetupArmiesTable() {
@@ -707,34 +708,33 @@ namespace Shardok {
        }

        void SetModifiers() {
-            MainQueue.Q.Enqueue(() => {
-                hexGrid.ClearCellModifierImages();
+            // Called from ModelUpdated which runs on MainQueue - no need to re-enqueue
+            hexGrid.ClearCellModifierImages();

-                for (byte row = 0; row < Model.Map.RowCount; row++) {
-                    for (byte column = 0; column < Model.Map.ColumnCount; column++) {
-                        Coords coords = new Coords();
-                        coords.Row = row;
-                        coords.Column = column;
+            for (byte row = 0; row < Model.Map.RowCount; row++) {
+                for (byte column = 0; column < Model.Map.ColumnCount; column++) {
+                    Coords coords = new Coords();
+                    coords.Row = row;
+                    coords.Column = column;

-                        var terrain = Model.Map.TerrainAt(coords);
-                        int cellIndex = MapCoordsToGridIndex(coords);
-                        int numberForCell = _randomNumberForCellIndex[cellIndex];
-                        hexGrid.SetCellTerrainImage(
-                                cellIndex,
-                                _imageForTerrainTracker
-                                        .GetImageForTerrain(terrain, numberForCell, Model.Month));
-                        if (terrain.Modifier?.Fire != null) {
-                            hexGrid.SetCellModifierEffect(cellIndex, fireEffectPrefab);
-                        } else {
-                            hexGrid.SetCellModifierEffect(cellIndex, null);
-                        }
+                    var terrain = Model.Map.TerrainAt(coords);
+                    int cellIndex = MapCoordsToGridIndex(coords);
+                    int numberForCell = _randomNumberForCellIndex[cellIndex];
+                    hexGrid.SetCellTerrainImage(
+                            cellIndex,
+                            _imageForTerrainTracker
+                                    .GetImageForTerrain(terrain, numberForCell, Model.Month));
+                    if (terrain.Modifier?.Fire != null) {
+                        hexGrid.SetCellModifierEffect(cellIndex, fireEffectPrefab);
+                    } else {
+                        hexGrid.SetCellModifierEffect(cellIndex, null);
+                    }

-                        if (terrain.Modifier?.Bridge != null) {
-                            hexGrid.SetCellModifierImage(cellIndex, bridgeImage);
-                        }
+                    if (terrain.Modifier?.Bridge != null) {
+                        hexGrid.SetCellModifierImage(cellIndex, bridgeImage);
                    }
                }
-            });
+            }
        }

        void HandleButton() {
@@ -961,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));
@@ -82,7 +82,7 @@ public class ShardokGameModel {
    public int Month { get; private set; }
    private List<PlayerTotals> PlayerTotals { get; set; }

-    public List<CommandDescriptor> AvailableCommands { get; private set; }
+    public List<CommandDescriptor> AvailableCommands { get; private set; } = new();
    public Action UpdateAction { get; set; }
    public List<PlayerWithHostility> players;
    public String GetPlayerName(PlayerId playerId) {
@@ -111,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;
@@ -206,6 +217,8 @@ public class ShardokGameModel {
                                        ? newCommands.CurrentCommand.ToList()
                                        : newCommands.PreviewCommand.ToList();
        }
+        // Trigger UI refresh after commands are updated so unit action indicators reflect new state
+        UpdateAction?.Invoke();
    }

    public bool HasTargetedCommand(Coords start, Coords target, List<CommandType> possibleTypes) {
@@ -0,0 +1,278 @@
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace common {
+    /// <summary>
+    /// Automatically scrolls text content that overflows its container.
+    /// Shows a fade gradient at the bottom when content overflows, then begins
+    /// auto-scrolling after a delay. Useful for tooltips where the user can't
+    /// manually scroll.
+    ///
+    /// Also supports dynamic height sizing: the ScrollRect will grow to fit its
+    /// content up to available screen space, only enabling scrolling when needed.
+    /// </summary>
+    public class AutoScrollingText : MonoBehaviour {
+        /// <summary>
+        /// Global scroll speed multiplier controlled by Settings.
+        /// Default is 1.0 (use instance scrollSpeed as-is).
+        /// Range: 0.0 (paused) to 2.0 (double speed).
+        /// </summary>
+        public static float GlobalScrollSpeedMultiplier {
+            get => PlayerPrefs.GetFloat(ScrollSpeedKey, 1.0f);
+            set => PlayerPrefs.SetFloat(ScrollSpeedKey, Mathf.Clamp(value, 0f, 2f));
+        }
+
+        private const string ScrollSpeedKey = "autoScrollSpeedMultiplier";
+
+        [Header("Scroll Rect")]
+        [Tooltip("The ScrollRect containing the text content")]
+        public ScrollRect scrollRect;
+
+        [Tooltip("Optional gradient image to show when content overflows (fades at bottom)")]
+        public GameObject fadeGradient;
+
+        [Header("Auto-Scroll Timing")]
+        [Tooltip("Seconds to wait before starting to scroll")]
+        public float scrollDelaySeconds = 1.5f;
+
+        [Tooltip("Scroll speed in normalized units per second (0-1 range)")]
+        public float scrollSpeed = 0.15f;
+
+        [Tooltip("Seconds to pause at the bottom before resetting")]
+        public float pauseAtBottomSeconds = 1.0f;
+
+        [Header("Dynamic Sizing")]
+        [Tooltip("If true, resize the ScrollRect to fit content up to available space")]
+        public bool dynamicHeight = true;
+
+        [Tooltip("Margin from top of screen in pixels")]
+        public float topMargin = 20f;
+
+        [Tooltip("LayoutElement to adjust for dynamic height (usually on ScrollRect)")]
+        public LayoutElement layoutElement;
+
+        [Tooltip("Other content in the panel (e.g., hero details). Height will be preserved.")]
+        public RectTransform otherContent;
+
+        [Tooltip("Optional: Panel to hide until layout is complete (prevents jumpy resize)")]
+        public CanvasGroup panelCanvasGroup;
+
+        private float _visibleTime = 0f;
+        private bool _isScrolling = false;
+        private bool _isPausedAtBottom = false;
+        private float _pauseTimer = 0f;
+        private RectTransform _scrollRectTransform;
+        private Canvas _rootCanvas;
+
+        private void OnEnable() {
+            // Hide panel until layout is complete to prevent jumpy resize
+            if (panelCanvasGroup != null) { panelCanvasGroup.alpha = 0f; }
+
+            if (scrollRect != null) {
+                _scrollRectTransform = scrollRect.GetComponent<RectTransform>();
+                _rootCanvas = scrollRect.GetComponentInParent<Canvas>()?.rootCanvas;
+
+                // Immediately reset scroll position to prevent visual jump on first frame
+                // Use normalizedPosition to reset both horizontal and vertical
+                scrollRect.normalizedPosition = new Vector2(0f, 1f);
+
+                // Also reset the content's anchored position to prevent any offset
+                if (scrollRect.content != null) {
+                    var contentRect = scrollRect.content;
+                    contentRect.anchoredPosition = new Vector2(0f, contentRect.anchoredPosition.y);
+                }
+            }
+
+            // Delay layout update to next frame so content has time to rebuild
+            StartCoroutine(DelayedInitialize());
+        }
+
+        private System.Collections.IEnumerator DelayedInitialize() {
+            yield return null;  // Wait one frame for layout to rebuild
+            yield return null;  // Extra frame for ContentSizeFitter
+
+            UpdateDynamicHeight();
+            ResetScroll();
+
+            // Show panel now that layout is complete
+            if (panelCanvasGroup != null) { panelCanvasGroup.alpha = 1f; }
+        }
+
+        private void OnDisable() { ResetScroll(); }
+
+        /// <summary>
+        /// Resets scroll position to top and restarts the delay timer.
+        /// Call this when the text content changes.
+        /// </summary>
+        public void ResetScroll() {
+            _visibleTime = 0f;
+            _isScrolling = false;
+            _isPausedAtBottom = false;
+            _pauseTimer = 0f;
+
+            if (scrollRect != null) {
+                scrollRect.verticalNormalizedPosition = 1f;  // Top
+            }
+
+            UpdateFadeGradient();
+        }
+
+        [Header("Debug")]
+        [Tooltip("Enable debug logging to console")]
+        public bool debugLogging = false;
+
+        /// <summary>
+        /// Updates the ScrollRect height to fit content, up to available screen space.
+        /// </summary>
+        private void UpdateDynamicHeight() {
+            if (!dynamicHeight || layoutElement == null || scrollRect == null) return;
+            if (_scrollRectTransform == null || _rootCanvas == null) return;
+
+            // Get content height - prefer TMP_Text.preferredHeight over rect.height
+            // because rect.height may not reflect actual text size without ContentSizeFitter
+            float contentHeight = 0f;
+            float rectHeight = scrollRect.content != null ? scrollRect.content.rect.height : 0f;
+            var tmpText = scrollRect.content?.GetComponentInChildren<TMP_Text>();
+            if (tmpText != null) {
+                // Use TMP's calculated preferred height - this is the actual text size
+                contentHeight = tmpText.preferredHeight;
+
+                // Sync Content RectTransform height with actual text size.
+                // Must both grow AND shrink to prevent blank space when scrolling to bottom.
+                if (Mathf.Abs(scrollRect.content.rect.height - contentHeight) > 1f) {
+                    scrollRect.content.SetSizeWithCurrentAnchors(
+                            RectTransform.Axis.Vertical,
+                            contentHeight);
+                }
+            } else {
+                contentHeight = rectHeight;
+            }
+
+            // Get the bottom of the ScrollRect in screen space
+            Vector3[] corners = new Vector3[4];
+            _scrollRectTransform.GetWorldCorners(corners);
+
+            Camera cam = _rootCanvas.renderMode == RenderMode.ScreenSpaceOverlay
+                                 ? null
+                                 : _rootCanvas.worldCamera;
+            Vector2 scrollRectBottomScreen =
+                    RectTransformUtility.WorldToScreenPoint(cam, corners[0]);
+
+            // Calculate how much space we have from ScrollRect bottom to top of screen
+            float spaceToTop = Screen.height - scrollRectBottomScreen.y - topMargin;
+
+            // Account for canvas scaling
+            float scaleFactor = _rootCanvas.scaleFactor;
+            if (scaleFactor > 0) { spaceToTop /= scaleFactor; }
+
+            // Get height of other content (hero details) if specified
+            float otherContentHeight = 0f;
+            if (otherContent != null) { otherContentHeight = otherContent.rect.height; }
+
+            // Max height for ScrollRect = space to top minus other content
+            float maxScrollRectHeight = spaceToTop - otherContentHeight;
+
+            // Clamp to reasonable bounds
+            maxScrollRectHeight = Mathf.Max(maxScrollRectHeight, 50f);
+
+            // Set preferred height to content or max, whichever is smaller
+            float targetHeight = Mathf.Min(contentHeight, maxScrollRectHeight);
+            layoutElement.preferredHeight = targetHeight;
+
+            if (debugLogging) {
+                Debug.Log(
+                        $"[AutoScrollingText] contentHeight={contentHeight:F0} (rectHeight={rectHeight:F0}), " +
+                        $"spaceToTop={spaceToTop:F0}, otherContent={otherContentHeight:F0}, " +
+                        $"maxHeight={maxScrollRectHeight:F0}, targetHeight={targetHeight:F0}");
+            }
+
+            // Force layout rebuild
+            RectTransform parentRect = _scrollRectTransform.parent as RectTransform;
+            if (parentRect != null) { LayoutRebuilder.ForceRebuildLayoutImmediate(parentRect); }
+        }
+
+        private void Update() {
+            if (scrollRect == null) return;
+
+            bool hasOverflow = HasContentOverflow();
+            UpdateFadeGradient();
+
+            if (!hasOverflow) {
+                _isScrolling = false;
+                return;
+            }
+
+            // Hold Shift to pause scrolling (lets user read at their own pace)
+            bool isPausedByUser =
+                    Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
+            if (isPausedByUser) return;
+
+            // Handle pause at bottom
+            if (_isPausedAtBottom) {
+                _pauseTimer += Time.deltaTime;
+                if (_pauseTimer >= pauseAtBottomSeconds) {
+                    // Reset to top and start over
+                    scrollRect.verticalNormalizedPosition = 1f;
+                    _isPausedAtBottom = false;
+                    _pauseTimer = 0f;
+                    _visibleTime = 0f;
+                    _isScrolling = false;
+                }
+                return;
+            }
+
+            // Track time visible
+            _visibleTime += Time.deltaTime;
+
+            // Start scrolling after delay
+            if (!_isScrolling && _visibleTime >= scrollDelaySeconds) { _isScrolling = true; }
+
+            // Perform scrolling (apply global speed multiplier from settings)
+            if (_isScrolling) {
+                float effectiveSpeed = scrollSpeed * GlobalScrollSpeedMultiplier;
+                float newPosition =
+                        scrollRect.verticalNormalizedPosition - (effectiveSpeed * Time.deltaTime);
+
+                if (newPosition <= 0f) {
+                    // Reached bottom
+                    scrollRect.verticalNormalizedPosition = 0f;
+                    _isScrolling = false;
+                    _isPausedAtBottom = true;
+                    _pauseTimer = 0f;
+                } else {
+                    scrollRect.verticalNormalizedPosition = newPosition;
+                }
+            }
+        }
+
+        private bool HasContentOverflow() {
+            if (scrollRect == null || scrollRect.content == null) return false;
+
+            // Use TMP_Text.preferredHeight for accurate content measurement
+            float contentHeight;
+            var tmpText = scrollRect.content.GetComponentInChildren<TMP_Text>();
+            if (tmpText != null) {
+                contentHeight = tmpText.preferredHeight;
+            } else {
+                contentHeight = scrollRect.content.rect.height;
+            }
+
+            float viewportHeight = scrollRect.viewport != null
+                                           ? scrollRect.viewport.rect.height
+                                           : scrollRect.GetComponent<RectTransform>().rect.height;
+
+            return contentHeight > viewportHeight + 1f;  // Small buffer for floating point
+        }
+
+        private void UpdateFadeGradient() {
+            if (fadeGradient == null) return;
+
+            bool hasOverflow = HasContentOverflow();
+            bool notAtBottom = scrollRect != null && scrollRect.verticalNormalizedPosition > 0.01f;
+
+            // Show gradient when there's overflow and we're not at the bottom
+            fadeGradient.SetActive(hasOverflow && notAtBottom);
+        }
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ac5d868c54ceb4893b1c95894cd4ec6f
@@ -54,18 +54,43 @@ namespace common.GUIUtils {
                    Type = type,
                    Time = DateTime.UtcNow
                });
-                MainQueue.Q.Enqueue(() => {
-                    errorTextField.text = AllMessageText;
-                    panel.gameObject.SetActive(true);
-                });
+
+                // Try to display immediately if possible, otherwise queue for later
+                try {
+                    if (MainQueue.Q != null) {
+                        MainQueue.Q.Enqueue(ShowErrorPanel);
+                    } else {
+                        _pendingShow = true;
+                    }
+                } catch {
+                    // MainQueue not ready yet - will show in Update
+                    _pendingShow = true;
+                }
+            }
+        }
+
+        private bool _pendingShow = false;
+
+        private void ShowErrorPanel() {
+            if (errorTextField != null && panel != null) {
+                errorTextField.text = AllMessageText;
+                panel.gameObject.SetActive(true);
+            }
+        }
+
+        // Register for log messages as early as possible
+        void Awake() { Application.logMessageReceivedThreaded += HandleLog; }
+
+        void Update() {
+            // Handle errors that occurred before MainQueue was ready
+            if (_pendingShow) {
+                _pendingShow = false;
+                ShowErrorPanel();
            }
        }

        // Use this for initialization
-        void Start() {
-            panel.gameObject.SetActive(false);
-            Application.logMessageReceivedThreaded += HandleLog;
-        }
+        void Start() { panel.gameObject.SetActive(false); }

        public void DismissClicked() {
            lock (_messages) {
@@ -21,14 +21,24 @@ option java_outer_classname = "EagleInterface";
 option objc_class_prefix = "E0G";

 service ShardokInternalInterface {
+    // Server-side streaming for game updates - replaces polling via GetGameStatus
+    rpc SubscribeToGame(GameSubscriptionRequest) returns (stream GameStatusResponse) {}
+
    rpc PostCommand(PostCommandRequest) returns (GameStatusResponse) {}
    rpc PostPlacementCommands(PlacementCommandsRequest) returns (GameStatusResponse) {}
+
+    // Deprecated: Use SubscribeToGame for streaming updates instead
    rpc GetGameStatus(GameStatusRequest) returns (GameStatusResponse) {}

    rpc GetHexMap(HexMapRequest) returns (HexMapResponse) {}
    rpc GetHexMapNames(HexMapNamesRequest) returns (HexMapNamesResponse) {}
 }

+message GameSubscriptionRequest {
+    string game_id = 1;
+    GameSetupInfo game_setup_info = 2;
+}
+
 message PostCommandRequest {
    string game_id = 1;
    int32 player_id = 2;
@@ -171,10 +171,43 @@ message GameUpdate {

 message HeartbeatRequest {
    int64 client_timestamp = 1;
+    // Sync verification: client reports its known action counts per game
+    repeated GameSyncStatus game_sync_statuses = 2;
+}
+
+// Client's known sync state for a single game
+message GameSyncStatus {
+    int64 game_id = 1;
+    // Eagle action count (matches ActionResultResponse.unfiltered_result_count_after)
+    int32 unfiltered_result_count = 2;
+    // Shardok action counts per tactical battle
+    repeated ShardokSyncStatus shardok_sync_statuses = 3;
+}
+
+message ShardokSyncStatus {
+    string shardok_game_id = 1;
+    // Matches ShardokActionResultResponse.filtered_result_count_after
+    int32 filtered_result_count = 2;
 }

 message HeartbeatResponse {
    int64 server_timestamp = 1;
+    // Sync verification results - only included if there are mismatches
+    repeated GameSyncResult game_sync_results = 2;
+}
+
+// Server's sync verification result for a single game
+message GameSyncResult {
+    int64 game_id = 1;
+    bool eagle_in_sync = 2;
+    int32 server_unfiltered_result_count = 3;  // Server's count for comparison
+    repeated ShardokSyncResult shardok_sync_results = 4;
+}
+
+message ShardokSyncResult {
+    string shardok_game_id = 1;
+    bool in_sync = 2;
+    int32 server_filtered_result_count = 3;  // Server's count for comparison
 }

 message NewGameOptions {
@@ -256,6 +289,25 @@ message ActionResultResponse {
    int32 unfiltered_result_count_after = 1;
    repeated .net.eagle0.eagle.views.ActionResultView action_result_views = 2;
    AvailableCommands available_commands = 3;
+    // Server-reported game status for connection status UI
+    ServerGameStatus server_game_status = 4;
+}
+
+// Server-reported game status for the connection status indicator.
+// Tells the client what the server is doing/waiting for.
+message ServerGameStatus {
+    enum Status {
+        UNKNOWN = 0;
+        YOUR_TURN = 1;              // Player has commands available
+        WAITING_FOR_PLAYERS = 2;    // Waiting for other player(s) to act
+        GENERATING_TEXT = 3;        // LLM text generation in progress
+        PROCESSING_ACTION = 4;      // Server is processing an action
+    }
+    Status status = 1;
+    // For WAITING_FOR_PLAYERS: which faction(s) we're waiting for
+    repeated int32 waiting_for_faction_ids = 2;
+    // For GENERATING_TEXT: which LLM stream is being generated
+    string generating_llm_id = 3;
 }

 message ShardokActionResultResponse {
@@ -23,6 +23,7 @@ message IncompleteText {
    string partial_text = 2;
    .net.eagle0.eagle.internal.GeneratedTextRequest llm_request = 3;
    int32 requested_after_history_count = 4;
+    int64 requested_at_millis = 5;
 }

 message UnrequestedText {
@@ -58,4 +58,8 @@ message Hero {
    repeated EventForHeroBackstory new_backstory_events = 29;

    .net.eagle0.eagle.common.Gender pronoun_gender = 27;
+
+    // The name of the faction this hero would lead, if they led one.
+    // Populated for "great person" heroes from the heroes TSV; empty for others.
+    string led_faction_name = 30;
 }
@@ -4,6 +4,7 @@ filegroup(
    name = "settings",
    srcs = ["settings.tsv"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/scala/net/eagle0/eagle:__pkg__",
        "//src/main/scala/net/eagle0/eagle/service:__pkg__",
    ],
@@ -13,6 +14,7 @@ filegroup(
    name = "game_parameters",
    srcs = ["game_parameters.json"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/scala/net/eagle0:__subpackages__",
        "//src/test:__subpackages__",
    ],
@@ -22,6 +24,7 @@ filegroup(
    name = "beasts",
    srcs = ["beasts.tsv"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/scala/net/eagle0/eagle/library/util:__pkg__",
        "//src/main/scala/net/eagle0/util:__pkg__",
        "//src/test:__subpackages__",
@@ -32,6 +35,7 @@ filegroup(
    name = "headshots",
    srcs = ["headshots.tsv"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/scala/net/eagle0/eagle/library/util/hero_generator/image_paths:__pkg__",
        "//src/main/scala/net/eagle0/eagle/library/util/hero_generator/random_hero_generator:__pkg__",
        "//src/main/scala/net/eagle0/util:__pkg__",
@@ -46,6 +50,7 @@ filegroup(
        "heroes.tsv",
    ],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/scala/net/eagle0/eagle/service/new_game_creation:__pkg__",
        "//src/main/scala/net/eagle0/util:__pkg__",
        "//src/test:__subpackages__",
@@ -56,6 +61,7 @@ filegroup(
    name = "province_map",
    srcs = ["province_map.tsv"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/scala/net/eagle0:__subpackages__",
        "//src/test:__subpackages__",
    ],
@@ -5,6 +5,7 @@ filegroup(
    name = "settings",
    srcs = ["settings.tsv"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/cpp/net/eagle0/shardok:__subpackages__",
        "//src/test/cpp/net/eagle0/shardok:__subpackages__",
    ],
@@ -44,6 +45,7 @@ filegroup(
    name = "battalion_types",
    srcs = ["battalionTypes.tsv"],
    visibility = [
+        "//ci:__pkg__",
        "//src/main/cpp/net/eagle0/shardok:__subpackages__",
        "//src/main/scala/net/eagle0/eagle/service:__pkg__",
        "//src/main/scala/net/eagle0/util:__pkg__",
@@ -21,6 +21,7 @@ scala_binary(
        ":external_text_generation_caller",
        ":external_text_generation_service_impl",
        ":open_ai_chat_completions_service_impl",
+        ":open_ai_responses_service_impl",
        ":streaming_text_results",
    ],
 )
@@ -52,7 +53,10 @@ scala_library(
        ":external_text_generation_service_impl",
        ":rate_limits",
        ":streaming_text_results",
-        "//src/main/scala/net/eagle0/common/sse:sse_subscriber",
+        "//src/main/scala/net/eagle0/common/sse:okhttp_sse_listener",
+        "@maven//:com_squareup_okhttp3_okhttp",
+        "@maven//:com_squareup_okhttp3_okhttp_sse",
+        "@maven//:com_squareup_okio_okio_jvm",
    ],
 )

@@ -86,6 +90,24 @@ scala_library(
    ],
 )

+scala_library(
+    name = "open_ai_responses_service_impl",
+    srcs = ["OpenAIResponsesServiceImpl.scala"],
+    visibility = [
+        "//visibility:public",
+    ],
+    deps = [
+        ":api_keys",
+        ":external_text_generation_service_impl",
+        ":open_ai_duration_parser",
+        ":rate_limits",
+        ":streaming_text_results",
+        "@maven//:org_json4s_json4s_ast_3",
+        "@maven//:org_json4s_json4s_core_3",
+        "@maven//:org_json4s_json4s_native_3",
+    ],
+)
+
 scala_library(
    name = "open_ai_duration_parser",
    srcs = ["OpenAiDurationParser.scala"],
@@ -1,21 +1,23 @@
 package net.eagle0.common.llm_integration

-import java.net.http.{HttpClient, HttpRequest, HttpResponse, HttpTimeoutException}
-import java.net.http.HttpClient.{Redirect, Version}
-import java.net.http.HttpResponse.ResponseInfo
+import java.io.IOException
+import java.net.http.HttpRequest
 import java.net.HttpURLConnection
+import java.net.SocketTimeoutException
 import java.time.{Duration, ZonedDateTime}
 import java.time.temporal.ChronoUnit
 import java.util.{Timer, TimerTask}
-import java.util.concurrent.CompletionException
+import java.util.concurrent.TimeUnit
 import java.util.function.Consumer

 import scala.concurrent.{ExecutionContext, Future, Promise}
-import scala.jdk.CollectionConverters.{CollectionHasAsScala, MapHasAsScala}
+import scala.jdk.CollectionConverters.{CollectionHasAsScala, IterableHasAsScala}
 import scala.jdk.FutureConverters.CompletionStageOps
 import scala.util.{Failure, Success}

-import net.eagle0.common.sse.SseSubscriber
+import net.eagle0.common.sse.OkHttpSseListener
+import okhttp3.{MediaType, OkHttpClient, Request, RequestBody, Response}
+import okhttp3.sse.{EventSource, EventSources}

 enum ExternalTextGenerationError extends Error:
  case RateLimit(code: Int, msg: String)
@@ -35,10 +37,51 @@ object ExternalTextGenerationCaller {

  private def nextBackoff(backoffSeconds: Double): Double =
    Math.min(backoffSeconds * backoffMultiplier, maxBackoffSeconds)
+
+  /** Convert a Java HttpRequest to an OkHttp Request */
+  private def toOkHttpRequest(javaRequest: HttpRequest): Request = {
+    val builder = new Request.Builder()
+      .url(javaRequest.uri().toString)
+
+    // Copy headers
+    javaRequest.headers().map().forEach { (name, values) =>
+      values.forEach(value => builder.addHeader(name, value))
+    }
+
+    // Handle request body
+    javaRequest.method() match {
+      case "GET"  => builder.get()
+      case "POST" =>
+        val bodyPublisher = javaRequest.bodyPublisher().orElse(null)
+        if bodyPublisher != null then {
+          // Extract body content - for BodyPublishers.ofString, we can get the content
+          val bodyContent = new StringBuilder()
+          val subscriber  = new java.util.concurrent.Flow.Subscriber[java.nio.ByteBuffer] {
+            override def onSubscribe(subscription: java.util.concurrent.Flow.Subscription): Unit =
+              subscription.request(Long.MaxValue)
+            override def onNext(item: java.nio.ByteBuffer): Unit                                 =
+              bodyContent.append(java.nio.charset.StandardCharsets.UTF_8.decode(item).toString)
+            override def onError(throwable: Throwable): Unit                                     = ()
+            override def onComplete(): Unit                                                      = ()
+          }
+          bodyPublisher.subscribe(subscriber)
+          val contentType =
+            javaRequest.headers().firstValue("Content-Type").orElse("application/json")
+          val mediaType   = MediaType.parse(contentType)
+          builder.post(RequestBody.create(bodyContent.toString, mediaType))
+        } else {
+          builder.post(RequestBody.create("", null))
+        }
+      case other  => throw new UnsupportedOperationException(s"HTTP method $other not supported")
+    }
+
+    builder.build()
+  }
 }

 final class ExternalTextGenerationCaller(
    val timeoutSeconds: Int = 10,
+    val readTimeoutSeconds: Int = 60,
    serviceImpl: ExternalTextGenerationServiceImpl
 ) {
  private var inProgressCount = 0
@@ -57,13 +100,17 @@ final class ExternalTextGenerationCaller(

  implicit val ec: ExecutionContext = ExecutionContext.global

-  private val httpClient = HttpClient
-    .newBuilder()
-    .version(Version.HTTP_2)
-    .followRedirects(Redirect.NORMAL)
-    .connectTimeout(Duration.ofSeconds(timeoutSeconds))
+  // OkHttp client with read timeout - the key benefit over Java HttpClient
+  // If no data is received for readTimeoutSeconds, the connection will timeout
+  private val okHttpClient = new OkHttpClient.Builder()
+    .connectTimeout(timeoutSeconds.toLong, TimeUnit.SECONDS)
+    .readTimeout(readTimeoutSeconds.toLong, TimeUnit.SECONDS)
+    .writeTimeout(timeoutSeconds.toLong, TimeUnit.SECONDS)
+    .retryOnConnectionFailure(true)
    .build()

+  private val eventSourceFactory = EventSources.createFactory(okHttpClient)
+
  private var successDurations =
    new scala.collection.mutable.ArrayBuffer[Long]()

@@ -72,7 +119,7 @@ final class ExternalTextGenerationCaller(
      partialCompletion: Option[String],
      streamingConsumer: Consumer[StreamingTextResults],
      backoffSeconds: Double = ExternalTextGenerationCaller.initialBackoffSeconds
-  ): Future[HttpResponse[Unit]] =
+  ): Future[Unit] =
    streamCompletion(
      inputText = inputText,
      request = serviceImpl.makeRequest(
@@ -88,13 +135,13 @@ final class ExternalTextGenerationCaller(
      request: HttpRequest,
      backoffSeconds: Double,
      streamingConsumer: Consumer[StreamingTextResults]
-  ): Future[HttpResponse[Unit]] = {
+  ): Future[Unit] = {
    val startTime = System.currentTimeMillis()

-    def tryAgain: () => Future[HttpResponse[Unit]] = () => {
+    def tryAgain: () => Future[Unit] = () => {
      println(s"Trying again after $backoffSeconds seconds...")

-      val promise = Promise[HttpResponse[Unit]]()
+      val promise = Promise[Unit]()
      val t       = new Timer()
      t.schedule(
        new TimerTask {
@@ -113,104 +160,63 @@ final class ExternalTextGenerationCaller(
      promise.future
    }

+    val okHttpRequest = ExternalTextGenerationCaller.toOkHttpRequest(request)
+    val sseListener   = new OkHttpSseListener(serviceImpl.stringConsumer(streamingConsumer))
+
    inProgressCount += 1
-    httpClient
-      .sendAsync(
-        request,
-        (respInfo: ResponseInfo) =>
-          if respInfo.statusCode() == HttpURLConnection.HTTP_OK then
-            new SseSubscriber(serviceImpl.stringConsumer(streamingConsumer))
-          else
-            // For error responses, read the body to get error details
-            HttpResponse.BodySubscribers.mapping(
-              HttpResponse.BodySubscribers.ofString(java.nio.charset.StandardCharsets.UTF_8),
-              (body: String) => {
-                val code = respInfo.statusCode()
-                println(s"Error response ($code): $body")
-                // 4xx errors (except 429) are client errors - don't retry
-                if code >= 400 && code < 500 && code != 429 then
-                  throw ExternalTextGenerationError.Http(
-                    code,
-                    s"Client error $code: $body"
-                  )
-                else
-                  throw new RuntimeException(
-                    s"Server error $code: $body"
-                  )
-              }
-            )
-      )
-      .asScala
-      .andThen {
-        case x =>
-          inProgressCount -= 1
-          x
-      }
-      .transform {
-        case Success(httpResponse) =>
-          val rateLimits = serviceImpl.rateLimitsFrom(
-            headers = httpResponse
-              .headers()
-              .map()
-              .asScala
-              .map { case (k, v) => (k, v.asScala.toVector) }
-              .toMap
+
+    // Start the SSE connection
+    val eventSource = eventSourceFactory.newEventSource(okHttpRequest, sseListener)
+
+    // Convert the CompletableFuture to a Scala Future
+    sseListener.getFuture.asScala.andThen {
+      case _ =>
+        inProgressCount -= 1
+    }.transform {
+      case Success(_) =>
+        val duration = System.currentTimeMillis() - startTime
+        this.synchronized {
+          successDurations.addOne(duration)
+          if successDurations.size % 100 == 0 then {
+            successDurations = successDurations.sorted
+            val p99pos =
+              successDurations.size - successDurations.size / 100
+            println(s"p99 duration: ${successDurations(p99pos)}ms")
+          }
+        }
+        Success(())
+
+      case Failure(e: SocketTimeoutException) =>
+        println(s"Read timeout after ${readTimeoutSeconds}s: ${e.getMessage}")
+        Failure(
+          ExternalTextGenerationError.Timeout(
+            s"Read timeout after ${readTimeoutSeconds}s: ${e.getMessage}"
          )
-          currentRateLimits = rateLimits
-          currentRateLimitTime = ZonedDateTime.now()
+        )

-          val responseCode = httpResponse.statusCode()
-          if responseCode < HttpURLConnection.HTTP_BAD_REQUEST then {
-            val duration = System.currentTimeMillis() - startTime
-
-            this.synchronized {
-              successDurations.addOne(duration)
-              if successDurations.size % 100 == 0 then {
-                successDurations = successDurations.sorted
-                val p99pos =
-                  successDurations.size - successDurations.size / 100
-                println(s"p99 duration: ${successDurations(p99pos)}ms")
-              }
-
-              Success(httpResponse)
-            }
-          } else if responseCode == 429 then
-            Failure(
-              ExternalTextGenerationError.RateLimit(
-                responseCode,
-                httpResponse.toString
-              )
-            )
-          else
-            Failure(
-              ExternalTextGenerationError.Http(
-                responseCode,
-                "An error occurred while generating a response.\n" + httpResponse
-              )
-            )
-
-        case Failure(timeoutException: HttpTimeoutException) =>
-          Failure(
-            ExternalTextGenerationError.Timeout(
-              s"Timed out: ${timeoutException.getMessage}"
-            )
+      case Failure(e: IOException) if e.getMessage != null && e.getMessage.contains("timeout") =>
+        println(s"Timeout: ${e.getMessage}")
+        Failure(
+          ExternalTextGenerationError.Timeout(
+            s"Timeout: ${e.getMessage}"
          )
+        )

-        case Failure(exception) => Failure(exception)
-      }
-      .recoverWith {
-        // Don't retry 4xx client errors - they won't succeed
-        case e: CompletionException if e.getCause.isInstanceOf[ExternalTextGenerationError.Http] =>
-          Future.failed(e.getCause)
-        case e: ExternalTextGenerationError.Http                                                 =>
-          Future.failed(e)
-        // Retry transient errors (5xx, timeouts, network issues)
-        case e: CompletionException                                                              =>
-          println(s"CompletionException error $e - retrying")
-          tryAgain()
-        case e: Throwable                                                                        =>
-          println(s"error $e - retrying")
-          tryAgain()
-      }
+      case Failure(exception) => Failure(exception)
+    }.recoverWith {
+      // Don't retry 4xx client errors - they won't succeed
+      case e: ExternalTextGenerationError.Http    =>
+        Future.failed(e)
+      // Retry transient errors (timeouts, network issues)
+      case e: ExternalTextGenerationError.Timeout =>
+        println(s"Timeout error - retrying: ${e.message}")
+        tryAgain()
+      case e: IOException                         =>
+        println(s"IOException - retrying: ${e.getMessage}")
+        tryAgain()
+      case e: Throwable                           =>
+        println(s"error $e - retrying")
+        tryAgain()
+    }
  }
 }
@@ -4,6 +4,9 @@ import scala.concurrent.duration.{Duration, SECONDS}
 import scala.concurrent.Await
 //import scala.util.Random

+enum LlmProvider:
+  case Claude, OpenAIChatCompletions, OpenAIResponses
+
 object ExternalTextGenerationCallerApp {
  def main(args: Array[String]): Unit = {
 //    val personalityWords = Vector(
@@ -30,8 +33,16 @@ object ExternalTextGenerationCallerApp {
    val chatGptImpl: ExternalTextGenerationServiceImpl =
      new OpenAIChatCompletionsServiceImpl()

-    val caller = new ExternalTextGenerationCaller(
-      serviceImpl = if true then claudeImpl else chatGptImpl
+    val openAiResponsesImpl: ExternalTextGenerationServiceImpl =
+      new OpenAIResponsesServiceImpl()
+
+    val selectedProvider = LlmProvider.OpenAIResponses
+    val caller           = new ExternalTextGenerationCaller(
+      serviceImpl = selectedProvider match {
+        case LlmProvider.Claude                => claudeImpl
+        case LlmProvider.OpenAIChatCompletions => chatGptImpl
+        case LlmProvider.OpenAIResponses       => openAiResponsesImpl
+      }
    )

    (0 to 0).foreach { _ =>
@@ -0,0 +1,200 @@
+package net.eagle0.common.llm_integration
+
+import java.net.{URI, URL}
+import java.net.http.HttpRequest
+import java.net.http.HttpRequest.BodyPublishers
+import java.time.{Duration, ZonedDateTime}
+import java.util.function.Consumer
+
+import org.json4s.{DefaultFormats, JString}
+import org.json4s.jvalue2extractable
+import org.json4s.jvalue2monadic
+import org.json4s.native.{Json, Serialization}
+
+/**
+ * OpenAI Responses API implementation.
+ *
+ * The Responses API is OpenAI's newer API primitive that offers: - Better performance with reasoning models (3%
+ * improvement in SWE-bench) - Lower costs through improved cache utilization (40-80% improvement) - Semantic streaming
+ * events with clear lifecycle (response.created, response.output_text.delta, response.completed) - Built-in tools (web
+ * search, file search, computer use, code interpreter)
+ *
+ * @see
+ *   https://platform.openai.com/docs/api-reference/responses
+ */
+object OpenAIResponsesServiceImpl {
+  val gpt5: String = "gpt-5.1"
+
+  private val apiKey              = ApiKeys.openAI
+  private val baseURL             = new URL("https://api.openai.com/v1/responses")
+  private val temperature: Double = 1.0
+
+  private def baseRequest(timeoutSeconds: Int): HttpRequest.Builder =
+    HttpRequest
+      .newBuilder()
+      .uri(URI.create(baseURL.toString))
+      .timeout(Duration.ofSeconds(timeoutSeconds))
+      .header(
+        "Authorization",
+        s"Bearer ${OpenAIResponsesServiceImpl.apiKey}"
+      )
+}
+
+class OpenAIResponsesServiceImpl(
+    timeoutSeconds: Int = 10,
+    val defaultModelName: String = "gpt-5.1"
+) extends ExternalTextGenerationServiceImpl {
+  implicit val jsonFormats: DefaultFormats.type = DefaultFormats
+
+  private def requestDictionary(
+      inputText: String,
+      partialCompletion: Option[String]
+  ): Map[String, Any] = {
+    // For partial completions, we need to format as an array of input items
+    // The Responses API uses "input" instead of "messages"
+    val input = partialCompletion match {
+      case Some(partial) =>
+        // When we have a partial completion, send as array of items
+        Vector(
+          Map("type" -> "message", "role" -> "user", "content"      -> inputText),
+          Map("type" -> "message", "role" -> "assistant", "content" -> partial)
+        )
+      case None          =>
+        // Simple text input when no partial completion
+        inputText
+    }
+
+    Map(
+      "model"       -> defaultModelName,
+      "temperature" -> OpenAIResponsesServiceImpl.temperature,
+      "stream"      -> true,
+      "input"       -> input
+    )
+  }
+
+  override def makeRequest(
+      inputText: String,
+      partialCompletion: Option[String]
+  ): HttpRequest =
+    OpenAIResponsesServiceImpl
+      .baseRequest(timeoutSeconds = timeoutSeconds)
+      .header("Content-Type", "application/json")
+      .POST(
+        BodyPublishers.ofString(
+          Serialization.write(
+            requestDictionary(
+              inputText = inputText,
+              partialCompletion = partialCompletion
+            )
+          )
+        )
+      )
+      .build()
+
+  override def stringConsumer(
+      streamingConsumer: Consumer[StreamingTextResults]
+  ): Consumer[String] = (t: String) => {
+    val json       = new Json(DefaultFormats)
+    val parsedJson =
+      try
+        json.parse(t)
+      catch {
+        case pe: org.json4s.ParserUtil.ParseException =>
+          println(s"Failed to parse JSON: $t")
+          throw pe
+      }
+
+    val eventType = (parsedJson \ "type").extractOpt[String]
+
+    eventType match {
+      case Some("response.output_text.delta") =>
+        // Text delta event - extract the delta and stream ID
+        val delta    = (parsedJson \ "delta").extract[String]
+        val itemId   = (parsedJson \ "item_id").extractOpt[String].getOrElse("unknown")
+        val streamId = itemId
+
+        streamingConsumer.accept(
+          StreamingTextResults(
+            streamId = streamId,
+            value = delta,
+            completed = false
+          )
+        )
+
+      case Some("response.output_text.done") =>
+        // Text is complete for this output item
+        val itemId   = (parsedJson \ "item_id").extractOpt[String].getOrElse("unknown")
+        val streamId = itemId
+
+        streamingConsumer.accept(
+          StreamingTextResults(
+            streamId = streamId,
+            value = "",
+            completed = true
+          )
+        )
+
+      case Some("response.completed") =>
+        // Response is fully complete - extract the response ID as streamId
+        val responseId = (parsedJson \ "response" \ "id").extractOpt[String].getOrElse("unknown")
+        streamingConsumer.accept(
+          StreamingTextResults(
+            streamId = responseId,
+            value = "",
+            completed = true
+          )
+        )
+
+      case Some("response.created") | Some("response.in_progress") | Some("response.output_item.added") | Some(
+            "response.content_part.added"
+          ) =>
+        // Lifecycle events - ignore, no content to stream
+        ()
+
+      case Some("error") =>
+        // Error event
+        val errorMsg = (parsedJson \ "error" \ "message").extractOpt[String].getOrElse("Unknown error")
+        throw new RuntimeException(s"OpenAI Responses API error: $errorMsg")
+
+      case Some(other) =>
+        // Unknown event type - log but continue
+        println(s"OpenAI Responses API: ignoring unknown event type: $other")
+
+      case None =>
+        // No event type - might be malformed, log it
+        println(s"OpenAI Responses API: received message without event type: $t")
+    }
+  }
+
+  override def rateLimitsFrom(
+      headers: Map[String, Vector[String]]
+  ): Option[RateLimits] =
+    // The Responses API uses the same rate limit headers as Chat Completions
+    for {
+      requestLimit      <- headers.get("x-ratelimit-limit-requests")
+      tokenLimit        <- headers.get("x-ratelimit-limit-tokens")
+      requestsRemaining <- headers.get("x-ratelimit-remaining-requests")
+      tokensRemaining   <- headers.get("x-ratelimit-remaining-tokens")
+      requestResetTime  <- headers.get("x-ratelimit-reset-requests")
+      tokenResetTime    <- headers.get("x-ratelimit-reset-tokens")
+    } yield RateLimits(
+      requestLimit = requestLimit.head.toInt,
+      tokenLimit = tokenLimit.head.toInt,
+      requestsRemaining = requestsRemaining.head.toInt,
+      tokensRemaining = tokensRemaining.head.toInt,
+      requestResetTime = ZonedDateTime
+        .now()
+        .plus(
+          OpenAiDurationParser
+            .parseDuration(requestResetTime.head)
+            .getOrElse(Duration.ZERO)
+        ),
+      tokenResetTime = ZonedDateTime
+        .now()
+        .plus(
+          OpenAiDurationParser
+            .parseDuration(tokenResetTime.head)
+            .getOrElse(Duration.ZERO)
+        )
+    )
+}
@@ -18,3 +18,13 @@ scala_library(
        "@maven//:org_json4s_json4s_core_3",
    ],
 )
+
+scala_library(
+    name = "okhttp_sse_listener",
+    srcs = ["OkHttpSseListener.scala"],
+    visibility = ["//visibility:public"],
+    deps = [
+        "@maven//:com_squareup_okhttp3_okhttp",
+        "@maven//:com_squareup_okhttp3_okhttp_sse",
+    ],
+)
@@ -0,0 +1,62 @@
+package net.eagle0.common.sse
+
+import java.util.concurrent.CompletableFuture
+import java.util.function.Consumer
+
+import okhttp3.sse.{EventSource, EventSourceListener}
+import okhttp3.Response
+
+/**
+ * OkHttp-based SSE listener that wraps our existing SseEventReader logic.
+ *
+ * Key benefit over Java HttpClient: OkHttp supports read timeouts, so if the server stops sending data without properly
+ * closing the connection, we'll get a timeout error instead of waiting forever.
+ */
+class OkHttpSseListener(messageDataConsumer: Consumer[String]) extends EventSourceListener {
+
+  private val future: CompletableFuture[Unit] = new CompletableFuture[Unit]
+
+  private val DoneToken = "[DONE]"
+
+  def getFuture: CompletableFuture[Unit] = future
+
+  override def onOpen(eventSource: EventSource, response: Response): Unit = {
+    // Connection established, nothing to do
+  }
+
+  override def onEvent(
+      eventSource: EventSource,
+      id: String,
+      `type`: String,
+      data: String
+  ): Unit =
+    try
+      if data != DoneToken then {
+        messageDataConsumer.accept(data)
+      }
+      // If it's [DONE], just ignore - onClosed will be called
+    catch {
+      case e: Exception =>
+        val _ = future.completeExceptionally(e)
+        eventSource.cancel()
+    }
+
+  override def onClosed(eventSource: EventSource): Unit =
+    if !future.isDone then {
+      val _ = future.complete(())
+    }
+
+  override def onFailure(
+      eventSource: EventSource,
+      t: Throwable,
+      response: Response
+  ): Unit =
+    if !future.isDone then {
+      if response != null then {
+        println(s"SSE failure with response code ${response.code()}: ${t.getMessage}")
+      } else {
+        println(s"SSE failure: ${t.getMessage}")
+      }
+      val _ = future.completeExceptionally(t)
+    }
+}
@@ -21,7 +21,8 @@ case class IncompleteClientText(
    id: ClientTextId,
    partialText: String,
    requestedAfterHistoryCount: Int,
-    llmRequest: GeneratedTextRequest
+    llmRequest: GeneratedTextRequest,
+    requestedAtMillis: Long
 ) extends ClientText {
  def append(newText: String): IncompleteClientText =
    copy(partialText = partialText + newText)
@@ -17,6 +17,15 @@ trait ClientTextStore {
  def unrequestedTexts: Map[ClientTextId, UnrequestedClientText]
  def accessibleTo: Map[ClientTextId, Vector[FactionId]]

+  /** Returns incomplete texts that have been waiting longer than the threshold */
+  def stalledIncompleteTexts(
+      thresholdMillis: Long,
+      currentTimeMillis: Long = System.currentTimeMillis()
+  ): Vector[IncompleteClientText] =
+    incompleteTexts.values
+      .filter(ict => currentTimeMillis - ict.requestedAtMillis > thresholdMillis)
+      .toVector
+
  def saved: ClientTextStore

  def withAddedTextRequest(
@@ -69,7 +69,8 @@ case class ClientTextStoreImpl(
              id = id,
              partialText = "",
              llmRequest = unrequested.llmRequest,
-              requestedAfterHistoryCount = unrequested.requestedAfterHistoryCount
+              requestedAfterHistoryCount = unrequested.requestedAfterHistoryCount,
+              requestedAtMillis = System.currentTimeMillis()
            )),
          unrequestedTexts = unrequestedTexts - id,
          incompleteTextsAreSaved = false
@@ -238,7 +239,8 @@ object ClientTextStoreImpl {
                id = ict.id,
                partialText = ict.text,
                llmRequest = Some(ict.llmRequest),
-                requestedAfterHistoryCount = ict.requestedAfterHistoryCount
+                requestedAfterHistoryCount = ict.requestedAfterHistoryCount,
+                requestedAtMillis = ict.requestedAtMillis
              )
          }.toVector,
          unrequestedTexts = completeSaved.unrequestedTexts.map {
@@ -330,7 +332,12 @@ object ClientTextStoreImpl {
                  id = it.id,
                  partialText = it.partialText,
                  llmRequest = it.llmRequest.get,
-                  requestedAfterHistoryCount = it.requestedAfterHistoryCount
+                  requestedAfterHistoryCount = it.requestedAfterHistoryCount,
+                  // Use persisted timestamp if available, otherwise use current time
+                  // (for backwards compatibility with old persisted data)
+                  requestedAtMillis =
+                    if it.requestedAtMillis > 0 then it.requestedAtMillis
+                    else System.currentTimeMillis()
                )
              }.toVector,
              icts.unrequestedTexts.map { it =>
@@ -48,7 +48,9 @@ scala_library(
        "//src/main/protobuf/net/eagle0/eagle/views:action_result_view_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier_impl",
        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_proto_applier_impl",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier_impl",
        "//src/main/scala/net/eagle0/eagle/library/actions/availability",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action:check_for_fulfilled_quests_action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action:hero_backstory_update_action_generator",
@@ -57,18 +59,19 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:command_factory",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_proto_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
        "//src/main/scala/net/eagle0/eagle/library/util/hero_generator",
        "//src/main/scala/net/eagle0/eagle/library/util/validations:runtime_validator",
+        "//src/main/scala/net/eagle0/eagle/library/util/validations:scala_runtime_validator",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types/base:action_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_type_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
@@ -149,11 +152,16 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
    deps = [
+        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
+        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/protobuf/net/eagle0/shardok/api:action_result_view_scala_proto",
        "//src/main/protobuf/net/eagle0/shardok/api:command_descriptor_scala_proto",
        "//src/main/protobuf/net/eagle0/shardok/storage:action_result_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
@@ -203,7 +211,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:command_factory",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:vigor_xp_applier",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
        "//src/main/scala/net/eagle0/eagle/library/util/hero_generator",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
@@ -211,17 +219,13 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types/base:action_result_type",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_type_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type_id",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
@@ -7,7 +7,12 @@ import net.eagle0.eagle.{FactionId, GameId, ProvinceId}
 import net.eagle0.eagle.api.command.AvailableCommands
 import net.eagle0.eagle.api.selected_command.SelectedCommand
 import net.eagle0.eagle.internal.action_result.ActionResult
-import net.eagle0.eagle.library.actions.applier.{ActionResultProtoApplier, ActionResultProtoApplierImpl}
+import net.eagle0.eagle.library.actions.applier.{
+  ActionResultApplierImpl,
+  ActionResultProtoApplier,
+  ActionResultProtoApplierImpl,
+  ActionResultWithResultingState
+}
 import net.eagle0.eagle.library.actions.availability.AvailableCommandsFactory
 import net.eagle0.eagle.library.actions.impl.action.{
  CheckForFulfilledQuestsAction,
@@ -15,11 +20,12 @@ import net.eagle0.eagle.library.actions.impl.action.{
  ResolveBattleAction
 }
 import net.eagle0.eagle.library.actions.impl.command.{AvailableCommandTypeMap, CommandFactory}
-import net.eagle0.eagle.library.actions.impl.common.{ActionWithResultingState, RandomStateProtoSequencer}
+import net.eagle0.eagle.library.actions.impl.common.ActionWithResultingState
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.util.hero_generator.HeroGenerator
-import net.eagle0.eagle.library.util.validations.RuntimeValidator
+import net.eagle0.eagle.library.util.validations.{RuntimeValidator, ScalaRuntimeValidator}
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
-import net.eagle0.eagle.library.EngineImpl.{appliedResults, withUpdateChecks}
+import net.eagle0.eagle.library.EngineImpl.{appliedResults, appliedResultsScala, withUpdateChecks}
 import net.eagle0.eagle.model.action_result.ActionResultT
 import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
 import net.eagle0.eagle.model.proto_converters.BattalionTypeConverter
@@ -43,10 +49,10 @@ object EngineImpl {
  private def withPhaseAdvancement(
      engineAndResultsImpl: EngineAndResultsImpl
  ): EngineAndResultsImpl =
-    engineAndResultsImpl.recursiveTransform(eng =>
+    engineAndResultsImpl.recursiveTransformScala(eng =>
      RoundPhaseAdvancer.checkForPhaseAdvancement(
-        currentState = GameStateConverter.toProto(eng.currentState),
-        actionResultProtoApplier = eng.actionResultProtoApplier,
+        currentState = eng.currentState,
+        actionResultApplier = ActionResultApplierImpl(Some(ScalaRuntimeValidator)),
        history = eng.history,
        availableCommandsFactory = eng.availableCommandsFactory,
        heroGenerator = eng.heroGenerator,
@@ -97,14 +103,31 @@ object EngineImpl {
      results = results.map(_.actionResult)
    )
  )
+
+  def appliedResultsScala(
+      engine: EngineImpl,
+      results: Vector[ActionResultWithResultingState]
+  ): EngineAndResults = withUpdateChecks(
+    EngineAndResultsImpl(
+      engine = engine.copy(
+        currentState = results.lastOption
+          .map(_.resultingState)
+          .getOrElse(engine.currentState),
+        history = engine.history.withNewResultsScala(results)
+      ),
+      results = results.map(awrs =>
+        net.eagle0.eagle.model.proto_converters.ActionResultProtoConverter.toProto(awrs.actionResult)
+      )
+    )
+  )
 }

 final case class EngineAndResultsImpl(
    engine: EngineImpl,
    results: Vector[ActionResult]
 ) extends EngineAndResults {
-  def recursiveTransform(
-      f: EngineImpl => Vector[ActionWithResultingState]
+  def recursiveTransformScala(
+      f: EngineImpl => Vector[ActionResultWithResultingState]
  ): EngineAndResultsImpl = {
    @tailrec
    def go(
@@ -115,7 +138,7 @@ final case class EngineAndResultsImpl(

      if goResults.isEmpty then EngineAndResultsImpl(eng, acc)
      else
-        appliedResults(eng, goResults) match {
+        appliedResultsScala(eng, goResults) match {
          case EngineAndResultsImpl(eng2, res) =>
            go(eng2, acc ++ res)
        }
@@ -126,13 +149,13 @@ final case class EngineAndResultsImpl(

  def recursiveTransformT(
      f: EngineImpl => Vector[ActionResultT]
-  ): EngineAndResultsImpl = recursiveTransform { eng =>
-    val results = f(eng)
-    RandomStateProtoSequencer(
+  ): EngineAndResultsImpl = recursiveTransformScala { eng =>
+    val actionResultApplier = ActionResultApplierImpl(Some(ScalaRuntimeValidator))
+    RandomStateSequencer(
      initialState = eng.currentState,
-      actionResultProtoApplier = eng.actionResultProtoApplier,
+      actionResultApplier = actionResultApplier,
      functionalRandom = SeededRandom(eng.currentState.randomSeed)
-    ).withActionResultTs(_ => results).results.newValue
+    ).withActionResults(_ => f(eng)).resultsWithStates.newValue
  }

  def saveNow: EngineAndResultsImpl =
@@ -282,37 +305,34 @@ case class EngineImpl(
    )
    val availableCommand    = availableCommandOpt.get

-    val sequencer = RandomStateProtoSequencer(
+    val sequencer = RandomStateSequencer(
      initialState = this.currentState,
-      actionResultProtoApplier = actionResultProtoApplier,
+      actionResultApplier = ActionResultApplierImpl(Some(ScalaRuntimeValidator)),
      functionalRandom = SeededRandom(this.currentState.randomSeed)
-    ).withActionResults { gs =>
-      val results = commandFactory
-        .makeCommand(
-          actingFactionId = factionId,
-          gameState = GameStateConverter.fromProto(gs),
-          availableCommand = availableCommand,
-          selectedCommand = selectedCommand
-        )
-        .execute(actionResultProtoApplier)
-        .map(_.actionResult)
-
-      if !results.headOption.forall(_.player.isDefined) then {
-        print(
-          "Result with type " + results.head.`type` + " did not have a player set"
-        )
-      }
-      internalRequire(
-        results.headOption.forall(_.player.isDefined),
-        s"Result with type ${results.head.`type`} did not have a player set"
+    ).withTCommand { gs =>
+      commandFactory.makeTCommand(
+        actingFactionId = factionId,
+        gameState = gs,
+        availableCommand = availableCommand,
+        selectedCommand = selectedCommand
      )
+    }.withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator(gs))

-      results
-    }.withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator.fromGameState(gs))
+    // Validate that the first result has an acting faction set (required for player commands)
+    val firstResult = sequencer.actionResults.newValue.headOption
+    if !firstResult.forall(_.actingFactionId.isDefined) then {
+      print(
+        "Result with type " + firstResult.map(_.actionResultType).getOrElse("unknown") + " did not have a player set"
+      )
+    }
+    internalRequire(
+      firstResult.forall(_.actingFactionId.isDefined),
+      s"Result with type ${firstResult.map(_.actionResultType).getOrElse("unknown")} did not have a player set"
+    )

-    appliedResults(
+    appliedResultsScala(
      engine = this,
-      results = sequencer.results.newValue
+      results = sequencer.resultsWithStates.newValue
    )
  }
 }
@@ -1,7 +1,10 @@
 package net.eagle0.eagle.library

 import net.eagle0.eagle.{FactionId, RoundId, ShardokGameId}
+import net.eagle0.eagle.library.actions.applier.ActionResultWithResultingState
 import net.eagle0.eagle.library.actions.impl.common.ActionWithResultingState
+import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
+import net.eagle0.eagle.model.proto_converters.ActionResultProtoConverter
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.shardok.api.action_result_view.ActionResultView as ShardokActionResultView
@@ -37,6 +40,14 @@ trait GameHistory {

  def withNewResults(newResults: Vector[ActionWithResultingState]): GameHistory

+  def withNewResultsScala(newResults: Vector[ActionResultWithResultingState]): GameHistory =
+    withNewResults(newResults.map { awrs =>
+      ActionWithResultingState(
+        actionResult = ActionResultProtoConverter.toProto(awrs.actionResult),
+        gameState = GameStateConverter.toProto(awrs.resultingState)
+      )
+    })
+
  def shardokCount(shardokGameId: ShardokGameId): Int

  def shardokGameState(
@@ -3,37 +3,30 @@ package net.eagle0.eagle.library
 import scala.collection.mutable

 import net.eagle0.common.SeededRandom
-import net.eagle0.eagle.common.round_phase.RoundPhase
-import net.eagle0.eagle.common.round_phase.RoundPhase.*
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.library.actions.applier.{ActionResultProtoApplier, ActionResultTApplierImpl}
+import net.eagle0.eagle.internal.game_state.GameState as GameStateProto
+import net.eagle0.eagle.library.actions.applier.{ActionResultApplier, ActionResultWithResultingState}
 import net.eagle0.eagle.library.actions.availability.AvailableCommandsFactory
 import net.eagle0.eagle.library.actions.impl.action.*
 import net.eagle0.eagle.library.actions.impl.command.CommandFactory
-import net.eagle0.eagle.library.actions.impl.common.ActionWithResultingState
+import net.eagle0.eagle.library.actions.impl.common.VigorXPApplier
 import net.eagle0.eagle.library.util.hero_generator.HeroGenerator
 import net.eagle0.eagle.library.util.EagleRequire.internalValidated
-import net.eagle0.eagle.model.proto_converters.date.DateConverter
-import net.eagle0.eagle.model.proto_converters.faction.FactionConverter
 import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
-import net.eagle0.eagle.model.proto_converters.ActionResultProtoConverter
-import net.eagle0.eagle.model.proto_converters.BattalionConverter
-import net.eagle0.eagle.model.proto_converters.BattalionTypeConverter
-import net.eagle0.eagle.model.state.battalion.BattalionT
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.RoundPhase
+import net.eagle0.eagle.model.state.RoundPhase.*
 import net.eagle0.eagle.RoundId

 object RoundPhaseAdvancer {
  private val times: mutable.Map[RoundPhase, Long] =
-    mutable.Map(RoundPhase.values.map(_ -> 0L)*)
+    mutable.Map(RoundPhase.allValues.map(_ -> 0L)*)
  private val print                                = false
  private val roundsBetweenPrint                   = 100

  private def printTimings(roundId: RoundId): Unit = {
    val totalTime = times.values.sum.toDouble / 1000.0

-    times.toVector.sortBy(_._2)(Ordering.Long.reverse).foreach {
+    times.toVector.sortBy(_._2)(using Ordering.Long.reverse).foreach {
      case (phase, time) =>
        val timeInSecs = time.toDouble / 1000.0
        val msPerRound = time.toDouble / roundId.toDouble
@@ -47,360 +40,338 @@ object RoundPhaseAdvancer {

  def checkForPhaseAdvancement(
      currentState: GameState,
-      actionResultProtoApplier: ActionResultProtoApplier,
+      actionResultApplier: ActionResultApplier,
      history: GameHistory,
      availableCommandsFactory: AvailableCommandsFactory,
      heroGenerator: HeroGenerator,
      commandFactory: CommandFactory
-  ): Vector[ActionWithResultingState] = {
+  ): Vector[ActionResultWithResultingState] = {
+    // Lazy conversion to proto for AvailableCommandsFactory calls
+    lazy val currentStateProto: GameStateProto = GameStateConverter.toProto(currentState)
+
    val currentPhase = currentState.currentPhase
    val startTime    = System.currentTimeMillis

-    if print && currentPhase == NEW_ROUND && currentState.currentRoundId % roundsBetweenPrint == 0
+    if print && currentPhase == NewRound && currentState.currentRoundId % roundsBetweenPrint == 0
    then {
      printTimings(currentState.currentRoundId)
    }

-    val results: Vector[ActionWithResultingState] = currentPhase match {
-      case UNKNOWN_PHASE =>
-        throw new IllegalStateException(
-          "Somehow we're in game state UNKNOWN_PHASE"
+    val results: Vector[ActionResultWithResultingState] = currentPhase match {
+      case NewRound =>
+        val actionResults = NewRoundAction(currentState, history, actionResultApplier)
+          .randomResults(SeededRandom(currentState.randomSeed))
+          .newValue
+          .map(VigorXPApplier.withVigorXp)
+        actionResultApplier.applyActionResults(currentState, actionResults)
+
+      case PrisonerExchange =>
+        actionResultApplier.applyActionResults(
+          currentState,
+          PrisonerExchangeAction(currentState).results
        )

-      case NEW_ROUND =>
-        NewRoundAction(GameStateConverter.fromProto(currentState), history).execute(actionResultProtoApplier)
-
-      case PRISONER_EXCHANGE =>
-        PrisonerExchangeAction(currentState).execute(actionResultProtoApplier)
-
-      case PROVINCE_EVENTS =>
-        PerformProvinceEventsAction(
-          GameStateConverter.fromProto(currentState)
-        ).execute(actionResultProtoApplier)
-
-      case FORCED_TURN_BACK =>
-        PerformForcedTurnBackAction(currentState).execute(
-          actionResultProtoApplier
+      case ProvinceEvents =>
+        actionResultApplier.applyActionResults(
+          currentState,
+          PerformProvinceEventsAction(currentState)
+            .results(SeededRandom(currentState.randomSeed))
        )

-      case PROVINCE_MOVE_RESOLUTION =>
-        PerformProvinceMoveResolutionAction(
-          GameStateConverter.fromProto(currentState)
-        ).execute(actionResultProtoApplier)
+      case ForcedTurnBack =>
+        actionResultApplier.applyActionResults(
+          currentState,
+          PerformForcedTurnBackAction(currentState).results
+        )

-      case HANDLE_RIOT =>
+      case ProvinceMoveResolution =>
+        val actionResults = PerformProvinceMoveResolutionAction(currentState, actionResultApplier)
+          .results(SeededRandom(currentState.randomSeed))
+          .map(VigorXPApplier.withVigorXp)
+        actionResultApplier.applyActionResults(currentState, actionResults)
+
+      case HandleRiot =>
        if availableCommandsFactory
-            .hasAvailableHandleRiotPhaseCommands(currentState)
+            .hasAvailableHandleRiotPhaseCommands(currentStateProto)
        then Vector.empty
        else
-          EndHandleRiotsPhaseAction(
-            gameState = GameStateConverter.fromProto(currentState),
+          val actionResults = EndHandleRiotsPhaseAction(
+            gameState = currentState,
            commandsForProvince = pid =>
              availableCommandsFactory
                .handleRiotPhaseCommandsForOneProvince(
-                  currentState,
-                  currentState.provinces(pid)
+                  currentStateProto,
+                  currentStateProto.provinces(pid)
                ),
-            commandFactory = commandFactory
-          ).execute(actionResultProtoApplier)
+            commandFactory = commandFactory,
+            actionResultApplier = actionResultApplier
+          ).results(SeededRandom(currentState.randomSeed))
+            .map(VigorXPApplier.withVigorXp)
+          actionResultApplier.applyActionResults(currentState, actionResults)

-      case HERO_DEPARTURES =>
-        PerformHeroDeparturesAction(
-          startingState = currentState,
-          functionalRandom = SeededRandom(currentState.randomSeed)
-        ).execute(actionResultProtoApplier)
+      case HeroDepartures =>
+        val actionResults = PerformHeroDeparturesAction(gameState = currentState)
+          .results(SeededRandom(currentState.randomSeed))
+        actionResultApplier.applyActionResults(currentState, actionResults)

-      case UNAFFILIATED_HERO_ACTIONS =>
-        PerformUnaffiliatedHeroesAction(
-          gameState = GameStateConverter.fromProto(currentState),
-          heroGenerator = heroGenerator
-        ).execute(actionResultProtoApplier)
+      case UnaffiliatedHeroActions =>
+        val actionResults = PerformUnaffiliatedHeroesAction(
+          gameState = currentState,
+          heroGenerator = heroGenerator,
+          actionResultApplier = actionResultApplier
+        ).results(SeededRandom(currentState.randomSeed))
+          .map(VigorXPApplier.withVigorXp)
+        actionResultApplier.applyActionResults(currentState, actionResults)

-      case PLEASE_RECRUIT_ME =>
+      case PleaseRecruitMe =>
        if availableCommandsFactory
-            .hasAvailablePleaseRecruitMePhaseCommands(currentState)
+            .hasAvailablePleaseRecruitMePhaseCommands(currentStateProto)
        then Vector.empty
        else
          Vector(
-            actionResultProtoApplier.applyActionResult(
+            actionResultApplier.applyActionResult(
              currentState,
-              ActionResultProtoConverter.toProto(
-                EndPleaseRecruitMePhaseAction.fromProtoState(currentState).immediateExecute
-              )
+              EndPleaseRecruitMePhaseAction(currentState).immediateExecute
            )
          )

-      case VASSAL_COMMANDS =>
+      case VassalCommands =>
        val vassalCommandResults = PerformVassalCommandsPhaseAction(
-          gameState = GameStateConverter.fromProto(currentState),
+          gameState = currentState,
          commandsForProvince = availableCommandsFactory
-            .commandPhaseCommandsForProvince(currentState, _),
-          commandFactory = commandFactory
-        ).execute(actionResultProtoApplier)
+            .commandPhaseCommandsForProvince(currentStateProto, _),
+          commandFactory = commandFactory,
+          actionResultApplier = actionResultApplier
+        ).results(SeededRandom(currentState.randomSeed))
+          .map(VigorXPApplier.withVigorXp)
+        val appliedResults       = actionResultApplier.applyActionResults(currentState, vassalCommandResults)

-        if vassalCommandResults.nonEmpty then vassalCommandResults
+        if appliedResults.nonEmpty then appliedResults
        else
-          EndVassalCommandsPhaseAction(GameStateConverter.fromProto(currentState)).execute(
-            actionResultProtoApplier
-          )
+          val endResults = EndVassalCommandsPhaseAction(currentState, actionResultApplier)
+            .results(SeededRandom(currentState.randomSeed))
+            .map(VigorXPApplier.withVigorXp)
+          actionResultApplier.applyActionResults(currentState, endResults)

-      case PLAYER_COMMANDS =>
+      case PlayerCommands =>
        if availableCommandsFactory
            .hasAvailablePlayerCommandsPhaseCommands(
-              currentState
+              currentStateProto
            )
        then Vector.empty
        else
-          actionResultProtoApplier.applyActionResults(
+          actionResultApplier.applyActionResults(
            currentState,
            EndPlayerCommandsPhaseAction(
              currentState,
-              ActionResultTApplierImpl(actionResultProtoApplier)
-            ).results(functionalRandom = SeededRandom(currentState.randomSeed))
-              .map(
-                ActionResultProtoConverter.toProto(_)
-              )
+              actionResultApplier
+            ).randomResults(functionalRandom = SeededRandom(currentState.randomSeed)).newValue
          )

-      case HOSTILE_ARMY_SETUP =>
+      case HostileArmySetup =>
        Vector(
-          actionResultProtoApplier.applyActionResult(
+          actionResultApplier.applyActionResult(
            currentState,
-            ActionResultProtoConverter.toProto(
-              PerformHostileArmySetupAction(
-                GameStateConverter.fromProto(currentState)
-              ).immediateExecute
-            )
+            PerformHostileArmySetupAction(currentState).immediateExecute
          )
        )

-      case FREE_FOR_ALL_DECISION =>
+      case FreeForAllDecision =>
        if availableCommandsFactory
            .hasAvailableFreeForAllDecisionPhaseCommands(
-              currentState
+              currentStateProto
            )
        then Vector.empty
        else
          // There may eventually be VassalAttackDecisions, but for now we're leaving that on the player
-          actionResultProtoApplier.applyActionResults(
+          actionResultApplier.applyActionResults(
            currentState,
-            EndFreeForAllDecisionPhaseAction(currentState).results.map(
-              ActionResultProtoConverter.toProto(_)
-            )
+            EndFreeForAllDecisionPhaseAction(currentState).results
          )

-      case FREE_FOR_ALL_BATTLE_REQUEST =>
-        val requestResults = RequestFreeForAllBattlesAction(
-          currentState
-        ).execute(actionResultProtoApplier)
-        val latestState    = requestResults.lastOption.map(_.gameState).getOrElse(currentState)
-        requestResults :+ actionResultProtoApplier.applyActionResult(
+      case FreeForAllBattleRequest =>
+        val requestResults = actionResultApplier.applyActionResults(
+          currentState,
+          RequestFreeForAllBattlesAction(currentState).results
+        )
+        val latestState    = requestResults.lastOption.map(_.resultingState).getOrElse(currentState)
+        requestResults :+ actionResultApplier.applyActionResult(
          latestState,
-          ActionResultProtoConverter.toProto(EndFreeForAllBattleRequestPhaseAction.immediateExecute)
+          EndFreeForAllBattleRequestPhaseAction.immediateExecute
        )

-      case FREE_FOR_ALL_BATTLE_RESOLUTION =>
+      case FreeForAllBattleResolution =>
        if currentState.outstandingBattles.isEmpty then
          Vector(
-            actionResultProtoApplier.applyActionResult(
+            actionResultApplier.applyActionResult(
              currentState,
-              ActionResultProtoConverter.toProto(EndFreeForAllBattleResolutionPhaseAction.immediateExecute)
+              EndFreeForAllBattleResolutionPhaseAction.immediateExecute
            )
          )
        else Vector.empty // wait for battles to resolve

-      case UNCONTESTED_CONQUEST =>
-        actionResultProtoApplier.applyActionResults(
+      case UncontestedConquest =>
+        actionResultApplier.applyActionResults(
          currentState,
          PerformUncontestedConquestAction(
            gameId = currentState.gameId,
            currentRoundId = currentState.currentRoundId,
-            currentDate = DateConverter.fromProto(currentState.currentDate),
-            provinces = currentState.provinces.values
-              .map(ProvinceConverter.fromProto)
-              .map(p => p.id -> p)
-              .toMap,
-            factions = currentState.factions.values
-              .map(FactionConverter.fromProto)
-              .map(f => f.id -> f)
-              .toMap,
-            heroes = currentState.heroes.values
-              .map(HeroConverter.fromProto)
-              .map(h => h.id -> h)
-              .toMap,
-            battalions = currentState.battalions.values
-              .map(BattalionConverter.fromProto)
-              .map(b => (b.id, b))
-              .toMap
+            currentDate = currentState.currentDate.get,
+            provinces = currentState.provinces,
+            factions = currentState.factions,
+            heroes = currentState.heroes,
+            battalions = currentState.battalions
          ).results
-            .map(ActionResultProtoConverter.toProto)
        )

-      case ATTACK_DECISION =>
+      case AttackDecision =>
        if availableCommandsFactory.hasAvailableAttackDecisionPhaseCommands(
-            currentState
+            currentStateProto
          )
        then Vector.empty
        else {
          // There may eventually be VassalAttackDecisions, but for now we're leaving that on the player
-          actionResultProtoApplier.applyActionResults(
+          actionResultApplier.applyActionResults(
            currentState,
            EndAttackDecisionPhaseAction(
              gameId = currentState.gameId,
              currentRoundId = currentState.currentRoundId,
-              currentDate = DateConverter.fromProto(currentState.currentDate),
-              provinces = currentState.provinces.values
-                .map(ProvinceConverter.fromProto)
-                .toVector
-            ).results.map(ActionResultProtoConverter.toProto)
+              currentDate = currentState.currentDate.get,
+              provinces = currentState.provinces.values.toVector
+            ).results
          )
        }

-      case DEFENSE_DECISION =>
+      case DefenseDecision =>
        if availableCommandsFactory.hasAvailablePlayerDefenseCommands(
-            currentState
+            currentStateProto
          )
        then Vector.empty
        else {
          val vassalCommandResults = PerformVassalDefenseDecisionsAction(
-            gameState = GameStateConverter.fromProto(currentState),
+            gameState = currentState,
            commandsForProvince = availableCommandsFactory
-              .defensePhaseCommandsForProvince(currentState, _),
-            commandFactory = commandFactory
-          ).execute(actionResultProtoApplier)
+              .defensePhaseCommandsForProvince(currentStateProto, _),
+            commandFactory = commandFactory,
+            actionResultApplier = actionResultApplier
+          ).results(SeededRandom(currentState.randomSeed))
+            .map(VigorXPApplier.withVigorXp)
+          val appliedResults       = actionResultApplier.applyActionResults(currentState, vassalCommandResults)

-          if vassalCommandResults.nonEmpty then vassalCommandResults
+          if appliedResults.nonEmpty then appliedResults
          else
            Vector(
-              actionResultProtoApplier.applyActionResult(
+              actionResultApplier.applyActionResult(
                currentState,
-                ActionResultProtoConverter.toProto(
-                  EndDefenseDecisionPhaseAction.fromProtoState(currentState).immediateExecute
-                )
+                EndDefenseDecisionPhaseAction(currentState).immediateExecute
              )
            )
        }

-      case TRUCE_TURN_BACK =>
-        TruceTurnBackPhaseAction(GameStateConverter.fromProto(currentState)).execute(actionResultProtoApplier)
+      case TruceTurnBack =>
+        val actionResults = TruceTurnBackPhaseAction(currentState, actionResultApplier)
+          .results(SeededRandom(currentState.randomSeed))
+          .map(VigorXPApplier.withVigorXp)
+        actionResultApplier.applyActionResults(currentState, actionResults)

-      case BATTLE_REQUEST =>
+      case BattleRequest =>
        val requestBattlesAction = RequestBattlesAction(
          gameId = currentState.gameId,
          currentRoundId = currentState.currentRoundId,
-          currentDate = DateConverter.fromProto(currentState.currentDate),
+          currentDate = currentState.currentDate.get,
          battleCounter = currentState.battleCounter,
-          heroes = currentState.heroes.view.mapValues(HeroConverter.fromProto).toMap,
-          battalions = currentState.battalions.view
-            .mapValues(BattalionConverter.fromProto)
-            .toMap,
-          provinces = currentState.provinces.view
-            .mapValues(ProvinceConverter.fromProto)
-            .toMap,
-          factions = currentState.factions.view
-            .mapValues(FactionConverter.fromProto)
-            .toMap,
-          battalionTypes = currentState.battalionTypes.map { bt =>
-            val converted = BattalionTypeConverter.fromProto(bt)
-            converted.typeId -> converted
-          }.toMap
+          heroes = currentState.heroes,
+          battalions = currentState.battalions,
+          provinces = currentState.provinces,
+          factions = currentState.factions,
+          battalionTypes = currentState.battalionTypes.map(bt => bt.typeId -> bt).toMap
        )
-        val requestResults       = actionResultProtoApplier.applyActionResults(
+        val requestResults       = actionResultApplier.applyActionResults(
          currentState,
-          requestBattlesAction.results.map(
-            ActionResultProtoConverter.toProto(_)
-          )
+          requestBattlesAction.results
        )
-        val latestState          = requestResults.lastOption.map(_.gameState).getOrElse(currentState)
-        requestResults :+ actionResultProtoApplier.applyActionResult(
+        val latestState          = requestResults.lastOption.map(_.resultingState).getOrElse(currentState)
+        requestResults :+ actionResultApplier.applyActionResult(
          latestState,
-          ActionResultProtoConverter.toProto(
-            EndBattleRequestPhaseAction.fromProtoState(latestState).immediateExecute
-          )
+          EndBattleRequestPhaseAction(latestState).immediateExecute
        )

-      case FOOD_CONSUMPTION =>
+      case FoodConsumption =>
        Vector(
-          actionResultProtoApplier.applyActionResult(
+          actionResultApplier.applyActionResult(
            currentState,
-            ActionResultProtoConverter.toProto(
-              PerformFoodConsumptionPhaseAction(GameStateConverter.fromProto(currentState)).immediateExecute
-            )
+            PerformFoodConsumptionPhaseAction(currentState).immediateExecute
          )
        )

-      case BATTLE_RESOLUTION =>
+      case BattleResolution =>
        if currentState.outstandingBattles.isEmpty then
          Vector(
-            actionResultProtoApplier.applyActionResult(
+            actionResultApplier.applyActionResult(
              currentState,
-              ActionResultProtoConverter.toProto(EndBattleResolutionPhaseAction.immediateExecute)
+              EndBattleResolutionPhaseAction.immediateExecute
            )
          )
        else Vector.empty // wait for battles to resolve

-      case BATTLE_AFTERMATH =>
+      case BattleAftermath =>
        if currentState.provinces.values
            .flatMap(_.capturedHeroes)
            .isEmpty
        then
-          actionResultProtoApplier.applyActionResults(
+          actionResultApplier.applyActionResults(
            currentState,
            EndBattleAftermathPhaseAction(
              currentState,
-              ActionResultTApplierImpl(actionResultProtoApplier)
+              actionResultApplier
            )
              .randomResults(
                SeededRandom(currentState.randomSeed)
              )
              .newValue
-              .map(ActionResultProtoConverter.toProto)
          )
        else Vector.empty

-      case DIPLOMACY_RESOLUTION =>
+      case DiplomacyResolution =>
        if availableCommandsFactory.hasAvailablePlayerCommands(
-            currentState
+            currentStateProto
          )
        then Vector.empty
        else
-          actionResultProtoApplier.applyActionResults(
+          actionResultApplier.applyActionResults(
            currentState,
            EndDiplomacyResolutionPhaseAction(
              currentState,
-              actionResultTApplier = ActionResultTApplierImpl(actionResultProtoApplier)
-            ).randomResults(SeededRandom(currentState.randomSeed))
-              .newValue
-              .map(ActionResultProtoConverter.toProto)
+              actionResultApplier = actionResultApplier
+            ).randomResults(SeededRandom(currentState.randomSeed)).newValue
          )

-      case RECON_RESOLUTION =>
-        PerformReconResolutionAction(GameStateConverter.fromProto(currentState)).execute(
-          actionResultProtoApplier
-        )
-
-      case Unrecognized(x) =>
-        throw new IllegalStateException(s"Unknown round phase $x")
+      case ReconResolution =>
+        val actionResults = PerformReconResolutionAction(currentState, actionResultApplier)
+          .results(SeededRandom(currentState.randomSeed))
+          .map(VigorXPApplier.withVigorXp)
+        actionResultApplier.applyActionResults(currentState, actionResults)
    }
-    val timeSpent                                 = System.currentTimeMillis - startTime
+    val timeSpent                                       = System.currentTimeMillis - startTime
    times(currentPhase) = times(currentPhase) + timeSpent

-    validateResults(results, currentState, availableCommandsFactory)
+    validateResults(results, currentState, currentStateProto, availableCommandsFactory)
  }

  // We should always either return results, be waiting for an LLM request or battle to resolve,
  // or have available player commands
  private def validateResults(
-      results: Vector[ActionWithResultingState],
+      results: Vector[ActionResultWithResultingState],
      startingState: GameState,
+      startingStateProto: GameStateProto,
      availableCommandsFactory: AvailableCommandsFactory
-  ): Vector[ActionWithResultingState] =
+  ): Vector[ActionResultWithResultingState] =
    internalValidated(
      results,
-      (r: Vector[ActionWithResultingState]) =>
+      (r: Vector[ActionResultWithResultingState]) =>
        r.nonEmpty ||
          startingState.outstandingBattles.nonEmpty ||
-          availableCommandsFactory.hasAvailablePlayerCommands(startingState),
+          availableCommandsFactory.hasAvailablePlayerCommands(startingStateProto),
      "No results were found, but we also don't seem to be waiting for anything"
    )
 }
@@ -0,0 +1,23 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.model.action_result.ActionResultT
+import net.eagle0.eagle.model.state.game_state.GameState
+
+case class ActionResultWithResultingState(
+    actionResult: ActionResultT,
+    resultingState: GameState
+)
+
+trait ActionResultApplier {
+  def xpForStatBump(stat: Int): Int
+
+  def applyActionResults(
+      startingState: GameState,
+      results: Iterable[ActionResultT]
+  ): Vector[ActionResultWithResultingState]
+
+  def applyActionResult(
+      startingState: GameState,
+      result: ActionResultT
+  ): ActionResultWithResultingState
+}
@@ -0,0 +1,165 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.library.util.validations.ScalaValidator
+import net.eagle0.eagle.model.action_result.ActionResultT
+import net.eagle0.eagle.model.state.battalion.BattalionT
+import net.eagle0.eagle.model.state.date.Date
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.hero.HeroT
+import net.eagle0.eagle.model.state.province.ProvinceT
+import net.eagle0.eagle.model.state.run_status.RunStatus
+import net.eagle0.eagle.model.state.RoundPhase
+// Import extension methods
+import GameStateExtensions.*
+
+/**
+ * Implementation of ActionResultApplier that applies ActionResultT directly to Scala GameState.
+ *
+ * This uses extension methods on GameState to apply each type of change.
+ */
+object ActionResultApplierImpl {
+  def apply(validator: Option[ScalaValidator]): ActionResultApplierImpl = new ActionResultApplierImpl(validator)
+
+  // Type class for single-argument validation
+  trait Validatable[T]:
+    def validate(v: ScalaValidator, value: T): T
+
+  given Validatable[HeroT] with
+    def validate(v: ScalaValidator, value: HeroT): HeroT = v.validate(value)
+
+  given Validatable[GameState] with
+    def validate(v: ScalaValidator, value: GameState): GameState = v.validate(value)
+
+  given Validatable[ActionResultT] with
+    def validate(v: ScalaValidator, value: ActionResultT): ActionResultT = v.validate(value)
+
+  // Type class for validation with GameState context
+  trait ValidatableWithGameState[T]:
+    def validate(v: ScalaValidator, value: T, gs: GameState): T
+
+  given ValidatableWithGameState[BattalionT] with
+    def validate(v: ScalaValidator, value: BattalionT, gs: GameState): BattalionT = v.validate(value, gs)
+}
+
+class ActionResultApplierImpl(validator: Option[ScalaValidator]) extends ActionResultApplier {
+  import ActionResultApplierImpl.{Validatable, ValidatableWithGameState, given}
+
+  // Generic single-argument validate
+  def validate[T: Validatable](value: T): T =
+    validator.fold(value)(v => summon[Validatable[T]].validate(v, value))
+
+  // Generic validate with GameState context
+  def validate[T: ValidatableWithGameState](value: T, gs: GameState): T =
+    validator.fold(value)(v => summon[ValidatableWithGameState[T]].validate(v, value, gs))
+
+  // Province validation with RoundPhase (unique signature, no type class needed)
+  def validate(province: ProvinceT, roundPhase: RoundPhase): ProvinceT =
+    validator.fold(province)(_.validate(province, roundPhase))
+
+  override def xpForStatBump(stat: Int): Int = GameStateExtensions.xpForStatBump(stat)
+
+  override def applyActionResults(
+      startingState: GameState,
+      results: Iterable[ActionResultT]
+  ): Vector[ActionResultWithResultingState] =
+    results
+      .foldLeft((startingState, Vector.empty[ActionResultWithResultingState])) {
+        case ((gameState, acc), result) =>
+          val awrs = applyActionResult(gameState, result)
+          (awrs.resultingState, acc :+ awrs)
+      }
+      ._2
+
+  override def applyActionResult(
+      startingState: GameState,
+      result: ActionResultT
+  ): ActionResultWithResultingState = {
+    // Validate the action result
+    validate(result)
+
+    // Get date for applying hero changes - use newDate if present, otherwise current date from state
+    val date: Date = result.newDate
+      .orElse(startingState.currentDate)
+      .getOrElse(
+        throw new IllegalStateException("No date available for applying action result")
+      )
+
+    // Validate new heroes before applying
+    result.newHeroes.foreach(validate)
+
+    // Apply basic state updates
+    val stateAfterBasics = applyBasicStateUpdates(startingState, result)
+
+    // Apply new provinces with validation
+    val stateAfterNewProvinces = result.newProvinces.foldLeft(stateAfterBasics) { (gs, np) =>
+      validate(np, gs.currentPhase)
+      gs.applyNewProvinces(Vector(np))
+    }
+
+    // Apply changed provinces with validation
+    val stateAfterChangedProvinces = result.changedProvinces.foldLeft(stateAfterNewProvinces) { (gs, cp) =>
+      val after = gs.applyChangedProvinces(Vector(cp))
+      validate(after.provinces(cp.provinceId), gs.currentPhase)
+      after
+    }
+
+    // Apply changed battalions with validation
+    val stateAfterChangedBattalions = stateAfterChangedProvinces.applyChangedBattalions(result.changedBattalions)
+    result.changedBattalions.foreach { cb =>
+      stateAfterChangedBattalions.battalions.get(cb.battalionId).foreach { b =>
+        validate(b, stateAfterChangedBattalions)
+      }
+    }
+
+    // Apply all remaining entity changes using extension methods
+    val finalState = stateAfterChangedBattalions
+      .applyProvinceActed(result.provinceIdActed)
+      .applyLastCommand(result.provinceId, result.lastCommandTypeForActingProvince)
+      .applyNewBattalions(result.newBattalions, result.provinceId)
+      .applyDestroyedBattalionIds(result.destroyedBattalionIds)
+      .applyNewHeroes(result.newHeroes)
+      .applyChangedHeroes(result.changedHeroes, date)
+      .applyRemovedHeroes(result.removedHeroIds.toSet)
+      .applyChangedFactions(result.changedFactions)
+      .applyRemovedFactions(result.removedFactionIds.toSet)
+      .applyNewFactions(result.newFactions)
+      .applyNewBattle(result.newBattle)
+      .applyNewNotifications(result.newNotifications)
+      .applyRemovedNotifications(result.removedNotifications)
+      .applyNewSeed(result.newRandomSeed)
+      .applyChronicleEntry(result.newChronicleEntry)
+      .applyCommandCountUpdate(result.actingFactionId)
+
+    // Validate final game state
+    validate(finalState)
+
+    ActionResultWithResultingState(
+      actionResult = result,
+      resultingState = finalState
+    )
+  }
+
+  private def applyBasicStateUpdates(state: GameState, result: ActionResultT): GameState = {
+    val afterRoundId = result.newRoundId
+      .map(rid => state.copy(currentRoundId = rid))
+      .getOrElse(state)
+
+    val afterPhase = result.newRoundPhase
+      .map(phase => afterRoundId.copy(currentPhase = phase))
+      .getOrElse(afterRoundId)
+
+    val afterDate = result.newDate
+      .map(date => afterPhase.copy(currentDate = Some(date)))
+      .getOrElse(afterPhase)
+
+    val afterRunStatus =
+      if result.gameEnded.contains(true) then afterDate.copy(runStatus = RunStatus.Over)
+      else afterDate
+
+    val afterVictor = result.newVictorFactionId
+      .map(factionId => afterRunStatus.copy(victor = Some(factionId)))
+      .getOrElse(afterRunStatus)
+
+    afterVictor.copy(actionResultCount = afterVictor.actionResultCount + 1)
+  }
+}
@@ -1,35 +1,39 @@
 package net.eagle0.eagle.library.actions.applier

 import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.library.util.validations.Validator
+import net.eagle0.eagle.library.util.validations.ScalaValidator
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.ActionResultProtoConverter
+import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter

 object ActionResultTApplierImpl {
-  def apply(validator: Validator): ActionResultTApplierImpl =
-    new ActionResultTApplierImpl(new ActionResultProtoApplierImpl(validator))
+  /** Creates an ActionResultTApplierImpl with no validation (for tests) */
+  def apply(): ActionResultTApplierImpl =
+    new ActionResultTApplierImpl(new ActionResultApplierImpl(None))

-  def apply(protoApplier: ActionResultProtoApplier): ActionResultTApplierImpl =
-    new ActionResultTApplierImpl(protoApplier)
+  def apply(validator: ScalaValidator): ActionResultTApplierImpl =
+    new ActionResultTApplierImpl(new ActionResultApplierImpl(Some(validator)))
+
+  def apply(baseApplier: ActionResultApplier): ActionResultTApplierImpl =
+    new ActionResultTApplierImpl(baseApplier)
 }

-class ActionResultTApplierImpl(protoApplier: ActionResultProtoApplier) extends ActionResultTApplier {
-  override def xpForStatBump(stat: Int): Int = protoApplier.xpForStatBump(stat)
+class ActionResultTApplierImpl(baseApplier: ActionResultApplier) extends ActionResultTApplier {
+  override def xpForStatBump(stat: Int): Int = baseApplier.xpForStatBump(stat)

  override def applyActionResults(
      startingState: GameState,
      results: Iterable[ActionResultT]
-  ): Vector[ActionResultTWithResultingState] = protoApplier
+  ): Vector[ActionResultTWithResultingState] = baseApplier
    .applyActionResults(
-      startingState,
-      results.map(ActionResultProtoConverter.toProto)
+      GameStateConverter.fromProto(startingState),
+      results
    )
    .zip(results)
    .map {
      case (actionWithResultingState, actionResult) =>
        ActionResultTWithResultingState(
          actionResult = actionResult,
-          resultingState = actionWithResultingState.gameState
+          resultingState = GameStateConverter.toProto(actionWithResultingState.resultingState)
        )
    }

@@ -1,5 +1,211 @@
 load("@rules_scala//scala:scala.bzl", "scala_library")

+scala_library(
+    name = "action_result_applier",
+    srcs = ["ActionResultApplier.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle/library:__pkg__",
+        "//src/test/scala/net/eagle0/eagle/library/actions:__subpackages__",
+    ],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+    ],
+)
+
+scala_library(
+    name = "province_update_helpers",
+    srcs = ["ProvinceUpdateHelpers.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
+        "//src/main/scala/net/eagle0/eagle/library/util/hero:hero_utils",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state:army",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province/concrete",
+    ],
+)
+
+scala_library(
+    name = "province_update_helpers2",
+    srcs = ["ProvinceUpdateHelpers2.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state/quest",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
+    ],
+)
+
+scala_library(
+    name = "game_state_province_extensions",
+    srcs = ["GameStateProvinceExtensions.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        ":province_update_helpers",
+        ":province_update_helpers2",
+        "//src/main/protobuf/net/eagle0/eagle/api:selected_command_scala_proto",
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
+        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/province/concrete",
+    ],
+)
+
+scala_library(
+    name = "game_state_battalion_extensions",
+    srcs = ["GameStateBattalionExtensions.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state:army",
+        "//src/main/scala/net/eagle0/eagle/model/state:combat_unit",
+        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
+        "//src/main/scala/net/eagle0/eagle/model/state/battalion/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province/concrete",
+    ],
+)
+
+scala_library(
+    name = "game_state_hero_extensions",
+    srcs = ["GameStateHeroExtensions.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
+        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state/date",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/hero",
+        "//src/main/scala/net/eagle0/eagle/model/state/hero/backstory_version",
+        "//src/main/scala/net/eagle0/eagle/model/state/hero/concrete",
+    ],
+)
+
+scala_library(
+    name = "game_state_faction_extensions",
+    srcs = ["GameStateFactionExtensions.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_faction_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/view/province:province_view",
+    ],
+)
+
+scala_library(
+    name = "game_state_battle_extensions",
+    srcs = ["GameStateBattleExtensions.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/shardok_battle",
+    ],
+)
+
+scala_library(
+    name = "game_state_misc_extensions",
+    srcs = ["GameStateMiscExtensions.scala"],
+    visibility = ["//visibility:private"],
+    deps = [
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
+        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+    ],
+)
+
+scala_library(
+    name = "game_state_extensions",
+    srcs = ["GameStateExtensions.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle/library/actions:__subpackages__",
+    ],
+    exports = [
+        ":game_state_battalion_extensions",
+        ":game_state_battle_extensions",
+        ":game_state_faction_extensions",
+        ":game_state_hero_extensions",
+        ":game_state_misc_extensions",
+        ":game_state_province_extensions",
+        "//src/main/protobuf/net/eagle0/eagle/api:selected_command_scala_proto",
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+    ],
+    deps = [
+        ":game_state_battalion_extensions",
+        ":game_state_battle_extensions",
+        ":game_state_faction_extensions",
+        ":game_state_hero_extensions",
+        ":game_state_misc_extensions",
+        ":game_state_province_extensions",
+        "//src/main/protobuf/net/eagle0/eagle/api:selected_command_scala_proto",
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/settings:extra_xp_for_stat_bump_over100",
+        "//src/main/scala/net/eagle0/eagle/library/settings:xp_for_stat_bump",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+    ],
+)
+
+scala_library(
+    name = "action_result_applier_impl",
+    srcs = ["ActionResultApplierImpl.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle/library/actions:__subpackages__",
+    ],
+    exports = [
+        ":action_result_applier",
+        ":game_state_extensions",
+    ],
+    deps = [
+        ":action_result_applier",
+        ":game_state_extensions",
+        "//src/main/scala/net/eagle0/eagle/library/util/validations:scala_validator",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
+        "//src/main/scala/net/eagle0/eagle/model/state/date",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/run_status",
+    ],
+)
+
 scala_library(
    name = "action_result_proto_applier",
    srcs = ["ActionResultProtoApplier.scala"],
@@ -9,11 +215,10 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions:__subpackages__",
    ],
    deps = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
        "//src/main/scala/net/eagle0/eagle/library/util/hero:legacy_hero_utils",
-        # "@maven//:com_thesamet_scalapb_lenses_3",
    ],
 )

@@ -27,23 +232,22 @@ scala_library(
    exports = [":action_result_proto_applier"],
    deps = [
        ":action_result_proto_applier",
-        "//src/main/scala/net/eagle0/common:functional_random",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
        "//src/main/protobuf/net/eagle0/eagle/common:profession_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/internal:faction_relationship_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:run_status_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/internal:llm_request_scala_proto",
+        "//src/main/protobuf/net/eagle0/eagle/internal:run_status_scala_proto",
+        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/settings:xp_for_stat_bump",
-        "//src/main/scala/net/eagle0/eagle/library/settings:extra_xp_for_stat_bump_over100",
        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
+        "//src/main/scala/net/eagle0/eagle/library/settings:extra_xp_for_stat_bump_over100",
+        "//src/main/scala/net/eagle0/eagle/library/settings:xp_for_stat_bump",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
-        "//src/main/scala/net/eagle0/eagle/library/util/hero:legacy_hero_utils",
        "//src/main/scala/net/eagle0/eagle/library/util:province_event_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/hero:legacy_hero_utils",
        "//src/main/scala/net/eagle0/eagle/library/util/validations:runtime_validator",
-        # "@maven//:com_thesamet_scalapb_lenses_3",
    ],
 )

@@ -66,7 +270,6 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types/base:action_result_type",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
-        # "@maven//:com_thesamet_scalapb_lenses_3",
    ],
 )

@@ -78,25 +281,28 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions:__subpackages__",
    ],
    exports = [
+        ":action_result_applier",
        ":action_result_trait_applier",
        "//src/main/scala/net/eagle0/eagle/library/util/validations:runtime_validator",
+        "//src/main/scala/net/eagle0/eagle/library/util/validations:scala_validator",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
    deps = [
-        ":action_result_proto_applier_impl",
+        ":action_result_applier",
+        ":action_result_applier_impl",
        ":action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/types/base:action_result_type",
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
+        "//src/main/scala/net/eagle0/eagle/library/util/validations:scala_validator",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/util/validations:runtime_validator",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
-        # "@maven//:com_thesamet_scalapb_lenses_3",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types/base:action_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
 )
@@ -0,0 +1,134 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.action_result.concrete.ChangedBattalionC
+import net.eagle0.eagle.model.action_result.ChangedBattalionT
+import net.eagle0.eagle.model.state.{Army, CombatUnit, MovingArmy}
+import net.eagle0.eagle.model.state.battalion.concrete.BattalionC
+import net.eagle0.eagle.model.state.battalion.BattalionT
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+
+object GameStateBattalionExtensions {
+
+  extension (gameState: GameState) {
+
+    def applyNewBattalions(
+        newBattalions: Vector[BattalionT],
+        provinceId: Option[ProvinceId]
+    ): GameState =
+      if newBattalions.isEmpty then gameState
+      else
+        provinceId.map { pid =>
+          val maxCurrentId         =
+            if gameState.battalions.isEmpty then 0
+            else gameState.battalions.keys.max
+          val newIds               = (maxCurrentId + 1) to (maxCurrentId + newBattalions.size)
+          val newBattalionsWithIds = newIds
+            .zip(newBattalions)
+            .map {
+              case (id, batt) =>
+                id -> assignBattalionId(batt, id)
+            }
+            .toMap
+          val province             = gameState.provinces(pid) match {
+            case p: ProvinceC => p
+            case p            => throw new EagleInternalException(s"Unknown ProvinceT type: ${p.getClass}")
+          }
+          gameState.copy(
+            battalions = gameState.battalions ++ newBattalionsWithIds,
+            provinces = gameState.provinces.updated(
+              pid,
+              province.copy(battalionIds = province.battalionIds ++ newIds)
+            )
+          )
+        }
+          .getOrElse(
+            gameState.copy(
+              battalions = gameState.battalions ++ newBattalions.map(b => b.id -> b)
+            )
+          )
+
+    def applyChangedBattalions(changedBattalions: Vector[ChangedBattalionT]): GameState =
+      if changedBattalions.isEmpty then gameState
+      else {
+        // Partition based on whether the target battalion has size 0
+        val (zero, nonzero) = changedBattalions.partition {
+          case cb: ChangedBattalionC => cb.to.size == 0
+          case _                     => false
+        }
+        val afterDestroyed  = applyDestroyedBattalionIds(zero.map(_.battalionId))
+
+        val updatedBattalions = nonzero.collect {
+          case cb: ChangedBattalionC =>
+            val existingName = afterDestroyed.battalions.get(cb.battalionId).map(_.name)
+            cb.battalionId -> preserveName(cb.to, existingName)
+        }.toMap
+
+        afterDestroyed.copy(
+          battalions = afterDestroyed.battalions ++ updatedBattalions
+        )
+      }
+
+    def applyDestroyedBattalionIds(destroyedBattalionIds: Vector[BattalionId]): GameState =
+      if destroyedBattalionIds.isEmpty then gameState
+      else {
+        val destroyedBattalions = destroyedBattalionIds
+          .filterNot(_ == -1)
+          .flatMap(bid => gameState.battalions.get(bid).map(bid -> _))
+          .toMap
+
+        val updatedProvinces = gameState.provinces.map {
+          case (pid, province) =>
+            province match {
+              case p: ProvinceC =>
+                pid -> p.copy(
+                  battalionIds = p.battalionIds.filterNot(destroyedBattalionIds.contains),
+                  incomingArmies = p.incomingArmies.map(a => movingArmyWithoutBattalions(a, destroyedBattalionIds))
+                )
+              case p            => pid -> p
+            }
+        }
+
+        gameState.copy(
+          battalions = gameState.battalions -- destroyedBattalionIds,
+          destroyedBattalions = gameState.destroyedBattalions ++ destroyedBattalions,
+          provinces = updatedProvinces
+        )
+      }
+  }
+
+  private def assignBattalionId(batt: BattalionT, id: BattalionId): BattalionT = batt match {
+    case b: BattalionC => b.copy(id = id)
+    case b             => throw new EagleInternalException(s"Unknown BattalionT type: ${b.getClass}")
+  }
+
+  private def preserveName(batt: BattalionT, existingName: Option[String]): BattalionT =
+    existingName match {
+      case Some(name) =>
+        batt match {
+          case b: BattalionC => b.copy(name = name)
+          case b             => b
+        }
+      case None       => batt
+    }
+
+  private def movingArmyWithoutBattalions(
+      movingArmy: MovingArmy,
+      removedBattalionIds: Vector[BattalionId]
+  ): MovingArmy = {
+    val newUnits = movingArmy.army.units.map(unitWithRemovedBattalions(_, removedBattalionIds))
+    if newUnits.isEmpty then movingArmy.copy(army = movingArmy.army.copy(units = Vector.empty))
+    else movingArmy.copy(army = movingArmy.army.copy(units = newUnits))
+  }
+
+  private def unitWithRemovedBattalions(
+      u: CombatUnit,
+      removedBattalionIds: Vector[BattalionId]
+  ): CombatUnit =
+    u.battalionId match {
+      case Some(bid) if removedBattalionIds.contains(bid) => u.copy(battalionId = None)
+      case _                                              => u
+    }
+}
@@ -0,0 +1,25 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.shardok_battle.ShardokBattle
+
+object GameStateBattleExtensions {
+
+  extension (gameState: GameState) {
+
+    def applyNewBattle(battle: Option[ShardokBattle]): GameState =
+      battle.map { b =>
+        gameState.copy(
+          outstandingBattles = gameState.outstandingBattles :+ b,
+          battleCounter = gameState.battleCounter.max(b.battleIndex)
+        )
+      }
+        .getOrElse(gameState)
+
+    def applyResolvedBattle(shardokGameId: Option[ShardokGameId]): GameState =
+      gameState.copy(
+        outstandingBattles = gameState.outstandingBattles.filterNot(batt => shardokGameId.contains(batt.shardokGameId))
+      )
+  }
+}
@@ -0,0 +1,17 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.library.settings.{ExtraXpForStatBumpOver100, XpForStatBump}
+export GameStateBattalionExtensions.*
+export GameStateBattleExtensions.*
+export GameStateFactionExtensions.*
+export GameStateHeroExtensions.*
+export GameStateMiscExtensions.*
+// Re-export all extension imports for convenient single import
+export GameStateProvinceExtensions.*
+
+object GameStateExtensions {
+
+  def xpForStatBump(stat: Int): Int =
+    if stat <= 99 then XpForStatBump.intValue
+    else XpForStatBump.intValue + ExtraXpForStatBumpOver100.intValue * (stat - 99)
+}
@@ -0,0 +1,149 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.action_result.concrete.ChangedFactionC
+import net.eagle0.eagle.model.action_result.ChangedFactionT
+import net.eagle0.eagle.model.state.faction.concrete.FactionC
+import net.eagle0.eagle.model.state.faction.FactionRelationship
+import net.eagle0.eagle.model.state.faction.FactionT
+import net.eagle0.eagle.model.state.faction.FactionT.OutgoingOfferRound
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.view.province.ProvinceView
+
+object GameStateFactionExtensions {
+
+  private val trustMax: Int = 100
+
+  extension (gameState: GameState) {
+
+    def applyChangedFactions(changedFactions: Vector[ChangedFactionT]): GameState =
+      if changedFactions.isEmpty then gameState
+      else
+        changedFactions.foldLeft(gameState) {
+          case (gs, cf) =>
+            gs.applyChangedFaction(cf)
+        }
+
+    def applyChangedFaction(cf: ChangedFactionT): GameState = cf match {
+      case cfc: ChangedFactionC => applyChangedFactionC(cfc)
+      case _                    => throw new EagleInternalException(s"Unknown ChangedFactionT type: ${cf.getClass}")
+    }
+
+    private def applyChangedFactionC(cf: ChangedFactionC): GameState =
+      if !gameState.factions.contains(cf.factionId) then gameState
+      else {
+        val existingFaction = gameState.factions(cf.factionId) match {
+          case f: FactionC => f
+          case f           => throw new EagleInternalException(s"Unknown FactionT type: ${f.getClass}")
+        }
+
+        val newFocusProvinceId =
+          if cf.clearFocusProvinceId then None
+          else cf.newFocusProvinceId.orElse(existingFaction.focusProvinceId)
+
+        val newLastActedProvinceIdThisRound =
+          if cf.clearLastActedProvinceId then 0
+          else cf.newLastActedProvinceId.getOrElse(existingFaction.lastActedProvinceIdThisRound)
+
+        // Update relationships with trust level changes
+        val relationshipsAfterChanges = cf.changedFactionRelationships
+          .foldLeft(
+            existingFaction.factionRelationships
+              .filterNot(fr =>
+                cf.changedFactionRelationships.map(_.targetFactionId).contains(fr.targetFactionId) ||
+                  cf.removedFactionRelationshipFactionIds.contains(fr.targetFactionId)
+              ) ++ cf.changedFactionRelationships
+          ) { (relationships, _) =>
+            relationships
+          }
+
+        // Apply trust level updates
+        val relationshipsAfterTrust = cf.trustLevelUpdates.foldLeft(relationshipsAfterChanges) {
+          case (relationships, update) =>
+            val existingRelationship = relationships
+              .find(_.targetFactionId == update.targetFactionId)
+              .getOrElse(
+                FactionRelationship(
+                  targetFactionId = update.targetFactionId,
+                  relationshipLevel = FactionRelationship.RelationshipLevel.Hostile,
+                  trustValue = 0
+                )
+              )
+            val newValue             = Math.min(trustMax, update.delta + existingRelationship.trustValue)
+            relationships.filterNot(_.targetFactionId == update.targetFactionId) :+
+              existingRelationship.copy(trustValue = newValue)
+        }
+
+        // Update reconned provinces
+        val newReconnedProvinces = existingFaction.reconnedProvinces
+          .filterNot(pv =>
+            cf.updatedReconnedProvinces.map(_.id).contains(pv.id) ||
+              cf.removedReconnedProvinceIds.contains(pv.id)
+          ) ++ cf.updatedReconnedProvinces
+
+        // Update outgoing offer rounds
+        val newLastOutgoingTruceOfferRounds = existingFaction.lastOutgoingTruceOfferRounds
+          .filterNot(oor => cf.newOutgoingTruceOfferFactionIds.map(_.fid).contains(oor.toFactionId)) ++
+          cf.newOutgoingTruceOfferFactionIds.map(wrapper =>
+            OutgoingOfferRound(toFactionId = wrapper.fid, roundId = gameState.currentRoundId)
+          )
+
+        val newLastOutgoingAllianceOfferRounds = existingFaction.lastOutgoingAllianceOfferRounds
+          .filterNot(oor => cf.newOutgoingAllianceOfferFactionIds.map(_.fid).contains(oor.toFactionId)) ++
+          cf.newOutgoingAllianceOfferFactionIds.map(wrapper =>
+            OutgoingOfferRound(toFactionId = wrapper.fid, roundId = gameState.currentRoundId)
+          )
+
+        val newLastOutgoingInvitationRounds = existingFaction.lastOutgoingInvitationRounds
+          .filterNot(oor => cf.newOutgoingInvitationFactionIds.map(_.fid).contains(oor.toFactionId)) ++
+          cf.newOutgoingInvitationFactionIds.map(wrapper =>
+            OutgoingOfferRound(toFactionId = wrapper.fid, roundId = gameState.currentRoundId)
+          )
+
+        val newLastOutgoingRansomOfferRounds = existingFaction.lastOutgoingRansomOfferRounds
+          .filterNot(oor => cf.newOutgoingRansomOfferFactionIds.map(_.fid).contains(oor.toFactionId)) ++
+          cf.newOutgoingRansomOfferFactionIds.map(wrapper =>
+            OutgoingOfferRound(toFactionId = wrapper.fid, roundId = gameState.currentRoundId)
+          )
+
+        val updatedFaction = existingFaction.copy(
+          factionHeadId = cf.newFactionHeadHeroId.getOrElse(existingFaction.factionHeadId),
+          leaderIds = existingFaction.leaderIds.diff(cf.removedLeaderHeroIds) ++ cf.newLeaderHeroIds,
+          prestigeModifiers =
+            existingFaction.prestigeModifiers.diff(cf.removedPrestigeModifiers) ++ cf.newPrestigeModifiers,
+          factionRelationships = relationshipsAfterTrust,
+          incomingDiplomacyOffers = existingFaction.incomingDiplomacyOffers
+            .filterNot(offer => cf.removedIncomingDiplomacyOfferFactionIds.contains(offer.originatingFactionId)) ++
+            cf.newIncomingDiplomacyOffers,
+          focusProvinceId = newFocusProvinceId,
+          reconnedProvinces = newReconnedProvinces,
+          lastActedProvinceIdThisRound = newLastActedProvinceIdThisRound,
+          lastOutgoingTruceOfferRounds = newLastOutgoingTruceOfferRounds,
+          lastOutgoingAllianceOfferRounds = newLastOutgoingAllianceOfferRounds,
+          lastOutgoingInvitationRounds = newLastOutgoingInvitationRounds,
+          lastOutgoingRansomOfferRounds = newLastOutgoingRansomOfferRounds
+        )
+
+        gameState.copy(
+          factions = gameState.factions.updated(cf.factionId, updatedFaction)
+        )
+      }
+
+    def applyRemovedFactions(removedFactionIds: Set[FactionId]): GameState = {
+      val (removed, remaining) = gameState.factions.partition {
+        case (fid, _) =>
+          removedFactionIds.contains(fid)
+      }
+      gameState.copy(
+        destroyedFactions = gameState.destroyedFactions ++ removed,
+        factions = remaining
+      )
+    }
+
+    def applyNewFactions(newFactions: Vector[FactionT]): GameState =
+      gameState.copy(
+        factions = gameState.factions ++ newFactions.map(f => f.id -> f)
+      )
+  }
+}
@@ -0,0 +1,134 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.library.util.EagleRequire.internalRequire
+import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.action_result.concrete.{ChangedHeroC, StatAbsolute, StatDelta, StatNoChange}
+import net.eagle0.eagle.model.action_result.ChangedHeroT
+import net.eagle0.eagle.model.state.date.Date
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.hero.backstory_version.BackstoryVersion
+import net.eagle0.eagle.model.state.hero.concrete.HeroC
+import net.eagle0.eagle.model.state.hero.HeroT
+
+object GameStateHeroExtensions {
+
+  extension (gameState: GameState) {
+
+    def applyNewHeroes(newHeroes: Vector[HeroT]): GameState =
+      if newHeroes.isEmpty then gameState
+      else {
+        newHeroes.foreach(h =>
+          internalRequire(
+            !gameState.heroes.contains(h.id),
+            s"Got a new hero update for existing hero ${h.id}"
+          )
+        )
+        gameState.copy(
+          heroes = gameState.heroes ++ newHeroes.map(h => h.id -> h)
+        )
+      }
+
+    def applyChangedHeroes(changedHeroes: Vector[ChangedHeroT], date: Date): GameState =
+      if changedHeroes.isEmpty then gameState
+      else
+        changedHeroes.foldLeft(gameState) {
+          case (gs, ch) =>
+            gs.applyChangedHero(ch, date)
+        }
+
+    def applyChangedHero(ch: ChangedHeroT, date: Date): GameState = ch match {
+      case chc: ChangedHeroC => applyChangedHeroC(chc, date)
+      case _                 => throw new EagleInternalException(s"Unknown ChangedHeroT type: ${ch.getClass}")
+    }
+
+    private def applyChangedHeroC(ch: ChangedHeroC, date: Date): GameState = {
+      val existingHero = gameState.heroes(ch.heroId) match {
+        case h: HeroC => h
+        case h        => throw new EagleInternalException(s"Unknown HeroT type: ${h.getClass}")
+      }
+
+      val newFactionId = ch.newFactionId.orElse(
+        if ch.clearFactionId then None else existingHero.factionId
+      )
+
+      val newRoundIdJoined =
+        if ch.newFactionId.isDefined then Some(gameState.currentRoundId)
+        else if ch.clearFactionId then None
+        else existingHero.roundIdJoined
+
+      val newVigor = ch.vigorChange match {
+        case StatDelta(d)     =>
+          (existingHero.vigor + d).max(0.0).min(existingHero.constitution)
+        case StatAbsolute(va) =>
+          internalRequire(va >= 0, s"Got a negative new vigor of $va")
+          internalRequire(
+            va <= existingHero.constitution,
+            s"Got a new vigor of $va with ${existingHero.constitution} constitution"
+          )
+          va
+        case StatNoChange     => existingHero.vigor
+      }
+
+      val newLoyalty = ch.loyaltyChange match {
+        case StatDelta(ld)    =>
+          Math.min(100.0, Math.max(0, existingHero.loyalty + ld))
+        case StatAbsolute(la) =>
+          internalRequire(la >= 0, s"Got a negative absolute loyalty of $la")
+          internalRequire(la <= 100.0, s"Got an absolute loyalty of $la")
+          la
+        case StatNoChange     => existingHero.loyalty
+      }
+
+      val newBackstoryVersions = existingHero.backstoryVersions ++ ch.newBackstoryTextId.map { textId =>
+        BackstoryVersion(textId = textId, date = date)
+      }
+
+      val newBackstoryEvents =
+        if ch.clearEventsForHeroBackstory then Vector.empty
+        else existingHero.backstoryEvents ++ ch.newEventsForHeroBackstory
+
+      val updatedHero = existingHero.copy(
+        factionId = newFactionId,
+        roundIdJoined = newRoundIdJoined,
+        vigor = newVigor,
+        loyalty = newLoyalty,
+        strengthXp = existingHero.strengthXp + ch.strengthXpDelta.getOrElse(0),
+        agilityXp = existingHero.agilityXp + ch.agilityXpDelta.getOrElse(0),
+        wisdomXp = existingHero.wisdomXp + ch.wisdomXpDelta.getOrElse(0),
+        charismaXp = existingHero.charismaXp + ch.charismaXpDelta.getOrElse(0),
+        constitutionXp = existingHero.constitutionXp + ch.constitutionXpDelta.getOrElse(0),
+        strength = existingHero.strength + ch.strengthDelta.getOrElse(0),
+        agility = existingHero.agility + ch.agilityDelta.getOrElse(0),
+        wisdom = existingHero.wisdom + ch.wisdomDelta.getOrElse(0),
+        charisma = existingHero.charisma + ch.charismaDelta.getOrElse(0),
+        constitution = existingHero.constitution + ch.constitutionDelta.getOrElse(0),
+        profession = ch.newProfession.getOrElse(existingHero.profession),
+        backstoryVersions = newBackstoryVersions,
+        backstoryEvents = newBackstoryEvents
+      )
+
+      gameState.copy(
+        heroes = gameState.heroes.updated(ch.heroId, updatedHero)
+      )
+    }
+
+    def applyRemovedHeroes(removedHeroIds: Set[HeroId]): GameState = {
+      val (removed, remaining) = gameState.heroes.partition {
+        case (k, _) =>
+          removedHeroIds.contains(k)
+      }
+      val killedHeroes         = removed.map {
+        case (hid, hero) =>
+          hero match {
+            case h: HeroC => hid -> h.copy(factionId = None)
+            case h        => hid -> h
+          }
+      }
+      gameState.copy(
+        killedHeroes = gameState.killedHeroes ++ killedHeroes,
+        heroes = remaining
+      )
+    }
+  }
+}
@@ -0,0 +1,54 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.model.action_result.NotificationT
+import net.eagle0.eagle.model.state.chronicle_entry.ChronicleEntry
+import net.eagle0.eagle.model.state.game_state.GameState
+
+object GameStateMiscExtensions {
+
+  extension (gameState: GameState) {
+
+    def applyAccumulatedDetails(notification: Option[NotificationT]): GameState =
+      notification
+        .map(note => gameState.copy(deferredNotifications = gameState.deferredNotifications :+ note))
+        .getOrElse(gameState)
+
+    def applyNewNotifications(notifications: Vector[NotificationT]): GameState =
+      if notifications.isEmpty then gameState
+      else {
+        // Only add deferred notifications to the deferred list.
+        // Non-deferred notifications are for immediate delivery and don't affect game state.
+        val deferredOnly = notifications.filter(_.deferred)
+        if deferredOnly.isEmpty then gameState
+        else gameState.copy(deferredNotifications = gameState.deferredNotifications ++ deferredOnly)
+      }
+
+    def applyRemovedNotifications(notifications: Vector[NotificationT]): GameState =
+      gameState.copy(
+        deferredNotifications = gameState.deferredNotifications.diff(notifications)
+      )
+
+    def applyNewSeed(newSeed: Option[Long]): GameState =
+      newSeed.map(s => gameState.copy(randomSeed = s)).getOrElse(gameState)
+
+    def applyChronicleEntry(chronicleEntry: Option[ChronicleEntry]): GameState =
+      chronicleEntry.map { ce =>
+        val updatedEntries = gameState.chronicleEntries.indexWhere(_.date == ce.date) match {
+          case -1  => gameState.chronicleEntries :+ ce
+          case idx => gameState.chronicleEntries.updated(idx, ce)
+        }
+        gameState.copy(chronicleEntries = updatedEntries)
+      }
+        .getOrElse(gameState)
+
+    def applyCommandCountUpdate(actingFactionId: Option[FactionId]): GameState =
+      actingFactionId.map { factionId =>
+        val existingCount = gameState.factionCommandCounts.getOrElse(factionId, 0)
+        gameState.copy(
+          factionCommandCounts = gameState.factionCommandCounts.updated(factionId, existingCount + 1)
+        )
+      }
+        .getOrElse(gameState)
+  }
+}
@@ -0,0 +1,97 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.api.selected_command.SelectedCommand
+import net.eagle0.eagle.library.util.EagleRequire.internalRequire
+import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
+import net.eagle0.eagle.model.action_result.changed_province.ChangedProvinceT
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.province.ProvinceT
+
+object GameStateProvinceExtensions {
+
+  extension (gameState: GameState) {
+
+    def applyNewProvinces(newProvinces: Vector[ProvinceT]): GameState =
+      if newProvinces.isEmpty then gameState
+      else {
+        newProvinces.foreach(p =>
+          internalRequire(
+            !gameState.provinces.contains(p.id),
+            s"Got a new province update for existing province ${p.id}"
+          )
+        )
+        gameState.copy(
+          provinces = gameState.provinces ++ newProvinces.map(p => p.id -> p)
+        )
+      }
+
+    def applyChangedProvinces(changedProvinces: Vector[ChangedProvinceT]): GameState =
+      if changedProvinces.isEmpty then gameState
+      else
+        changedProvinces.foldLeft(gameState) {
+          case (gs, cp) =>
+            gs.applyChangedProvince(cp)
+        }
+
+    def applyChangedProvince(cp: ChangedProvinceT): GameState = cp match {
+      case cpc: ChangedProvinceC => applyChangedProvinceC(cpc)
+      case _                     =>
+        throw new EagleInternalException(s"Unknown ChangedProvinceT type: ${cp.getClass}")
+    }
+
+    private def applyChangedProvinceC(cp: ChangedProvinceC): GameState = {
+      val provinceBefore = gameState.provinces(cp.provinceId) match {
+        case p: ProvinceC => p
+        case p            => throw new EagleInternalException(s"Unknown ProvinceT type: ${p.getClass}")
+      }
+
+      val factionLeaderIds = gameState.factions.values.flatMap(_.leaderIds).toVector
+
+      // Use helper files to avoid compiler crash
+      val p1 = ProvinceUpdateHelpers.applyRulingAndBattalions(gameState, provinceBefore, cp, factionLeaderIds)
+      val p2 = ProvinceUpdateHelpers.applyArmiesAndResources(p1, cp)
+      val p3 = ProvinceUpdateHelpers2.applyHeroesAndEvents(p2, cp)
+      val provinceApplied = ProvinceUpdateHelpers2.applyMiscFields(gameState, p3, cp)
+
+      val provinceFixedForRuler = ProvinceUpdateHelpers2.fixRulerIfNeeded(gameState, provinceApplied)
+
+      gameState.copy(
+        provinces = gameState.provinces.updated(cp.provinceId, provinceFixedForRuler)
+      )
+    }
+
+    def applyProvinceActed(actedProvince: Option[ProvinceId]): GameState = {
+      internalRequire(!actedProvince.contains(0), "Province acted has id 0")
+      actedProvince.map { id =>
+        val province = gameState.provinces(id) match {
+          case p: ProvinceC => p
+          case p            => throw new EagleInternalException(s"Unknown ProvinceT type: ${p.getClass}")
+        }
+        gameState.copy(
+          provinces = gameState.provinces.updated(id, province.copy(hasActed = true))
+        )
+      }
+        .getOrElse(gameState)
+    }
+
+    def applyLastCommand(
+        provinceId: Option[ProvinceId],
+        lastCommand: Option[SelectedCommand]
+    ): GameState =
+      provinceId
+        .filter(_ => lastCommand.exists(!_.isEmpty))
+        .map { pid =>
+          val province = gameState.provinces(pid) match {
+            case p: ProvinceC => p
+            case p            => throw new EagleInternalException(s"Unknown ProvinceT type: ${p.getClass}")
+          }
+          gameState.copy(
+            provinces = gameState.provinces.updated(pid, province.copy(lastCommand = lastCommand))
+          )
+        }
+        .getOrElse(gameState)
+  }
+}
@@ -0,0 +1,122 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.*
+import net.eagle0.eagle.library.util.hero.HeroUtils
+import net.eagle0.eagle.library.util.EagleRequire.internalRequire
+import net.eagle0.eagle.model.action_result.changed_province.concrete.{ChangedProvinceC, HostileArmyStatusChange}
+import net.eagle0.eagle.model.state.{HostileArmyGroup, MovingArmy}
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+
+// Helper object 1 for province updates - split to avoid compiler crash
+object ProvinceUpdateHelpers {
+
+  def applyRulingAndBattalions(
+      gameState: GameState,
+      p: ProvinceC,
+      cp: ChangedProvinceC,
+      factionLeaderIds: Vector[HeroId]
+  ): ProvinceC =
+    p.copy(
+      rulingFactionId =
+        if cp.clearRulingFactionId then None
+        else cp.newRulingFactionId.orElse(p.rulingFactionId),
+      rulingFactionHeroIds = (p.rulingFactionHeroIds
+        .diff(cp.removedRulingFactionHeroIds) ++ cp.newRulingFactionHeroIds)
+        .map(hid => gameState.heroes(hid))
+        .sorted(using HeroUtils.sortOrdering(factionLeaderIds))
+        .map(_.id),
+      battalionIds = p.battalionIds.diff(cp.removedBattalionIds) ++ cp.newBattalionIds,
+      incomingArmies = modifyArmySet(
+        existingArmies = p.incomingArmies,
+        removedIds = cp.removedIncomingArmyIds,
+        addedArmies = cp.newIncomingArmies
+      ),
+      hostileArmies = modifyArmyGroupSet(
+        existingGroups = p.hostileArmies,
+        removedFactionIds = cp.removedHostileArmyFactionIds,
+        addedArmies = cp.newHostileArmies,
+        statusChanges = cp.hostileArmyStatusChanges
+      )
+    )
+
+  def applyArmiesAndResources(
+      p: ProvinceC,
+      cp: ChangedProvinceC
+  ): ProvinceC = {
+    val incomingShipments = {
+      val holdovers = p.incomingShipments
+        .filterNot(sh => cp.removedIncomingShipmentIds.contains(sh.id))
+      val nextId    = holdovers.map(_.id).maxOption.getOrElse(0) + 1
+      holdovers ++ cp.newIncomingShipments.zipWithIndex.map {
+        case (ship, index) =>
+          ship.copy(id = index + nextId)
+      }
+    }
+
+    val defendingArmy =
+      if cp.clearDefendingArmy then None
+      else
+        cp.newDefendingArmy.orElse(
+          p.defendingArmy.map { da =>
+            val newUnits = da.units
+              .filterNot(u => cp.removedRulingFactionHeroIds.contains(u.heroId))
+              .map { u =>
+                u.copy(battalionId = u.battalionId.filterNot(cp.removedBattalionIds.contains))
+              }
+            da.copy(units = newUnits)
+          }
+        )
+
+    val newGold = p.gold + cp.goldDelta.getOrElse(0)
+    internalRequire(newGold >= 0, s"Got a goldDelta of ${cp.goldDelta} but only ${p.gold} available")
+
+    val newFood = p.food + cp.foodDelta.getOrElse(0)
+    internalRequire(newFood >= 0, s"Got a foodDelta of ${cp.foodDelta} but only ${p.food} available")
+
+    p.copy(
+      incomingShipments = incomingShipments,
+      defendingArmy = defendingArmy,
+      gold = newGold,
+      food = newFood,
+      priceIndex = cp.newPriceIndex.getOrElse(p.priceIndex),
+      economy = (p.economy + cp.economyDelta.getOrElse(0.0)).max(0.0).min(100.0),
+      agriculture = (p.agriculture + cp.agricultureDelta.getOrElse(0.0)).max(0.0).min(100.0),
+      infrastructure = (p.infrastructure + cp.infrastructureDelta.getOrElse(0.0)).max(0.0).min(100.0),
+      economyDevastation = (p.economyDevastation + cp.economyDevastationDelta.getOrElse(0.0)).max(0.0).min(p.economy),
+      agricultureDevastation =
+        (p.agricultureDevastation + cp.agricultureDevastationDelta.getOrElse(0.0)).max(0.0).min(p.agriculture),
+      infrastructureDevastation =
+        (p.infrastructureDevastation + cp.infrastructureDevastationDelta.getOrElse(0.0)).max(0.0).min(p.infrastructure),
+      support = (p.support + cp.supportDelta.getOrElse(0.0)).max(0.0).min(100.0)
+    )
+  }
+
+  private def modifyArmySet(
+      existingArmies: Vector[MovingArmy],
+      removedIds: Vector[Int],
+      addedArmies: Vector[MovingArmy]
+  ): Vector[MovingArmy] = {
+    val holdovers = existingArmies.filterNot(ma => removedIds.contains(ma.id))
+    val nextId    = holdovers.map(_.id).maxOption.getOrElse(0) + 1
+    holdovers ++ addedArmies.zipWithIndex.map {
+      case (army, index) =>
+        army.copy(id = index + nextId)
+    }
+  }
+
+  private def modifyArmyGroupSet(
+      existingGroups: Vector[HostileArmyGroup],
+      removedFactionIds: Vector[FactionId],
+      addedArmies: Vector[HostileArmyGroup],
+      statusChanges: Vector[HostileArmyStatusChange]
+  ): Vector[HostileArmyGroup] =
+    statusChanges
+      .foldLeft(existingGroups.filterNot(g => removedFactionIds.contains(g.factionId))) {
+        case (groups, HostileArmyStatusChange(factionId, newStatus)) =>
+          groups.indexWhere(_.factionId == factionId) match {
+            case -1    => groups
+            case index => groups.updated(index, groups(index).copy(status = newStatus))
+          }
+      } ++ addedArmies
+}
@@ -0,0 +1,103 @@
+package net.eagle0.eagle.library.actions.applier
+
+import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.{BeastsEvent, ImminentRiotEvent, ProvinceOrderType}
+import net.eagle0.eagle.model.state.province.concrete.ProvinceC
+import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
+import net.eagle0.eagle.model.state.RoundPhase
+
+// Helper object 2 for province updates - split to avoid compiler crash
+object ProvinceUpdateHelpers2 {
+
+  def applyHeroesAndEvents(
+      p: ProvinceC,
+      cp: ChangedProvinceC
+  ): ProvinceC = {
+    val unaffiliatedHeroes =
+      p.unaffiliatedHeroes
+        .filterNot(uh => cp.removedUnaffiliatedHeroIds.contains(uh.heroId))
+        .filterNot(uh => cp.changedUnaffiliatedHeroes.map(_.heroId).contains(uh.heroId))
+        ++ cp.changedUnaffiliatedHeroes ++ cp.newUnaffiliatedHeroes
+
+    val capturedHeroes =
+      p.capturedHeroes
+        .filterNot(ch => cp.removedCapturedHeroIds.contains(ch.heroId))
+        .map(ch =>
+          if cp.recruitmentAtteptedCapturedHeroIds.contains(ch.heroId)
+          then ch.copy(recruitmentAttempted = true)
+          else ch
+        ) ++ cp.newCapturedHeroes
+
+    val lockedImprovementType = cp.newLockedImprovementType match {
+      case Some(net.eagle0.eagle.model.action_result.changed_province.concrete.NewLockedImprovementType.None)   =>
+        None
+      case Some(net.eagle0.eagle.model.action_result.changed_province.concrete.NewLockedImprovementType.New(v)) =>
+        Some(v)
+      case None => p.lockedImprovementType
+    }
+
+    p.copy(
+      hasActed = cp.setHasActed.getOrElse(p.hasActed),
+      rulerIsTraveling = cp.setRulerIsTraveling.getOrElse(p.rulerIsTraveling),
+      unaffiliatedHeroes = unaffiliatedHeroes,
+      capturedHeroes = capturedHeroes,
+      provinceOrders = cp.newProvinceOrders.getOrElse(p.provinceOrders),
+      activeEvents = cp.newProvinceEvents.getOrElse(p.activeEvents),
+      lockedImprovementType = lockedImprovementType
+    )
+  }
+
+  def applyMiscFields(
+      gameState: GameState,
+      p: ProvinceC,
+      cp: ChangedProvinceC
+  ): ProvinceC =
+    p.copy(
+      lastBeastsDate =
+        if cp.newProvinceEvents.exists(_.exists(_.isInstanceOf[BeastsEvent]))
+        then gameState.currentDate
+        else p.lastBeastsDate,
+      lastRiotDate =
+        if cp.newProvinceEvents.exists(_.exists(_.isInstanceOf[ImminentRiotEvent]))
+        then gameState.currentDate
+        else p.lastRiotDate,
+      incomingEndTurnActions = (p.incomingEndTurnActions ++ cp.newIncomingEndTurnActions)
+        .diff(cp.removedIncomingEndTurnActions),
+      deferredChanges = cp.removedDeferredChangeIndex
+        .map(idx => p.deferredChanges.patch(idx, Nil, 1))
+        .getOrElse(p.deferredChanges) ++ cp.newDeferredChange.toVector,
+      battleRevelations = p.battleRevelations.diff(cp.removedBattleRevelations) ++ cp.newBattleRevelations
+    )
+
+  def fixRulerIfNeeded(gameState: GameState, p: ProvinceC): ProvinceC =
+    if gameState.currentPhase != RoundPhase.PlayerCommands &&
+      (p.rulingFactionId.isEmpty || p.rulingFactionHeroIds.isEmpty)
+    then
+      p.copy(
+        rulingFactionId = None,
+        rulingHeroId = None,
+        rulingFactionHeroIds = Vector.empty,
+        support = 0,
+        provinceOrders = ProvinceOrderType.UnknownOrderType,
+        unaffiliatedHeroes = p.unaffiliatedHeroes.map(uh =>
+          uh.copy(
+            recruitmentInfo = uh.unaffiliatedHeroType match {
+              case UnaffiliatedHeroType.Prisoner          => RecruitmentInfo.Prisoner
+              case UnaffiliatedHeroType.MovingPrisoner    => RecruitmentInfo.MovingPrisoner
+              case UnaffiliatedHeroType.ReturningPrisoner => RecruitmentInfo.NoRulerInProvince
+              case UnaffiliatedHeroType.Outlaw            => RecruitmentInfo.Outlaw
+              case UnaffiliatedHeroType.Traveler          => RecruitmentInfo.Traveler
+              case UnaffiliatedHeroType.Resident          => RecruitmentInfo.NoRulerInProvince
+              case UnaffiliatedHeroType.Unknown           =>
+                throw new EagleInternalException("Unknown unaffiliated hero type")
+            }
+          )
+        )
+      )
+    else
+      p.copy(
+        rulingHeroId = p.rulingFactionHeroIds.headOption
+      )
+}
@@ -24,6 +24,7 @@ import net.eagle0.eagle.library.actions.impl.command.AvailableCommandTypeMap
 import net.eagle0.eagle.library.util.faction_utils.LegacyFactionUtils
 import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
 import net.eagle0.eagle.library.util.IncomingArmyUtils
+import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter

 object AvailableCommandsFactory {
  def shouldFollow(
@@ -492,7 +493,7 @@ class AvailableCommandsFactory(
      for {
        faction                     <- gs.factions.get(fid)
        pleaseRecruitMeCommand      <- AvailablePleaseRecruitMeCommandFactory
-                                         .availableCommand(gs, faction.id)
+                                         .availableCommand(GameStateConverter.fromProto(gs), faction.id)
        oneProvinceAvailableCommand <- optionalOneProvinceAvailableCommands(
                                         gs = gs,
                                         0,
@@ -1,22 +1,26 @@
 package net.eagle0.eagle.library.actions.availability

 import net.eagle0.eagle.api.available_command.{OneProvincePleaseRecruitMe, PleaseRecruitMeAvailableCommand}
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.internal.province.Province
 import net.eagle0.eagle.library.settings.MinSupportForTaxes
-import net.eagle0.eagle.library.util.unaffiliated_hero.LegacyUnaffiliatedHeroUtils
+import net.eagle0.eagle.library.util.unaffiliated_hero.UnaffiliatedHeroUtils
+import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
+import net.eagle0.eagle.model.proto_converters.UnaffiliatedHeroConverter
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.FactionId

 object AvailablePleaseRecruitMeCommandFactory {

  private def forOneProvince(
-      p: Province,
+      p: ProvinceT,
      fid: FactionId,
      gs: GameState
  ): Option[OneProvincePleaseRecruitMe] = {
+    // Convert to proto only for ExpandedUnaffiliatedHeroUtils which still requires proto types
+    val gsProto         = GameStateConverter.toProto(gs)
    val availableHeroes = for {
      targetUH <- p.unaffiliatedHeroes.filter(uh =>
-                    LegacyUnaffiliatedHeroUtils.willPleaseRecruitMe(
+                    UnaffiliatedHeroUtils.willPleaseRecruitMe(
                      gameState = gs,
                      factionId = fid,
                      unaffiliatedHero = uh
@@ -26,8 +30,8 @@ object AvailablePleaseRecruitMeCommandFactory {
      // FIXME: We should be generating the LLM request and its textID here instead of earlier in the round
      ExpandedUnaffiliatedHeroUtils
        .expandedUnaffiliatedHero(
-          gs = gs,
-          uh = targetUH
+          gs = gsProto,
+          uh = UnaffiliatedHeroConverter.toProto(targetUH)
        )

    Option.when(availableHeroes.nonEmpty)(
@@ -63,6 +63,8 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/util:incoming_army_utils",
        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils:legacy_faction_utils",
        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
 )

@@ -499,7 +501,13 @@ scala_library(
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library/settings:min_support_for_taxes",
-        "//src/main/scala/net/eagle0/eagle/library/util/unaffiliated_hero:legacy_unaffiliated_hero_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/unaffiliated_hero",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:unaffiliated_hero_converter",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/quest",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
    ],
 )

@@ -172,32 +172,26 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_proto_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
    ],
    deps = [
        ":check_for_faction_changes_action",
        ":hero_backstory_update_action_generator",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:battle_revelation_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier_impl",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_proto_sequencer",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/actions/llm_request_generators/captured_hero_helpers:captured_hero_plea_generator",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/settings:faction_bias_against_former_on_exile",
        "//src/main/scala/net/eagle0/eagle/library/settings:faction_bias_from_exile",
        "//src/main/scala/net/eagle0/eagle/library/settings:faction_bias_from_imprisonment",
        "//src/main/scala/net/eagle0/eagle/library/settings:truce_months_from_returning_leader",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util/unaffiliated_hero:legacy_unaffiliated_hero_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/unaffiliated_hero",
        "//src/main/scala/net/eagle0/eagle/library/util/view_filters:province_view_filter",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
@@ -213,21 +207,18 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:captured_hero_resolved_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_aftermath_phase_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battle_revelation_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:notification_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:unaffiliated_hero_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/llm_request",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:battle_revelation",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction:faction_relationship",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/hero",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
+        "//src/main/scala/net/eagle0/eagle/model/state/province:deferred_change_trait",
        "//src/main/scala/net/eagle0/eagle/model/state/quest",
        "//src/main/scala/net/eagle0/eagle/model/state/quest/concrete",
        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero/concrete",
    ],
 )

@@ -280,21 +271,15 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_simple_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_simple_action",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_battle_request_phase_result_type",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
 )

@@ -332,6 +317,7 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
@@ -340,20 +326,17 @@ scala_library(
        ":check_for_faction_changes_action",
        ":hero_backstory_update_action",
        ":hero_backstory_update_action_generator",
-        "//src/main/protobuf/net/eagle0/eagle/common:diplomacy_offer_status_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action/diplomacy_helpers:alliance_resolution_helpers",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action/diplomacy_helpers:break_alliance_resolution_helpers",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action/diplomacy_helpers:invitation_resolution_helpers",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action/diplomacy_helpers:ransom_resolution_helpers",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/action/diplomacy_helpers:truce_resolution_helpers",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils",
        "//src/main/scala/net/eagle0/eagle/library/util/quest_fulfillment:quest_fulfillment_utils",
        "//src/main/scala/net/eagle0/eagle/library/util/ransom_validity",
@@ -366,20 +349,17 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_faction_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_diplomacy_resolution_phase_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:ransom_invalidated_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:notification_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
+        "//src/main/scala/net/eagle0/eagle/model/state/diplomacy_offer",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/hero",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
+        "//src/main/scala/net/eagle0/eagle/model/state/hero/backstory_version",
        "//src/main/scala/net/eagle0/eagle/model/state/province",
        "//src/main/scala/net/eagle0/eagle/model/state/quest",
        "//src/main/scala/net/eagle0/eagle/model/state/quest/concrete",
@@ -402,21 +382,15 @@ scala_library(
    deps = [
        ":check_for_faction_changes_action",
        ":hero_backstory_update_action_generator",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library:eagle_internal_exception",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:vigor_xp_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/settings:prisoner_escape_chance",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
-        "//src/main/scala/net/eagle0/eagle/library/util:province_event_utils",
        "//src/main/scala/net/eagle0/eagle/library/util/province",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
@@ -434,18 +408,11 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:prisoner_escaped_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:prisoner_move_took_effect_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:weather_took_effect_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:notification_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:unaffiliated_hero_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province:event",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
-        "//src/main/scala/net/eagle0/eagle/model/state/hero",
-        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province:deferred_change_trait",
+        "//src/main/scala/net/eagle0/eagle/model/state/province:event",
        "//src/main/scala/net/eagle0/eagle/model/state/quest",
-        "//src/main/scala/net/eagle0/eagle/model/state/quest/concrete",
        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
    ],
 )
@@ -461,22 +428,15 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_simple_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_simple_action",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_defense_decision_phase_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:army_converter",
        "//src/main/scala/net/eagle0/eagle/model/state:army",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
 )

@@ -494,28 +454,13 @@ scala_library(
    ],
    deps = [
        ":withdrawn_army_returns_home_action",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_free_for_all_decision_phase_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
-        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
-        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
 )

@@ -529,36 +474,29 @@ scala_library(
    exports = [
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        "//src/main/protobuf/net/eagle0/eagle/api:available_command_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/api:command_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:command_factory",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:legacy_handle_riot_utils",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:handle_riot_utils",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:t_command_factory",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_proto_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_command",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_handle_riots_phase_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:notification_converter",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/province",
@@ -628,7 +566,6 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_simple_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_simple_action",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
@@ -641,8 +578,8 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:notification_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_please_recruit_me_phase_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:notification_converter",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
    ],
 )

@@ -714,6 +651,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
        "//src/main/scala/net/eagle0/eagle/model/state/faction",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/hero",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
        "//src/main/scala/net/eagle0/eagle/model/state/province",
@@ -733,7 +671,7 @@ scala_library(
    exports = [
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        ":check_for_faction_changes_action",
@@ -742,9 +680,9 @@ scala_library(
        ":hero_backstory_update_action_generator",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
@@ -756,11 +694,7 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_vassal_commands_phase_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters:battalion_type_converter",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
@@ -858,7 +792,7 @@ scala_library(
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils:legacy_faction_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
@@ -866,9 +800,11 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/hero",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
+        "//src/main/scala/net/eagle0/eagle/model/state/quest",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
    ],
 )

@@ -915,23 +851,18 @@ scala_library(
    exports = [
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        ":chronicle_event_generator",
        ":hero_stat_gain_action",
        ":new_year_action",
-        "//src/main/protobuf/net/eagle0/eagle/common:date_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/common:profession_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
        "//src/main/scala/net/eagle0/eagle/library:game_history",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/settings:empty_province_monthly_devastation_delta",
        "//src/main/scala/net/eagle0/eagle/library/settings:faction_bias_minimum_adjustment_per_round",
        "//src/main/scala/net/eagle0/eagle/library/settings:faction_bias_multiplier_per_round",
@@ -940,10 +871,9 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/settings:over_hero_cap_loyalty_delta",
        "//src/main/scala/net/eagle0/eagle/library/settings:over_resource_limit_loss",
        "//src/main/scala/net/eagle0/eagle/library/settings:trust_delta_per_round",
-        "//src/main/scala/net/eagle0/eagle/library/util:date_utils",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
        "//src/main/scala/net/eagle0/eagle/library/util:price_index_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_faction_trait",
@@ -956,18 +886,13 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request/chronicle_event",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:new_round_action_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/types/base:action_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:unaffiliated_hero_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/date",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/llm_request/chronicle_event",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/chronicle_entry",
        "//src/main/scala/net/eagle0/eagle/model/state/date",
        "//src/main/scala/net/eagle0/eagle/model/state/faction",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
        "//src/main/scala/net/eagle0/eagle/model/state/quest",
        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
    ],
@@ -1052,34 +977,26 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:province_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/actions/util:shattered_army_utils",
        "//src/main/scala/net/eagle0/eagle/library/settings:winter_supplies_loss",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:army_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_forced_turn_back_phase_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:weather_forced_supplies_back_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:weather_forced_supplies_lost_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:weather_forced_turn_back_result_type",
        "//src/main/scala/net/eagle0/eagle/model/state:army",
-        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
+        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state:supplies",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/province",
    ],
 )
@@ -1092,22 +1009,35 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/settings:faction_bias_from_departure",
        "//src/main/scala/net/eagle0/eagle/library/settings:loyalty_threshold",
-        "//src/main/scala/net/eagle0/eagle/library/util/hero:legacy_hero_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/hero:hero_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:notification_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_hero_departure_phase_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:heroes_departed_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/date",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/hero",
+        "//src/main/scala/net/eagle0/eagle/model/state/hero:event_for_hero_backstory_trait",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/quest",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero/concrete",
    ],
 )

@@ -1197,16 +1127,12 @@ scala_library(
    exports = [
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/common:province_event_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/settings:base_beasts_count",
        "//src/main/scala/net/eagle0/eagle/library/settings:beasts_duration_months",
        "//src/main/scala/net/eagle0/eagle/library/settings:beasts_event_chance",
@@ -1241,12 +1167,23 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/library/settings:months_between_riots_support_multiplier",
        "//src/main/scala/net/eagle0/eagle/library/settings:riot_event_chance",
        "//src/main/scala/net/eagle0/eagle/library/util:beast_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util:date_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util:incoming_army_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util:province_event_utils",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_faction_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:province_events_changed_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:beast_info",
+        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/battalion",
+        "//src/main/scala/net/eagle0/eagle/model/state/date",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/quest",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
    ],
 )

@@ -1258,41 +1195,21 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        ":end_province_move_resolution_phase_action",
        ":friendly_move_action",
        ":shipment_arrived_action",
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:army_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:supplies_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:army",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/state/hero",
-        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
    ],
 )

@@ -1343,15 +1260,15 @@ scala_library(
    exports = [
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:province_scala_proto",
+        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/util:returning_heroes",
        "//src/main/scala/net/eagle0/eagle/library/util/view_filters:province_view_filter",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
@@ -1360,18 +1277,16 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_faction_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:client_text_visibility_extension_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_recon_resolution_phase_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:recon_succeeded_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters:incoming_end_turn_action_converter",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province:incoming_end_turn_action",
    ],
 )

@@ -1383,26 +1298,20 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/util/hero_generator",
    ],
    deps = [
        ":end_unaffiliated_hero_actions_phase_action",
        ":unaffiliated_hero_appeared_action",
        ":unaffiliated_hero_rejoined_action",
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/common:unaffiliated_hero_quest_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/actions/name_generation_request",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
        "//src/main/scala/net/eagle0/eagle/library/settings:free_hero_move_vigor_cost",
        "//src/main/scala/net/eagle0/eagle/library/settings:min_vigor_for_free_hero_move",
        "//src/main/scala/net/eagle0/eagle/library/settings:new_hero_chance",
@@ -1433,10 +1342,6 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:hero_changed_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:hero_moved_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:new_quests_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/faction",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/hero",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/hero",
        "//src/main/scala/net/eagle0/eagle/model/state/hero:gender",
@@ -1456,37 +1361,31 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:command_factory",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:t_command_factory",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        "//src/main/protobuf/net/eagle0/eagle/api:available_command_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/api:command_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
+        "//src/main/protobuf/net/eagle0/eagle/common:province_order_type_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/common:more_option",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:command_factory",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_proto_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:t_command_factory",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_command",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/util:command_selection",
        "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers",
        "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:command_chooser",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
    ],
 )

@@ -1498,26 +1397,27 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:t_command_factory",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        "//src/main/protobuf/net/eagle0/eagle/api:available_command_scala_proto",
        "//src/main/protobuf/net/eagle0/eagle/api:command_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:command_factory",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/command:t_command_factory",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_command",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/util:command_selection",
        "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers",
-        "//src/main/scala/net/eagle0/eagle/library/util/province:legacy_province_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/province",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
    ],
 )

@@ -1529,16 +1429,23 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/util:eagle_require",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:notification_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_prisoner_exchange_phase_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:prisoners_exchanged_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/quest",
+        "//src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero",
    ],
 )

@@ -1702,20 +1609,21 @@ scala_library(
        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
    ],
    exports = [
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
    ],
    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:faction_relationship_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:deterministic_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/util:legacy_battalion_utils",
-        "//src/main/scala/net/eagle0/eagle/shardok_interface:eagle_unit",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/util:battalion_utils",
+        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
+        "//src/main/scala/net/eagle0/eagle/model/action_result/types:start_battle_result_type",
+        "//src/main/scala/net/eagle0/eagle/model/state:army",
+        "//src/main/scala/net/eagle0/eagle/model/state:battalion_type",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
+        "//src/main/scala/net/eagle0/eagle/model/state/shardok_battle",
    ],
 )

@@ -1758,8 +1666,6 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result:notification_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province",
        "//src/main/scala/net/eagle0/eagle/model/action_result/changed_province/concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:action_result_concrete",
-        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_battalion_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/concrete:changed_hero_concrete",
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/proto_converters:action_result_proto_converter",
@@ -1860,17 +1766,17 @@ scala_library(
    exports = [
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
    ],
    deps = [
        ":withdrawn_army_returns_home_action",
        "//src/main/scala/net/eagle0/common:functional_random",
        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_trait_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/applier:action_result_applier",
+        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_random_sequential_results_action",
        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:protoless_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:random_state_trait_sequencer",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:t_random_sequential_results_action",
-        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils:legacy_faction_utils",
+        "//src/main/scala/net/eagle0/eagle/library/actions/random_state_sequencer",
+        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils",
        "//src/main/scala/net/eagle0/eagle/model/action_result:action_result_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_battalion_trait",
        "//src/main/scala/net/eagle0/eagle/model/action_result:changed_hero_trait",
@@ -1882,10 +1788,9 @@ scala_library(
        "//src/main/scala/net/eagle0/eagle/model/action_result/generated_text_request",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:end_truce_turn_back_phase_result_type",
        "//src/main/scala/net/eagle0/eagle/model/action_result/types:withdrawal_for_truce_result_type",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
-        "//src/main/scala/net/eagle0/eagle/model/proto_converters/province",
        "//src/main/scala/net/eagle0/eagle/model/state:army",
        "//src/main/scala/net/eagle0/eagle/model/state:round_phase",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction",
        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
        "//src/main/scala/net/eagle0/eagle/model/state/province",
    ],
@@ -1927,30 +1832,6 @@ scala_library(
    ],
 )

-scala_library(
-    name = "unaffiliated_hero_moved_action",
-    srcs = ["UnaffiliatedHeroMovedAction.scala"],
-    visibility = [
-        "//src/main/scala/net/eagle0/eagle/library:__subpackages__",
-        "//src/test/scala/net/eagle0/eagle/library/actions/impl:__subpackages__",
-    ],
-    exports = [
-        "//src/main/scala/net/eagle0/common:functional_random",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action_with_resulting_state",
-    ],
-    deps = [
-        "//src/main/protobuf/net/eagle0/eagle/common:round_phase_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:action_result_scala_proto",
-        "//src/main/protobuf/net/eagle0/eagle/internal:game_state_scala_proto",
-        "//src/main/scala/net/eagle0/common:functional_random",
-        "//src/main/scala/net/eagle0/eagle:eagle_pkg",
-        "//src/main/scala/net/eagle0/eagle/library/actions/impl/common:action",
-        "//src/main/scala/net/eagle0/eagle/library/settings:free_hero_move_vigor_cost",
-        "//src/main/scala/net/eagle0/eagle/library/util/unaffiliated_hero:legacy_unaffiliated_hero_utils",
-    ],
-)
-
 scala_library(
    name = "unaffiliated_hero_rejoined_action",
    srcs = ["UnaffiliatedHeroRejoinedAction.scala"],
@@ -2,31 +2,11 @@ package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
 import net.eagle0.eagle.{FactionId, HeroId, ProvinceId}
-import net.eagle0.eagle.common.unaffiliated_hero_type.UnaffiliatedHeroType
-import net.eagle0.eagle.common.unaffiliated_hero_type.UnaffiliatedHeroType.{
-  UNAFFILIATED_HERO_OUTLAW,
-  UNAFFILIATED_HERO_PRISONER
-}
-import net.eagle0.eagle.internal.deferred_change.{
-  BlizzardEnded,
-  BlizzardStarted,
-  CapturedHeroExecuted,
-  CapturedHeroExiled,
-  CapturedHeroImprisoned,
-  CapturedHeroReturned,
-  DeferredChange,
-  DroughtEnded,
-  DroughtStarted,
-  EpidemicStarted,
-  PrisonerMoved,
-  PrisonerReturned
-}
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.internal.unaffiliated_hero.UnaffiliatedHero
-import net.eagle0.eagle.library.actions.applier.ActionResultTApplier
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
 import net.eagle0.eagle.library.actions.generated_text_request_generators.captured_hero_helpers.CapturedHeroPleaGenerator
 import net.eagle0.eagle.library.actions.impl.action.EndBattleAftermathPhaseAction.RevelationChange
-import net.eagle0.eagle.library.actions.impl.common.{ProtolessRandomSequentialResultsAction, RandomStateTSequencer}
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.settings.{
  FactionBiasAgainstFormerOnExile,
  FactionBiasFromExile,
@@ -34,7 +14,7 @@ import net.eagle0.eagle.library.settings.{
  TruceMonthsFromReturningLeader
 }
 import net.eagle0.eagle.library.util.faction_utils.FactionUtils
-import net.eagle0.eagle.library.util.unaffiliated_hero.LegacyUnaffiliatedHeroUtils
+import net.eagle0.eagle.library.util.unaffiliated_hero.UnaffiliatedHeroUtils
 import net.eagle0.eagle.library.util.view_filters.ProvinceViewFilter
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
 import net.eagle0.eagle.library.EagleInternalException
@@ -42,23 +22,18 @@ import net.eagle0.eagle.model.action_result.{ActionResultT, NotificationDetails,
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.{ActionResultC, ChangedFactionC, ChangedHeroC, NotificationC}
 import net.eagle0.eagle.model.action_result.types.{CapturedHeroResolvedResultType, EndAftermathPhaseResultType}
-import net.eagle0.eagle.model.proto_converters.{
-  BattleRevelationConverter,
-  NotificationConverter,
-  UnaffiliatedHeroConverter
-}
-import net.eagle0.eagle.model.proto_converters.date.DateConverter
-import net.eagle0.eagle.model.proto_converters.faction.FactionConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
 import net.eagle0.eagle.model.state.{BattleRevelation, RoundPhase}
 import net.eagle0.eagle.model.state.faction.FactionRelationship
+import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.{
  CapturedHeroExiledBackstoryEvent,
  CapturedHeroImprisonedBackstoryEvent,
  CapturedHeroReturnedBackstoryEvent,
  EventForHeroBackstoryT
 }
+import net.eagle0.eagle.model.state.province.{DeferredChange, DeferredChangeT}
+import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
+import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType
 import net.eagle0.eagle.model.state.BattleRevelationType.{DidBattle, Unknown, Withdrew}

 object EndBattleAftermathPhaseAction {
@@ -67,7 +42,7 @@ object EndBattleAftermathPhaseAction {
      changedProvince: ChangedProvinceC
  )

-  def allDeferredChanges(gameState: GameState): Vector[DeferredChange] =
+  def allDeferredChanges(gameState: GameState): Vector[DeferredChangeT] =
    gameState.provinces.values
      .flatMap(_.deferredChanges)
      .toVector
@@ -83,23 +58,25 @@ object EndBattleAftermathPhaseAction {
      gameState: GameState,
      functionalRandom: FunctionalRandom,
      newEventForHeroBackstoryDetails: EventForHeroBackstoryT
-  ): RandomState[ActionResultT] =
-    LegacyUnaffiliatedHeroUtils
+  ): RandomState[ActionResultT] = {
+    val hero      = gameState.heroes(capturedHeroId)
+    val initialUh = UnaffiliatedHeroC(
+      heroId = capturedHeroId,
+      unaffiliatedHeroType = uhType,
+      lastFactionId = hero.factionId,
+      factionBiases = (
+        newFactionBias.map(b => actingFactionId -> b) ++ oldFactionBias.map(b => capturedHeroFactionId -> b)
+      ).toMap
+    )
+
+    UnaffiliatedHeroUtils
      .updatedForQuest(
        gs = gameState,
        pid = provinceId,
-        uh = UnaffiliatedHero(
-          heroId = capturedHeroId,
-          `type` = uhType,
-          lastFaction = gameState.heroes(capturedHeroId).factionId,
-          factionBiases = (
-            newFactionBias.map(b => actingFactionId -> b) ++ oldFactionBias.map(b => capturedHeroFactionId -> b)
-          ).toMap
-        ),
-        hero = gameState.heroes(capturedHeroId),
+        uh = initialUh,
+        hero = hero,
        functionalRandom = functionalRandom
      )
-      .map(UnaffiliatedHeroConverter.fromProto)
      .map { uh =>
        ActionResultC(
          actionResultType = CapturedHeroResolvedResultType,
@@ -121,20 +98,20 @@ object EndBattleAftermathPhaseAction {
          )
        )
      }
+  }

  def deferredChangeAR(
-      deferredChange: DeferredChange,
+      deferredChange: DeferredChangeT,
      gameState: GameState,
      functionalRandom: FunctionalRandom
  ): RandomState[ActionResultT] =
    deferredChange match {
-      case CapturedHeroExiled(
+      case DeferredChange.CapturedHeroExiled(
            exiledHeroId,
            provinceId,
            exilingHeroId,
            exilingFactionId,
-            prisonerFactionId,
-            _ /* unknownFieldSet */
+            prisonerFactionId
          ) =>
        val notificationLlmRequest =
          CapturedHeroPleaGenerator.exiledNotification(
@@ -147,7 +124,7 @@ object EndBattleAftermathPhaseAction {
            provinceId = provinceId
          )
        convertToUnaffiliated(
-          uhType = UNAFFILIATED_HERO_OUTLAW,
+          uhType = UnaffiliatedHeroType.Outlaw,
          actingFactionId = exilingFactionId,
          provinceId = provinceId,
          capturedHeroId = exiledHeroId,
@@ -157,7 +134,7 @@ object EndBattleAftermathPhaseAction {
          gameState = gameState,
          functionalRandom = functionalRandom,
          newEventForHeroBackstoryDetails = CapturedHeroExiledBackstoryEvent(
-            date = DateConverter.fromProto(gameState.currentDate),
+            date = gameState.currentDate.get,
            capturingFactionId = exilingFactionId,
            capturingHeroId = exilingHeroId,
            provinceId = provinceId
@@ -177,13 +154,12 @@ object EndBattleAftermathPhaseAction {
              )
            )
        }
-      case CapturedHeroExecuted(
+      case DeferredChange.CapturedHeroExecuted(
            capturedHeroId,
            provinceId,
            executingHeroId,
            executingFactionId,
-            prisonerFactionId,
-            _ /* unknownFieldSet */
+            prisonerFactionId
          ) =>
        val notificationLlmRequest =
          CapturedHeroPleaGenerator.executedNotification(
@@ -224,13 +200,12 @@ object EndBattleAftermathPhaseAction {
          ),
          functionalRandom
        )
-      case CapturedHeroImprisoned(
+      case DeferredChange.CapturedHeroImprisoned(
            capturedHeroId,
            provinceId,
            imprisoningHeroId,
            imprisoningFactionId,
-            prisonerFactionId,
-            _ /* unknownFieldSet */
+            prisonerFactionId
          ) =>
        val notificationLlmRequest =
          CapturedHeroPleaGenerator.imprisonedNotification(
@@ -243,7 +218,7 @@ object EndBattleAftermathPhaseAction {
            provinceId = provinceId
          )
        convertToUnaffiliated(
-          uhType = UNAFFILIATED_HERO_PRISONER,
+          uhType = UnaffiliatedHeroType.Prisoner,
          actingFactionId = imprisoningFactionId,
          provinceId = provinceId,
          capturedHeroId = capturedHeroId,
@@ -253,7 +228,7 @@ object EndBattleAftermathPhaseAction {
          gameState = gameState,
          functionalRandom = functionalRandom,
          newEventForHeroBackstoryDetails = CapturedHeroImprisonedBackstoryEvent(
-            date = DateConverter.fromProto(gameState.currentDate),
+            date = gameState.currentDate.get,
            capturingFactionId = imprisoningFactionId,
            capturingHeroId = imprisoningHeroId,
            provinceId = provinceId
@@ -273,22 +248,16 @@ object EndBattleAftermathPhaseAction {
              )
            )
        }
-      case CapturedHeroReturned(
+      case DeferredChange.CapturedHeroReturned(
            returnedHeroId,
            actingHeroId,
            fromProvinceId,
            fromFactionId,
            toProvinceId,
-            toFactionId,
-            _ /* unknownFieldSet */
+            toFactionId
          ) =>
-        val allFactionTs =
-          gameState.factions.values.map(FactionConverter.fromProto)
-        val truceEndDate = DateConverter
-          .fromProto(gameState.currentDate)
-          .addMonths(
-            TruceMonthsFromReturningLeader.intValue
-          )
+        val allFactions  = gameState.factions.values
+        val truceEndDate = gameState.currentDate.get.addMonths(TruceMonthsFromReturningLeader.intValue)
        RandomState(
          ActionResultC(
            actionResultType = CapturedHeroResolvedResultType,
@@ -299,7 +268,7 @@ object EndBattleAftermathPhaseAction {
                heroId = returnedHeroId,
                newEventsForHeroBackstory = Vector(
                  CapturedHeroReturnedBackstoryEvent(
-                    date = DateConverter.fromProto(gameState.currentDate),
+                    date = gameState.currentDate.get,
                    capturingFactionId = fromFactionId,
                    capturingHeroId = actingHeroId,
                    provinceId = fromProvinceId
@@ -326,7 +295,7 @@ object EndBattleAftermathPhaseAction {
                    .factionRelationship(
                      by = fromFactionId,
                      of = toFactionId,
-                      factions = allFactionTs
+                      factions = allFactions
                    )
                    .copy(
                      relationshipLevel = FactionRelationship.RelationshipLevel.Truce,
@@ -341,7 +310,7 @@ object EndBattleAftermathPhaseAction {
                    .factionRelationship(
                      by = toFactionId,
                      of = fromFactionId,
-                      factions = allFactionTs
+                      factions = allFactions
                    )
                    .copy(
                      relationshipLevel = FactionRelationship.RelationshipLevel.Truce,
@@ -365,12 +334,10 @@ object EndBattleAftermathPhaseAction {
          functionalRandom
        )

-      case DeferredChange.Empty =>
-        throw new EagleInternalException("Empty deferred change")
-
      // the rest are not for this phase
-      case _: EpidemicStarted | _: DroughtStarted | _: DroughtEnded | _: PrisonerMoved | _: PrisonerReturned |
-          _: BlizzardStarted | _: BlizzardEnded =>
+      case _: DeferredChange.EpidemicStarted | _: DeferredChange.DroughtStarted | _: DeferredChange.DroughtEnded |
+          _: DeferredChange.PrisonerMoved | _: DeferredChange.PrisonerReturned | _: DeferredChange.BlizzardStarted |
+          _: DeferredChange.BlizzardEnded =>
        throw new EagleInternalException(
          "Event should not be present in EndBattleAftermathPhaseAction"
        )
@@ -379,10 +346,12 @@ object EndBattleAftermathPhaseAction {

 case class EndBattleAftermathPhaseAction(
    gameState: GameState,
-    actionResultApplier: ActionResultTApplier
+    actionResultApplier: ActionResultApplier
 ) extends ProtolessRandomSequentialResultsAction {
+
  private def revelationChange(
-      battleRevelation: BattleRevelation
+      battleRevelation: BattleRevelation,
+      gs: GameState
  ): RevelationChange =
    RevelationChange(
      changedFaction = battleRevelation.revelationType match {
@@ -394,25 +363,21 @@ case class EndBattleAftermathPhaseAction(
            updatedReconnedProvinces = Vector(
              ProvinceViewFilter
                .withdrawnFromProvinceView(
-                  province = gameState.provinces(battleRevelation.provinceId),
-                  gs = gameState,
+                  province = gs.provinces(battleRevelation.provinceId),
+                  gs = gs,
                  factionId = battleRevelation.revealedToFactionId
                )
-                .withAsOf(gameState.currentDate.get)
+                .copy(asOf = gs.currentDate)
            )
          )
        case DidBattle =>
          ChangedFactionC(
            factionId = battleRevelation.revealedToFactionId,
            updatedReconnedProvinces = Vector(
-              ProvinceViewFilter
-                .filteredProvinceView(
-                  gameState.provinces(battleRevelation.provinceId),
-                  gameState
-                  // FIXME: setting factionId to None right now to grab the full info. This
-                  // probably isn't exactly what we want.
-                )
-                .withAsOf(gameState.currentDate.get)
+              ProvinceViewFilter.filteredProvinceView(
+                gs.provinces(battleRevelation.provinceId),
+                gs
+              )
            )
          )
      },
@@ -427,22 +392,19 @@ case class EndBattleAftermathPhaseAction(
      province   <- gs.provinces.values.toVector
      revelation <- province.battleRevelations
      if gs.factions.contains(revelation.revealedToFactionId)
-    } yield revelationChange(BattleRevelationConverter.fromProto(revelation))
+    } yield revelationChange(revelation, gs)

  def sequencerWithDeferredChanges(
      initialState: GameState,
-      actionResultApplier: ActionResultTApplier,
+      actionResultApplier: ActionResultApplier,
      functionalRandom: FunctionalRandom
-  ): RandomStateTSequencer =
-    RandomStateTSequencer
-      .fromProto(
-        initialStateProto = initialState,
-        actionResultApplier = actionResultApplier,
-        functionalRandom = functionalRandom
-      )
-      .foldIn(
-        EndBattleAftermathPhaseAction.allDeferredChanges(gameState = initialState)
-      )(
+  ): RandomStateSequencer =
+    RandomStateSequencer(
+      initialState = initialState,
+      actionResultApplier = actionResultApplier,
+      functionalRandom = functionalRandom
+    )
+      .foldIn(EndBattleAftermathPhaseAction.allDeferredChanges(initialState))(
        EndBattleAftermathPhaseAction.deferredChangeAR
      )

@@ -468,30 +430,25 @@ case class EndBattleAftermathPhaseAction(
      .withRandomActionResults((gs, fr) =>
        CheckForFactionChangesAction(
          gameId = gs.gameId,
-          factions = gs.factions.values.toVector.map(FactionConverter.fromProto),
-          provinces = gs.provinces.values.toVector.map(ProvinceConverter.fromProto),
-          heroes = gs.heroes.values.toVector.map(HeroConverter.fromProto),
+          factions = gs.factions.values.toVector,
+          provinces = gs.provinces.values.toVector,
+          heroes = gs.heroes.values.toVector,
          killedHeroIds = gs.killedHeroes.keys.toVector
        ).randomResults(fr)
      )
-      .withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator.fromGameState(gs))
-      .withRandomActionResult {
-        case (gs, fr) =>
-          RandomState(
-            ActionResultC(
-              actionResultType = EndAftermathPhaseResultType,
-              changedFactions = revelationChanges(gs).map(_.changedFaction),
-              changedProvinces = revelationChanges(gs).map(_.changedProvince),
-              newRoundPhase = Some(RoundPhase.DiplomacyResolution),
-              removedNotifications = gs.deferredNotifications
-                .map(note => NotificationConverter.fromProto(note, deferred = true))
-                .toVector,
-              newNotifications = gs.deferredNotifications
-                .map(note => NotificationConverter.fromProto(note, deferred = false))
-                .toVector
-            ),
-            fr
-          )
+      .withActionResults(gs => HeroBackstoryUpdateActionGenerator(gs).results)
+      .withRandomActionResult { (gs, fr) =>
+        RandomState(
+          ActionResultC(
+            actionResultType = EndAftermathPhaseResultType,
+            changedFactions = revelationChanges(gs).map(_.changedFaction),
+            changedProvinces = revelationChanges(gs).map(_.changedProvince),
+            newRoundPhase = Some(RoundPhase.DiplomacyResolution),
+            removedNotifications = gs.deferredNotifications.map(_.withDeferred(true)),
+            newNotifications = gs.deferredNotifications.map(_.withDeferred(false))
+          ),
+          fr
+        )
      }
      .actionResults
  }
@@ -1,12 +1,12 @@
 package net.eagle0.eagle.library.actions.impl.action

-import net.eagle0.eagle.internal.game_state.GameState
 import net.eagle0.eagle.library.actions.impl.common.ProtolessSimpleAction
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.EndBattleRequestPhaseResultType
 import net.eagle0.eagle.model.action_result.ActionResultT
+import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.ProvinceId

@@ -23,7 +23,7 @@ case class EndBattleRequestPhaseAction(
 }

 object EndBattleRequestPhaseAction {
-  def fromProtoState(gameState: GameState): EndBattleRequestPhaseAction = {
+  def apply(gameState: GameState): EndBattleRequestPhaseAction = {
    internalRequire(
      gameState.provinces.forall {
        case (_, province) =>
@@ -1,14 +1,13 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.eagle.{FactionId, ProvinceId}
-import net.eagle0.eagle.internal.game_state.GameState
 import net.eagle0.eagle.library.actions.impl.common.ProtolessSimpleAction
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.EndDefenseDecisionPhaseResultType
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.ArmyConverter
-import net.eagle0.eagle.model.state.{MovingArmy, RoundPhase}
+import net.eagle0.eagle.model.state.{HostileArmyGroupStatus, MovingArmy, RoundPhase}
+import net.eagle0.eagle.model.state.game_state.GameState

 /** Resolution for a single province that paid tribute to hostile armies */
 case class PayingProvinceResolution(
@@ -52,19 +51,21 @@ case class EndDefenseDecisionPhaseAction(
 }

 object EndDefenseDecisionPhaseAction {
-  def fromProtoState(gameState: GameState): EndDefenseDecisionPhaseAction = {
+  def apply(gameState: GameState): EndDefenseDecisionPhaseAction = {
    val resolutions = gameState.provinces.values.flatMap { province =>
-      val tributePaidArmyGroups = province.hostileArmies.filter(
-        _.status.asMessage.sealedValue.isTributePaid
-      )
+      val tributePaidArmyGroups = province.hostileArmies.filter { ag =>
+        ag.status match {
+          case _: HostileArmyGroupStatus.TributePaid => true
+          case _                                     => false
+        }
+      }

      if tributePaidArmyGroups.isEmpty then None
      else {
        val returningArmies = for {
-          ag        <- tributePaidArmyGroups
-          armyProto <- ag.armies
-        } yield {
-          val army = ArmyConverter.fromProto(armyProto)
+          ag   <- tributePaidArmyGroups
+          army <- ag.armies
+        } yield
          // Swap destination/origin, clear flee province, set arrival to next round
          MovingArmy(
            id = army.id,
@@ -76,7 +77,6 @@ object EndDefenseDecisionPhaseAction {
            suppliesLoss = army.suppliesLoss,
            startingPositionIndex = army.startingPositionIndex
          )
-        }

        Some(
          PayingProvinceResolution(
@@ -1,8 +1,7 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.library.actions.applier.ActionResultTApplier
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
 import net.eagle0.eagle.library.actions.impl.action.diplomacy_helpers.{
  AllianceResolutionHelpers,
  BreakAllianceResolutionHelpers,
@@ -10,7 +9,8 @@ import net.eagle0.eagle.library.actions.impl.action.diplomacy_helpers.{
  RansomResolutionHelpers,
  TruceResolutionHelpers
 }
-import net.eagle0.eagle.library.actions.impl.common.{ProtolessRandomSequentialResultsAction, RandomStateTSequencer}
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.util.faction_utils.FactionUtils
 import net.eagle0.eagle.library.util.quest_fulfillment.QuestFulfillmentChecker
 import net.eagle0.eagle.library.util.ransom_validity.RansomValidity
@@ -18,35 +18,30 @@ import net.eagle0.eagle.library.EagleInternalException
 import net.eagle0.eagle.model.action_result.concrete.{ActionResultC, ChangedFactionC}
 import net.eagle0.eagle.model.action_result.types.{EndDiplomacyResolutionPhaseResultType, RansomInvalidatedResultType}
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.{BattalionConverter, NotificationConverter}
-import net.eagle0.eagle.model.proto_converters.date.DateConverter
-import net.eagle0.eagle.model.proto_converters.faction.FactionConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
 import net.eagle0.eagle.model.state.battalion.BattalionT
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.diplomacy_offer.{AllianceOffer, BreakAlliance, Invitation, RansomOffer, TruceOffer}
 import net.eagle0.eagle.model.state.diplomacy_offer.status.{Accepted, Imprisoned, Invalidated, Rejected, Unresolved}
 import net.eagle0.eagle.model.state.faction.FactionT
+import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.hero.HeroT
 import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.RoundPhase.ReconResolution

 case class EndDiplomacyResolutionPhaseAction(
    gameState: GameState,
-    actionResultTApplier: ActionResultTApplier
+    actionResultApplier: ActionResultApplier
 ) extends ProtolessRandomSequentialResultsAction {

  override def randomResults(
      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
    import EndDiplomacyResolutionPhaseActionHelpers.*
-    RandomStateTSequencer
-      .fromProto(
-        initialStateProto = gameState,
-        actionResultApplier = actionResultTApplier,
-        functionalRandom = functionalRandom
-      )
+    RandomStateSequencer(
+      initialState = gameState,
+      actionResultApplier = actionResultApplier,
+      functionalRandom = functionalRandom
+    )
      .withActionResults(invalidationResultsForState)
      .withActionResults(ransomResolutionsForState)
      .withRandomActionResults(truceResolutionsForState)
@@ -56,15 +51,9 @@ case class EndDiplomacyResolutionPhaseAction(
      .withRandomActionResults { (currentGameState, fr) =>
        CheckForFactionChangesAction(
          gameId = currentGameState.gameId,
-          factions = currentGameState.factions.values.toVector.map(
-            FactionConverter.fromProto
-          ),
-          provinces = currentGameState.provinces.values.toVector.map(
-            ProvinceConverter.fromProto
-          ),
-          heroes = currentGameState.heroes.values.toVector.map(
-            HeroConverter.fromProto
-          ),
+          factions = currentGameState.factions.values.toVector,
+          provinces = currentGameState.provinces.values.toVector,
+          heroes = currentGameState.heroes.values.toVector,
          killedHeroIds = currentGameState.killedHeroes.keys.toVector
        ).randomResults(fr)
      }
@@ -72,20 +61,14 @@ case class EndDiplomacyResolutionPhaseAction(
        HeroBackstoryUpdateAction(
          gameId = currentGameState.gameId,
          roundId = currentGameState.currentRoundId,
-          heroes = currentGameState.heroes.values
-            .map(HeroConverter.fromProto)
-            .toVector,
+          heroes = currentGameState.heroes.values.toVector,
          visibleToFactionIds = toFid =>
            FactionUtils.alliedFactions(
              toFid,
-              currentGameState.factions.values
-                .map(FactionConverter.fromProto)
-                .toVector
+              currentGameState.factions.values.toVector
            ),
          heroInProvinceOwnedBy = heroId => {
-            val provinces = currentGameState.provinces.values
-              .map(ProvinceConverter.fromProto)
-              .toVector
+            val provinces = currentGameState.provinces.values.toVector
            provinces
              .find(province =>
                province.rulingFactionHeroIds.contains(heroId) ||
@@ -109,7 +92,7 @@ case class EndDiplomacyResolutionPhaseAction(
 * compiler can become confused about which one is being referenced during imports.
 *
 * All helper methods take explicit parameters for game state components to ensure they always operate on the current
- * state as provided by RandomStateTSequencer, preventing use of stale data from the initial game state.
+ * state as provided by RandomStateSequencer, preventing use of stale data from the initial game state.
 */
 private object EndDiplomacyResolutionPhaseActionHelpers {

@@ -117,11 +100,8 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
  def invalidationResultsForState(
      currentGameState: GameState
  ): Vector[ActionResultT] = {
-    val factions  =
-      currentGameState.factions.values.map(FactionConverter.fromProto).toVector
-    val provinces = currentGameState.provinces.values
-      .map(ProvinceConverter.fromProto)
-      .toVector
+    val factions  = currentGameState.factions.values.toVector
+    val provinces = currentGameState.provinces.values.toVector

    for {
      faction    <- factions
@@ -152,8 +132,6 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
      currentGameState: GameState
  ): ActionResultT = {
    val deferredNotifications = currentGameState.deferredNotifications
-      .map(n => NotificationConverter.fromProto(n, deferred = true))
-      .toVector

    ActionResultC(
      actionResultType = EndDiplomacyResolutionPhaseResultType,
@@ -163,9 +141,6 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
    )
  }

-  private def factionTs(gs: GameState): Vector[FactionT] =
-    gs.factions.values.map(FactionConverter.fromProto).toVector
-
  private def resolutionsForType[A](
      getter: FactionT => Vector[A],
      resolver: A => Vector[ActionResultT]
@@ -192,14 +167,12 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
      currentGameState: GameState,
      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
-    val factions = factionTs(currentGameState)
+    val factions = currentGameState.factions.values.toVector
    randomResolutionsForType(
      _.incomingDiplomacyOffers.collect { case to: TruceOffer => to },
      (to: TruceOffer, fr: FunctionalRandom) => {
-        val provinces   = currentGameState.provinces.values
-          .map(ProvinceConverter.fromProto)
-          .toVector
-        val currentDate = DateConverter.fromProto(currentGameState.currentDate)
+        val provinces   = currentGameState.provinces.values.toVector
+        val currentDate = currentGameState.currentDate.get
        resultsForTruceOffer(
          to,
          fr,
@@ -217,16 +190,13 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
      currentGameState: GameState,
      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
-    val factions = factionTs(currentGameState)
+    val factions = currentGameState.factions.values.toVector
    randomResolutionsForType(
      _.incomingDiplomacyOffers.collect { case ao: AllianceOffer => ao },
      (ao: AllianceOffer, fr: FunctionalRandom) => {
-        val provinces   = currentGameState.provinces.values
-          .map(ProvinceConverter.fromProto)
-          .toVector
-        val heroes      =
-          currentGameState.heroes.values.map(HeroConverter.fromProto).toVector
-        val currentDate = DateConverter.fromProto(currentGameState.currentDate)
+        val provinces   = currentGameState.provinces.values.toVector
+        val heroes      = currentGameState.heroes.values.toVector
+        val currentDate = currentGameState.currentDate.get
        resultsForAllianceOffer(
          ao,
          fr,
@@ -244,14 +214,12 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
      currentGameState: GameState,
      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
-    val factions = factionTs(currentGameState)
+    val factions = currentGameState.factions.values.toVector
    randomResolutionsForType(
      _.incomingDiplomacyOffers.collect { case ba: BreakAlliance => ba },
      (ba: BreakAlliance, fr: FunctionalRandom) => {
-        val provinces   = currentGameState.provinces.values
-          .map(ProvinceConverter.fromProto)
-          .toVector
-        val currentDate = DateConverter.fromProto(currentGameState.currentDate)
+        val provinces   = currentGameState.provinces.values.toVector
+        val currentDate = currentGameState.currentDate.get
        resultsForBreakAlliance(ba, fr, provinces, factions, currentDate)
      },
      functionalRandom
@@ -262,17 +230,13 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
      currentGameState: GameState,
      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
-    val factions = factionTs(currentGameState)
+    val factions = currentGameState.factions.values.toVector
    randomResolutionsForType(
      _.incomingDiplomacyOffers.collect { case id: Invitation => id },
      (id: Invitation, fr: FunctionalRandom) => {
-        val provinces   = currentGameState.provinces.values
-          .map(ProvinceConverter.fromProto)
-          .toVector
-        val battalions  = currentGameState.battalions.values
-          .map(BattalionConverter.fromProto)
-          .toVector
-        val currentDate = DateConverter.fromProto(currentGameState.currentDate)
+        val provinces   = currentGameState.provinces.values.toVector
+        val battalions  = currentGameState.battalions.values.toVector
+        val currentDate = currentGameState.currentDate.get
        resultsForInvitation(
          id,
          fr,
@@ -289,16 +253,14 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
  def ransomResolutionsForState(
      currentGameState: GameState
  ): Vector[ActionResultT] = {
-    val factions = factionTs(currentGameState)
+    val factions = currentGameState.factions.values.toVector
    resolutionsForType(
      _.incomingDiplomacyOffers.collect { case ro: RansomOffer => ro },
      (ro: RansomOffer) => {
-        val provinces = currentGameState.provinces.values
-          .map(ProvinceConverter.fromProto)
-          .toVector
+        val provinces = currentGameState.provinces.values.toVector
        resultsForRansomOffer(
          ro,
-          DateConverter.fromProto(currentGameState.currentDate),
+          currentGameState.currentDate.get,
          provinces,
          currentGameState
        )
@@ -321,7 +283,7 @@ private object EndDiplomacyResolutionPhaseActionHelpers {
          gameId = gameState.gameId,
          currentDate = currentDate,
          currentRoundId = gameState.currentRoundId,
-          previousBackstoryTextIdLookup = hid => gameState.heroes(hid).backstoryVersions.toVector.last.textId
+          previousBackstoryTextIdLookup = hid => gameState.heroes(hid).backstoryVersions.last.textId
        )
      )
    case Rejected    =>
@@ -1,11 +1,10 @@
 package net.eagle0.eagle.library.actions.impl.action

-import net.eagle0.eagle.internal.game_state.GameState
 import net.eagle0.eagle.library.actions.impl.common.ProtolessSequentialResultsAction
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.EndFreeForAllDecisionPhaseResultType
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
+import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.RoundPhase

 case class EndFreeForAllDecisionPhaseAction(gameState: GameState) extends ProtolessSequentialResultsAction {
@@ -13,7 +12,7 @@ case class EndFreeForAllDecisionPhaseAction(gameState: GameState) extends Protol
  override def results: Vector[ActionResultT] =
    WithdrawnArmiesReturnHomeAction(
      gameState.currentRoundId,
-      gameState.provinces.values.map(ProvinceConverter.fromProto).toVector
+      gameState.provinces.values.toVector
    ).results :+ ActionResultC(
      actionResultType = EndFreeForAllDecisionPhaseResultType,
      newRoundPhase = Some(RoundPhase.FreeForAllBattleRequest)
@@ -2,79 +2,93 @@ package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
 import net.eagle0.eagle.api.command.OneProvinceAvailableCommands
-import net.eagle0.eagle.internal.action_result.ActionResult as ActionResultProto
-import net.eagle0.eagle.library.actions.applier.ActionResultProtoApplier
-import net.eagle0.eagle.library.actions.impl.command.{CommandFactory, LegacyHandleRiotUtils}
-import net.eagle0.eagle.library.actions.impl.common.{RandomSequentialResultsAction, RandomStateProtoSequencer}
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
+import net.eagle0.eagle.library.actions.impl.command.{HandleRiotUtils, TCommandFactory}
+import net.eagle0.eagle.library.actions.impl.common.{ProtolessRandomSequentialResultsAction, TCommand}
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.util.command_choice_helpers.CommandChoiceHelpers
-import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
+import net.eagle0.eagle.library.util.province.ProvinceUtils
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.EndHandleRiotsPhaseResultType
+import net.eagle0.eagle.model.action_result.ActionResultT
 import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
 import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.ProvinceId

 case class EndHandleRiotsPhaseAction(
    gameState: GameState,
    commandsForProvince: ProvinceId => Option[OneProvinceAvailableCommands],
-    commandFactory: CommandFactory
-) extends RandomSequentialResultsAction(GameStateConverter.toProto(gameState)) {
-  def vassalCommandResults(
-      ars: RandomStateProtoSequencer
-  ): RandomStateProtoSequencer =
-    ars.lastStateProto.provinces.values
-      .filter(LegacyProvinceUtils.hasImminentRiot)
+    commandFactory: TCommandFactory,
+    actionResultApplier: ActionResultApplier
+) extends ProtolessRandomSequentialResultsAction {
+
+  private def provincesWithImminentRiot(gs: GameState): Vector[ProvinceT] =
+    gs.provinces.values.filter(ProvinceUtils.hasImminentRiot).toVector
+
+  private def vassalCommandResults(
+      sequencer: RandomStateSequencer
+  ): RandomStateSequencer = {
+    val provincesToProcess = provincesWithImminentRiot(sequencer.lastState)
      .filterNot(_.hasActed)
-      .foldLeft(ars) {
-        case (sequencer, p) =>
-          commandsForProvince(p.id).map { opac =>
-            sequencer.withRandomAction {
-              case (gs, fr) =>
-                CommandChoiceHelpers
-                  .handleRiotSelectedCommand(
-                    actingFactionId = p.getRulingFactionId,
+
+    provincesToProcess.foldLeft(sequencer) {
+      case (seq, province) =>
+        commandsForProvince(province.id).map { opac =>
+          seq.withRandomActionResults { (gs, fr) =>
+            // Convert to proto for CommandChoiceHelpers which expects proto GameState
+            val gsProto = GameStateConverter.toProto(gs)
+            CommandChoiceHelpers
+              .handleRiotSelectedCommand(
+                actingFactionId = province.rulingFactionId.get,
+                gameState = gsProto,
+                availableCommands = opac.commands.toVector,
+                functionalRandom = fr
+              )
+              .continue {
+                case (Some(cs), nextFr) =>
+                  val cmd = commandFactory.makeTCommand(
+                    actingFactionId = province.rulingFactionId.get,
                    gameState = gs,
-                    availableCommands = opac.commands.toVector,
-                    functionalRandom = fr
+                    availableCommand = cs.available,
+                    selectedCommand = cs.selected
                  )
-                  .map { optCS =>
-                    optCS.map { cs =>
-                      commandFactory
-                        .makeCommand(
-                          actingFactionId = p.getRulingFactionId,
-                          gameState = GameStateConverter.fromProto(gs),
-                          availableCommand = cs.available,
-                          selectedCommand = cs.selected
-                        )
-                    }.get
+                  cmd match {
+                    case TCommand.Simple(action)       =>
+                      RandomState(Vector(action.immediateExecute), nextFr)
+                    case TCommand.RandomSimple(action) =>
+                      action.immediateExecute(nextFr).map(ar => Vector(ar))
+                    case TCommand.Sequential(action)   =>
+                      RandomState(action.results, nextFr)
                  }
-            }
-          }.get
-      }
+                case (None, nextFr)     =>
+                  RandomState(Vector.empty[ActionResultT], nextFr)
+              }
+          }
+        }
+          .getOrElse(seq)
+    }
+  }

  private def riotOccurredResults(
-      ars: RandomStateProtoSequencer
-  ): RandomStateProtoSequencer =
-    ars.lastStateProto.provinces.values
-      .filter(LegacyProvinceUtils.hasImminentRiot)
-      .foldLeft(ars) {
-        case (ars, p) =>
-          ars.withActionResult(_ =>
-            LegacyHandleRiotUtils
-              .riotOccurredAr(
-                p.getRulingFactionId,
-                ProvinceConverter.fromProto(p)
-              )
+      sequencer: RandomStateSequencer
+  ): RandomStateSequencer =
+    provincesWithImminentRiot(sequencer.lastState).foldLeft(sequencer) {
+      case (seq, province) =>
+        seq.withActionResult(_ =>
+          HandleRiotUtils.riotOccurredAr(
+            province.rulingFactionId.get,
+            province
          )
-      }
+        )
+    }

-  def endPhaseResult(
-      ars: RandomStateProtoSequencer
-  ): RandomStateProtoSequencer =
-    ars.withActionResultT(gs =>
+  private def endPhaseResult(
+      sequencer: RandomStateSequencer
+  ): RandomStateSequencer =
+    sequencer.withActionResult { gs =>
      ActionResultC(
        actionResultType = EndHandleRiotsPhaseResultType,
        newRoundPhase = Some(RoundPhase.HeroDepartures),
@@ -82,18 +96,17 @@ case class EndHandleRiotsPhaseAction(
          .filter(_.hasActed)
          .map(p => ChangedProvinceC(provinceId = p.id, setHasActed = Some(false)))
          .toVector,
-        removedNotifications = gameState.deferredNotifications,
-        newNotifications = gameState.deferredNotifications.map(_.withDeferred(false))
+        removedNotifications = gs.deferredNotifications,
+        newNotifications = gs.deferredNotifications.map(_.withDeferred(false))
      )
-    )
+    }

  override def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultProtoApplier: ActionResultProtoApplier
-  ): RandomState[Vector[ActionResultProto]] =
-    RandomStateProtoSequencer(
+      functionalRandom: FunctionalRandom
+  ): RandomState[Vector[ActionResultT]] =
+    RandomStateSequencer(
      initialState = gameState,
-      actionResultProtoApplier = actionResultProtoApplier,
+      actionResultApplier = actionResultApplier,
      functionalRandom = functionalRandom
    )
      .withRandomContinuance(vassalCommandResults)
@@ -1,19 +1,12 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.internal.deferred_change.*
-import net.eagle0.eagle.internal.deferred_change.DeferredChange.Empty
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.library.actions.applier.ActionResultTApplier
-import net.eagle0.eagle.library.actions.impl.common.{
-  ProtolessRandomSequentialResultsAction,
-  RandomStateTSequencer,
-  VigorXPApplier
-}
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
+import net.eagle0.eagle.library.actions.impl.common.{ProtolessRandomSequentialResultsAction, VigorXPApplier}
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.settings.PrisonerEscapeChance
 import net.eagle0.eagle.library.util.province.ProvinceUtils
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
-import net.eagle0.eagle.library.util.ProvinceEventUtils
 import net.eagle0.eagle.library.EagleInternalException
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.changed_province.ChangedProvinceT
@@ -26,12 +19,14 @@ import net.eagle0.eagle.model.action_result.types.{
  WeatherTookEffectResultType
 }
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.{NotificationConverter, UnaffiliatedHeroConverter}
-import net.eagle0.eagle.model.proto_converters.date.DateConverter
-import net.eagle0.eagle.model.proto_converters.faction.FactionConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.province.{ProvinceConverter, ProvinceEventConverter}
-import net.eagle0.eagle.model.state.province.{BlizzardEvent, DroughtEvent, EpidemicEvent}
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.{
+  BlizzardEvent,
+  DeferredChange,
+  DeferredChangeT,
+  DroughtEvent,
+  EpidemicEvent
+}
 import net.eagle0.eagle.model.state.unaffiliated_hero.RecruitmentInfo
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroType.{Outlaw, Prisoner}
 import net.eagle0.eagle.model.state.RoundPhase
@@ -39,11 +34,11 @@ import net.eagle0.eagle.ProvinceId

 case class EndPlayerCommandsPhaseAction(
    gameState: GameState,
-    applier: ActionResultTApplier
+    actionResultApplier: ActionResultApplier
 ) extends ProtolessRandomSequentialResultsAction {
+
  private def endPhaseResult(gs: GameState): ActionResultT = {
    val abandonedProvinces: Vector[ChangedProvinceT] = gs.provinces.values
-      .map(ProvinceConverter.fromProto)
      .filter(_.rulingFactionId.isDefined)
      .flatMap(ProvinceUtils.checkedForAbandonment)
      .toVector
@@ -62,19 +57,15 @@ case class EndPlayerCommandsPhaseAction(
              )
            )
        },
-        removedNotifications = gameState.deferredNotifications.map { note =>
-          NotificationConverter.fromProto(note, deferred = true)
-        }.toVector,
-        newNotifications = gameState.deferredNotifications.map { note =>
-          NotificationConverter.fromProto(note, deferred = false)
-        }.toVector
+        removedNotifications = gs.deferredNotifications.map(_.withDeferred(true)),
+        newNotifications = gs.deferredNotifications.map(_.withDeferred(false))
      )
    )
  }

  private def onePrisonerMovedChange(
      pid: ProvinceId,
-      prisonerMoved: PrisonerMoved,
+      prisonerMoved: DeferredChange.PrisonerMoved,
      gs: GameState,
      fr: FunctionalRandom
  ): RandomState[ActionResultT] = {
@@ -82,7 +73,6 @@ case class EndPlayerCommandsPhaseAction(
      .provinces(pid)
      .unaffiliatedHeroes
      .find(_.heroId == prisonerMoved.heroId)
-      .map(UnaffiliatedHeroConverter.fromProto)

    fr.nextDouble.map { doubleValue =>
      val escaped = doubleValue < PrisonerEscapeChance.doubleValue
@@ -122,7 +112,7 @@ case class EndPlayerCommandsPhaseAction(

  private def onePrisonerReturnedChange(
      pid: ProvinceId,
-      prisonerReturned: PrisonerReturned,
+      prisonerReturned: DeferredChange.PrisonerReturned,
      gs: GameState,
      fr: FunctionalRandom
  ): RandomState[ActionResultT] =
@@ -155,28 +145,28 @@ case class EndPlayerCommandsPhaseAction(

  private def notPrisonerChange(
      pid: ProvinceId,
-      deferredChange: DeferredChange,
+      deferredChange: DeferredChangeT,
      gs: GameState,
      fr: FunctionalRandom
-  ): RandomState[ActionResultT] =
+  ): RandomState[ActionResultT] = {
+    val currentDate = gs.currentDate.get
+    val province    = gs.provinces(pid)
+
    RandomState(
      VigorXPApplier.withVigorXp(
        ActionResultC(
          actionResultType = deferredChange match {
-            case _: EpidemicStarted   => EpidemicTookEffectResultType
-            case _: BlizzardEnded     => WeatherTookEffectResultType
-            case _: BlizzardStarted   => WeatherTookEffectResultType
-            case _: DroughtStarted    => WeatherTookEffectResultType
-            case _: DroughtEnded      => WeatherTookEffectResultType
-            case _: PrisonerMoved | _: PrisonerReturned | _: CapturedHeroImprisoned | _: CapturedHeroExecuted |
-                _: CapturedHeroExiled | _: CapturedHeroReturned =>
+            case _: DeferredChange.EpidemicStarted => EpidemicTookEffectResultType
+            case _: DeferredChange.BlizzardEnded   => WeatherTookEffectResultType
+            case _: DeferredChange.BlizzardStarted => WeatherTookEffectResultType
+            case _: DeferredChange.DroughtStarted  => WeatherTookEffectResultType
+            case _: DeferredChange.DroughtEnded    => WeatherTookEffectResultType
+            case _: DeferredChange.PrisonerMoved | _: DeferredChange.PrisonerReturned |
+                _: DeferredChange.CapturedHeroImprisoned | _: DeferredChange.CapturedHeroExecuted |
+                _: DeferredChange.CapturedHeroExiled | _: DeferredChange.CapturedHeroReturned =>
              throw new EagleInternalException(
                "Prisoner management changes should not be here"
              )
-            case DeferredChange.Empty =>
-              throw new EagleInternalException(
-                "Empty deferred change should not be here"
-              )
          },
          provinceId = Some(pid),
          changedProvinces = Vector(
@@ -184,70 +174,31 @@ case class EndPlayerCommandsPhaseAction(
              provinceId = pid,
              newProvinceEvents = Some(
                deferredChange match {
-                  case BlizzardStarted(
-                        _,
-                        durationMonths,
-                        _ /* unknownFieldSet */
-                      ) =>
-                    gs.provinces(pid)
-                      .activeEvents
-                      .map(ProvinceEventConverter.fromProto)
-                      .toVector :+ BlizzardEvent(
-                      startDate = DateConverter.fromProto(gs.currentDate),
-                      endDate = DateConverter
-                        .fromProto(gs.currentDate)
-                        .addMonths(
-                          durationMonths
-                        )
+                  case DeferredChange.BlizzardStarted(_, durationMonths) =>
+                    province.activeEvents :+ BlizzardEvent(
+                      startDate = currentDate,
+                      endDate = currentDate.addMonths(durationMonths)
                    )
-                  case BlizzardEnded(_, _ /* unknownFieldSet */ ) =>
-                    gs.provinces(pid)
-                      .activeEvents
-                      .filterNot(ProvinceEventUtils.isBlizzardEvent)
-                      .map(ProvinceEventConverter.fromProto)
-                      .toVector
+                  case _: DeferredChange.BlizzardEnded                   =>
+                    province.activeEvents.filter { case _: BlizzardEvent => false; case _ => true }

-                  case DroughtStarted(
-                        _,
-                        durationMonths,
-                        _ /* unknownFieldSet */
-                      ) =>
-                    gs.provinces(pid)
-                      .activeEvents
-                      .map(ProvinceEventConverter.fromProto)
-                      .toVector :+ DroughtEvent(
-                      startDate = DateConverter.fromProto(gs.currentDate),
-                      endDate = DateConverter
-                        .fromProto(gs.currentDate)
-                        .addMonths(durationMonths)
+                  case DeferredChange.DroughtStarted(_, durationMonths) =>
+                    province.activeEvents :+ DroughtEvent(
+                      startDate = currentDate,
+                      endDate = currentDate.addMonths(durationMonths)
                    )
+                  case _: DeferredChange.DroughtEnded                   =>
+                    province.activeEvents.filter { case _: DroughtEvent => false; case _ => true }

-                  case DroughtEnded(_, _ /* unknownFieldSet */ ) =>
-                    gs.provinces(pid)
-                      .activeEvents
-                      .filterNot(ProvinceEventUtils.isDroughtEvent)
-                      .map(ProvinceEventConverter.fromProto)
-                      .toVector
+                  case _: DeferredChange.EpidemicStarted =>
+                    province.activeEvents :+ EpidemicEvent(startDate = currentDate)

-                  case EpidemicStarted(_, _ /* unknownFieldSet */ ) =>
-                    gs.provinces(pid)
-                      .activeEvents
-                      .map(ProvinceEventConverter.fromProto)
-                      .toVector :+ EpidemicEvent(
-                      startDate = DateConverter.fromProto(gs.currentDate)
-                    )
-
-                  case _: PrisonerMoved          => Vector()
-                  case _: PrisonerReturned       => Vector()
-                  case _: CapturedHeroImprisoned => Vector()
-                  case _: CapturedHeroExecuted   => Vector()
-                  case _: CapturedHeroExiled     => Vector()
-                  case _: CapturedHeroReturned   => Vector()
-
-                  case Empty =>
-                    throw new EagleInternalException(
-                      "Empty deferred change should not be here"
-                    )
+                  case _: DeferredChange.PrisonerMoved          => Vector()
+                  case _: DeferredChange.PrisonerReturned       => Vector()
+                  case _: DeferredChange.CapturedHeroImprisoned => Vector()
+                  case _: DeferredChange.CapturedHeroExecuted   => Vector()
+                  case _: DeferredChange.CapturedHeroExiled     => Vector()
+                  case _: DeferredChange.CapturedHeroReturned   => Vector()
                }
              ),
              removedDeferredChangeIndex = Some(0)
@@ -257,26 +208,27 @@ case class EndPlayerCommandsPhaseAction(
      ),
      fr
    )
+  }

  private def oneDeferredProvinceChange(
      pid: ProvinceId,
-      deferredChange: DeferredChange,
+      deferredChange: DeferredChangeT,
      gs: GameState,
      fr: FunctionalRandom
  ): RandomState[ActionResultT] =
    deferredChange match {
-      case prisonerMoved: PrisonerMoved       =>
+      case prisonerMoved: DeferredChange.PrisonerMoved       =>
        onePrisonerMovedChange(pid, prisonerMoved, gs, fr)
-      case prisonerReturned: PrisonerReturned =>
+      case prisonerReturned: DeferredChange.PrisonerReturned =>
        onePrisonerReturnedChange(pid, prisonerReturned, gs, fr)
-      case _                                  => notPrisonerChange(pid, deferredChange, gs, fr)
+      case _                                                 => notPrisonerChange(pid, deferredChange, gs, fr)
    }

  private def deferredProvinceChangesResultsForProvince(
      pid: ProvinceId,
-      arsRS: RandomStateTSequencer
-  ): RandomStateTSequencer =
-    arsRS.lastStateProto.provinces(pid).deferredChanges.foldLeft(arsRS) {
+      sequencer: RandomStateSequencer
+  ): RandomStateSequencer =
+    sequencer.lastState.provinces(pid).deferredChanges.foldLeft(sequencer) {
      case (acc, dc) =>
        acc.withRandomActionResult {
          case (gs, fr) =>
@@ -285,12 +237,12 @@ case class EndPlayerCommandsPhaseAction(
    }

  private def deferredProvinceChangesResults(
-      ars: RandomStateTSequencer
-  ): RandomStateTSequencer =
-    ars.lastStateProto.provinces.keys
-      .foldLeft(ars) {
-        case (newArs, pid) =>
-          deferredProvinceChangesResultsForProvince(pid, newArs)
+      sequencer: RandomStateSequencer
+  ): RandomStateSequencer =
+    sequencer.lastState.provinces.keys
+      .foldLeft(sequencer) {
+        case (newSequencer, pid) =>
+          deferredProvinceChangesResultsForProvince(pid, newSequencer)
      }

  override def randomResults(
@@ -303,23 +255,22 @@ case class EndPlayerCommandsPhaseAction(
      )
    }

-    RandomStateTSequencer
-      .fromProto(
-        initialStateProto = gameState,
-        actionResultApplier = applier,
-        functionalRandom = functionalRandom
-      )
+    RandomStateSequencer(
+      initialState = gameState,
+      actionResultApplier = actionResultApplier,
+      functionalRandom = functionalRandom
+    )
      .withRandomActionResults((gs, fr) =>
        CheckForFactionChangesAction(
          gameId = gs.gameId,
-          factions = gs.factions.values.toVector.map(FactionConverter.fromProto),
-          provinces = gs.provinces.values.toVector.map(ProvinceConverter.fromProto),
-          heroes = gs.heroes.values.toVector.map(HeroConverter.fromProto),
+          factions = gs.factions.values.toVector,
+          provinces = gs.provinces.values.toVector,
+          heroes = gs.heroes.values.toVector,
          killedHeroIds = gs.killedHeroes.keys.toVector
        ).randomResults(fr)
      )
      .withContinuance(deferredProvinceChangesResults)
-      .withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator.fromGameState(gs))
+      .withActionResults(gs => HeroBackstoryUpdateActionGenerator(gs).results)
      .withActionResult(endPhaseResult)
      .actionResults
  }
@@ -1,12 +1,11 @@
 package net.eagle0.eagle.library.actions.impl.action

-import net.eagle0.eagle.internal.game_state.GameState
 import net.eagle0.eagle.library.actions.impl.common.ProtolessSimpleAction
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.EndPleaseRecruitMePhaseResultType
 import net.eagle0.eagle.model.action_result.ActionResultT
 import net.eagle0.eagle.model.action_result.NotificationT
-import net.eagle0.eagle.model.proto_converters.NotificationConverter
+import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.RoundPhase

 case class EndPleaseRecruitMePhaseAction(
@@ -24,10 +23,8 @@ case class EndPleaseRecruitMePhaseAction(
 }

 object EndPleaseRecruitMePhaseAction {
-  def fromProtoState(gameState: GameState): EndPleaseRecruitMePhaseAction =
+  def apply(gameState: GameState): EndPleaseRecruitMePhaseAction =
    EndPleaseRecruitMePhaseAction(
      deferredNotifications = gameState.deferredNotifications
-        .map(n => NotificationConverter.fromProto(n, deferred = true))
-        .toVector
    )
 }
@@ -1,24 +1,23 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.library.actions.applier.ActionResultTApplier
-import net.eagle0.eagle.library.actions.impl.common.{RandomStateTSequencer, TRandomSequentialResultsAction}
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
 import net.eagle0.eagle.model.action_result.concrete.ActionResultC
 import net.eagle0.eagle.model.action_result.types.EndVassalCommandsPhaseResultType
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.date.DateConverter
-import net.eagle0.eagle.model.proto_converters.faction.FactionConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
-import net.eagle0.eagle.model.proto_converters.BattalionConverter
+import net.eagle0.eagle.model.proto_converters.BattalionTypeConverter
 import net.eagle0.eagle.model.state.game_state.GameState
 import net.eagle0.eagle.model.state.RoundPhase

-case class EndVassalCommandsPhaseAction(gameState: GameState) extends TRandomSequentialResultsAction(gameState) {
+case class EndVassalCommandsPhaseAction(
+    gameState: GameState,
+    actionResultApplier: ActionResultApplier
+) extends ProtolessRandomSequentialResultsAction {
  override protected def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultTApplier: ActionResultTApplier
+      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
    gameState.provinces.values.foreach { p =>
      internalRequire(
@@ -27,56 +26,53 @@ case class EndVassalCommandsPhaseAction(gameState: GameState) extends TRandomSeq
      )
    }

-    RandomStateTSequencer(
+    RandomStateSequencer(
      initialState = gameState,
-      actionResultApplier = actionResultTApplier,
+      actionResultApplier = actionResultApplier,
      functionalRandom = functionalRandom
    )
-      .withProtolessSequentialResultsAction(gs =>
+      .withActionResults(gs =>
        CheckForFulfilledQuestsAction(
          gameId = gs.gameId,
-          currentDate = DateConverter.fromProto(gs.currentDate),
+          currentDate = gs.currentDate.get,
          currentRoundId = gs.currentRoundId,
-          provinces = gs.provinces.values.map(ProvinceConverter.fromProto).toVector,
-          factions = gs.factions.values
-            .map(FactionConverter.fromProto)
-            .toVector,
-          battalions = gs.battalions.values.toVector.map(BattalionConverter.fromProto),
-          getHero = hid => gs.heroes.get(hid).map(HeroConverter.fromProto),
-          battalionTypes = gs.battalionTypes.toVector,
-          hid => gs.heroes(hid).backstoryVersions.last.textId
-        )
+          provinces = gs.provinces.values.toVector,
+          factions = gs.factions.values.toVector,
+          battalions = gs.battalions.values.toVector,
+          getHero = hid => gs.heroes.get(hid),
+          battalionTypes = gs.battalionTypes.map(BattalionTypeConverter.toProto),
+          hid => gs.heroes(hid).backstoryTextId
+        ).results
      )
-      .withProtolessSequentialResultsAction(gs =>
+      .withActionResults(gs =>
        CheckForFailedQuestsAction(
          gameId = gs.gameId,
-          currentDate = DateConverter.fromProto(gs.currentDate),
+          currentDate = gs.currentDate.get,
          currentRoundId = gs.currentRoundId,
-          provinces = gs.provinces.values.map(ProvinceConverter.fromProto).toVector,
-          factions = gs.factions.values
-            .map(FactionConverter.fromProto)
-            .toVector,
-          hid => gs.heroes(hid).backstoryVersions.last.textId
-        )
+          provinces = gs.provinces.values.toVector,
+          factions = gs.factions.values.toVector,
+          hid => gs.heroes(hid).backstoryTextId
+        ).results
      )
      .withRandomActionResults((gs, fr) =>
        CheckForFactionChangesAction(
          gameId = gs.gameId,
-          factions = gs.factions.values.map(FactionConverter.fromProto).toVector,
-          provinces = gs.provinces.values.map(ProvinceConverter.fromProto).toVector,
-          heroes = gs.heroes.values.map(HeroConverter.fromProto).toVector,
+          factions = gs.factions.values.toVector,
+          provinces = gs.provinces.values.toVector,
+          heroes = gs.heroes.values.toVector,
          killedHeroIds = gs.killedHeroes.keys.toVector
        ).randomResults(fr)
      )
-      .withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator.fromGameState(gs))
-      .withActionResultT(_ =>
+      .withActionResults(gs => HeroBackstoryUpdateActionGenerator(gs).results)
+      .withActionResult { gs =>
+        // Use current state's deferred notifications, not the initial gameState
        ActionResultC(
          actionResultType = EndVassalCommandsPhaseResultType,
          newRoundPhase = Some(RoundPhase.PlayerCommands),
-          removedNotifications = gameState.deferredNotifications,
-          newNotifications = gameState.deferredNotifications.map(_.withDeferred(false))
+          removedNotifications = gs.deferredNotifications.map(_.withDeferred(true)),
+          newNotifications = gs.deferredNotifications.map(_.withDeferred(false))
        )
-      )
+      }
      .actionResults
  }
 }
@@ -1,24 +1,25 @@
 package net.eagle0.eagle.library.actions.impl.action

-import net.eagle0.eagle.internal.game_state.GameState
 import net.eagle0.eagle.library.actions.impl.common.ProtolessSequentialResultsAction
-import net.eagle0.eagle.library.util.faction_utils.LegacyFactionUtils
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
+import net.eagle0.eagle.library.util.faction_utils.FactionUtils
+import net.eagle0.eagle.model.state.game_state.GameState

 object HeroBackstoryUpdateActionGenerator {
-  def fromGameState(gameState: GameState): ProtolessSequentialResultsAction =
+
+  def apply(gameState: GameState): ProtolessSequentialResultsAction = {
+    val factions = gameState.factions.values.toVector
    HeroBackstoryUpdateAction(
      gameId = gameState.gameId,
      roundId = gameState.currentRoundId,
-      heroes = gameState.heroes.values.map(HeroConverter.fromProto).toVector,
-      visibleToFactionIds = fid => LegacyFactionUtils.alliedFactions(fid, gameState),
+      heroes = gameState.heroes.values.toVector,
+      visibleToFactionIds = fid => FactionUtils.alliedFactions(fid, factions),
      heroInProvinceOwnedBy = heroId =>
        gameState.provinces.values
          .find(province =>
-            province.rulingFactionHeroIds.contains(
-              heroId
-            ) || province.unaffiliatedHeroes.exists(_.heroId == heroId)
+            province.rulingFactionHeroIds.contains(heroId) ||
+              province.unaffiliatedHeroes.exists(_.heroId == heroId)
          )
          .flatMap(_.rulingFactionId)
    )
+  }
 }
@@ -2,9 +2,9 @@ package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
 import net.eagle0.eagle.{HeroId, ProvinceId, RoundId}
-import net.eagle0.eagle.internal.game_state.GameState as GameStateProto
-import net.eagle0.eagle.library.actions.applier.ActionResultTApplier
-import net.eagle0.eagle.library.actions.impl.common.{RandomStateTSequencer, TRandomSequentialResultsAction}
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.settings.{
  EmptyProvinceMonthlyDevastationDelta,
  FactionBiasMinimumAdjustmentPerRound,
@@ -15,8 +15,7 @@ import net.eagle0.eagle.library.settings.{
  OverResourceLimitLoss,
  TrustDeltaPerRound
 }
-import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
-import net.eagle0.eagle.library.util.DateProtoUtils._Date
+import net.eagle0.eagle.library.util.province.ProvinceUtils
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
 import net.eagle0.eagle.library.util.PriceIndexUtils
 import net.eagle0.eagle.library.GameHistory
@@ -32,37 +31,34 @@ import net.eagle0.eagle.model.action_result.concrete.{
 import net.eagle0.eagle.model.action_result.generated_text_request.{ChronicleUpdatePreviousEntry, LlmRequestT}
 import net.eagle0.eagle.model.action_result.types.NewRoundActionResultType
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.date.DateConverter
-import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
 import net.eagle0.eagle.model.proto_converters.generated_text_request.chronicle_event.ChronicleEventConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.UnaffiliatedHeroConverter
 import net.eagle0.eagle.model.state.chronicle_entry.ChronicleEntry
 import net.eagle0.eagle.model.state.date.Date
 import net.eagle0.eagle.model.state.faction.FactionRelationship
 import net.eagle0.eagle.model.state.faction.FactionRelationship.RelationshipLevel
 import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.model.state.unaffiliated_hero.UnaffiliatedHeroT
 import net.eagle0.eagle.model.state.RoundPhase

-case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
-    extends TRandomSequentialResultsAction(gameState) {
-
-  private val startingState: GameStateProto = GameStateConverter.toProto(gameState)
+case class NewRoundAction(
+    gameState: GameState,
+    gameHistory: GameHistory,
+    actionResultApplier: ActionResultApplier
+) extends ProtolessRandomSequentialResultsAction {

  private val chronicleMonths = Vector(11)

  private def isChronicleMonth(newDate: Date): Boolean =
    chronicleMonths.contains(newDate.month.value)

-  override protected def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultTApplier: ActionResultTApplier
+  override def randomResults(
+      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
-    val newRoundId = startingState.currentRoundId + 1
+    val newRoundId = gameState.currentRoundId + 1

    // Verify no old incoming armies
-    startingState.provinces.foreach {
+    gameState.provinces.foreach {
      case (pid, province) =>
        internalRequire(
          province.incomingArmies.forall(_.arrivalRound >= newRoundId),
@@ -74,28 +70,26 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
        )
    }

-    val oldDate = DateConverter.fromProto(startingState.currentDate)
+    val oldDate = gameState.currentDate.get
    val newDate = oldDate.addMonths(1)

    // Build sequencer starting from starting state
-    val initialSequencer = RandomStateTSequencer.fromProto(
-      initialStateProto = startingState,
-      actionResultApplier = actionResultTApplier,
+    val initialSequencer = RandomStateSequencer(
+      initialState = gameState,
+      actionResultApplier = actionResultApplier,
      functionalRandom = functionalRandom
    )

    // Optionally add NewYearAction
    val afterNewYearSequencer =
      if newDate.month == Date.Month.January then
-        initialSequencer.withActionResultT(_ =>
-          NewYearAction(GameStateConverter.fromProto(startingState)).immediateExecute
-        )
+        initialSequencer.withActionResult(_ => NewYearAction(gameState).immediateExecute)
      else initialSequencer

    // Add the main new round result
-    val afterNewRoundSequencer = afterNewYearSequencer.withActionResultT { currentState =>
+    val afterNewRoundSequencer = afterNewYearSequencer.withActionResult { currentState =>
      newRoundResult(
-        startingState = currentState,
+        gs = currentState,
        newRoundId = newRoundId,
        newDate = newDate
      )
@@ -103,34 +97,31 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)

    // Add stat gain checks (and profession gain for stats that newly cross the threshold)
    afterNewRoundSequencer.withRandomActionResults { (latestState, nextRandom) =>
-      val scalaHeroes = latestState.heroes.values.map(HeroConverter.fromProto)
-      val scalaDate   = DateConverter.fromProto(Some(DateConverter.toProto(newDate)))
-      HeroStatGainAction(scalaHeroes, latestState.gameId, scalaDate).randomResultsWithState(nextRandom)
+      HeroStatGainAction(latestState.heroes.values, latestState.gameId, newDate).randomResultsWithState(nextRandom)
    }.actionResults
  }

  private def chronicleLlmRequests(
      newDate: Date,
-      startingState: GameStateProto
+      gs: GameState
  ): Vector[LlmRequestT] =
    if isChronicleMonth(newDate) then
      Vector(
        LlmRequestT.ChronicleUpdateMessage(
          requestId = s"chronicle_update_${newDate.year}_${newDate.month.value}",
-          eagleGameId = startingState.gameId,
+          eagleGameId = gs.gameId,
          current_date = newDate,
-          previous_entries = startingState.chronicleEntries.map { entry =>
+          previous_entries = gs.chronicleEntries.map { entry =>
            ChronicleUpdatePreviousEntry(
-              date = DateConverter.fromProto(entry.date),
+              date = entry.date,
              generatedTextId = entry.generatedTextId
            )
-          }.toVector,
+          },
          new_entries = ChronicleEventGenerator
            .eventTextEntries(
              gameHistory = gameHistory,
-              since = startingState.chronicleEntries.lastOption
-                .flatMap(_.date)
-                .map(d => DateConverter.fromProto(Some(d)))
+              since = gs.chronicleEntries.lastOption
+                .map(_.date)
                .getOrElse(Date(year = 0, month = Date.Month.January))
            )
            .map(ChronicleEventConverter.fromProto)
@@ -138,8 +129,11 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
      )
    else Vector()

+  private def dateBefore(a: Date, b: Date): Boolean =
+    a.year < b.year || (a.year == b.year && a.month.value < b.month.value)
+
  private def newRoundResult(
-      startingState: GameStateProto,
+      gs: GameState,
      newRoundId: RoundId,
      newDate: Date
  ): ActionResultT = {
@@ -149,29 +143,28 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
    )

    val changes: Iterable[Changes] =
-      startingState.provinces.values.map { p =>
+      gs.provinces.values.map { p =>
        val changedUHs: Vector[UnaffiliatedHeroT] =
          p.unaffiliatedHeroes.map { uh =>
-            val tUh = UnaffiliatedHeroConverter.fromProto(uh)
-            tUh.copy(
+            uh.copy(
              recruitmentAttempted = false,
-              roundsInType = tUh.roundsInType + 1,
-              factionBiases = tUh.factionBiases.map {
+              roundsInType = uh.roundsInType + 1,
+              factionBiases = uh.factionBiases.map {
                case (fid, v) =>
                  fid -> modifiedFactionBiasValue(v)
              }
            )
-          }.toVector
-        val changedHeroes                         = changedHeroesAfterOverage(startingState, p.id)
+          }
+        val changedHeroes                         = changedHeroesAfterOverage(gs, p.id)

        // apply caps
        val capGoldLoss = (OverResourceLimitLoss.doubleValue * Math.max(
          0,
-          p.gold - LegacyProvinceUtils.goldCap(p)
+          p.gold - ProvinceUtils.goldCap(p)
        )).ceil.toInt
        val capFoodLoss = (OverResourceLimitLoss.doubleValue * Math.max(
          0,
-          p.food - LegacyProvinceUtils.foodCap(p)
+          p.food - ProvinceUtils.foodCap(p)
        )).ceil.toInt

        val newPriceIndex = PriceIndexUtils.shiftedTowardSteadyState(
@@ -228,7 +221,7 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
    val heroesAfterStipend: Map[HeroId, ChangedHeroC] =
      changes.flatMap(_.changedHeroes).map(h => h.heroId -> h).toMap

-    val uppedVigorHeroes: Iterable[ChangedHeroC] = startingState.heroes.map {
+    val uppedVigorHeroes: Iterable[ChangedHeroC] = gs.heroes.map {
      case (hid, h) =>
        val baseChange = heroesAfterStipend.getOrElse(hid, ChangedHeroC(heroId = hid))
        if h.vigor >= h.constitution then baseChange
@@ -243,10 +236,9 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
    val changedHeroes =
      uppedVigorHeroes.filter(ch => ch.hasChanges).toVector

-    val newDateProto    = DateConverter.toProto(newDate)
-    val changedFactions = startingState.factions.values.map { f =>
+    val changedFactions = gs.factions.values.map { f =>
      val removedTruces =
-        f.factionRelationships.filter(fr => fr.resetDate.exists(_ < newDateProto))
+        f.factionRelationships.filter(fr => fr.resetDate.exists(dateBefore(_, newDate)))

      ChangedFactionC(
        factionId = f.id,
@@ -257,15 +249,15 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
            resetDate = None,
            trustValue = fr.trustValue
          )
-        }.toVector,
-        trustLevelUpdates = startingState.factions.keys.filterNot(_ == f.id).toVector.map { targetFid =>
+        },
+        trustLevelUpdates = gs.factions.keys.filterNot(_ == f.id).toVector.map { targetFid =>
          TrustLevelUpdate(targetFid, TrustDeltaPerRound.intValue)
        },
        clearLastActedProvinceId = true
      )
    }.toVector

-    val llmRequests = chronicleLlmRequests(newDate, startingState)
+    val llmRequests = chronicleLlmRequests(newDate, gs)

    ActionResultC(
      actionResultType = NewRoundActionResultType,
@@ -286,21 +278,21 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
  }

  private def changedHeroesAfterOverage(
-      gameState: GameStateProto,
+      gs: GameState,
      provinceId: ProvinceId
  ): Vector[ChangedHeroC] = {
-    val province           = gameState.provinces(provinceId)
+    val province           = gs.provinces(provinceId)
    val notRecentHeroCount = province.rulingFactionHeroIds
-      .map(gameState.heroes)
+      .map(gs.heroes)
      .flatMap(_.roundIdJoined)
-      .count(roundId => gameState.currentRoundId - roundId > MinimumRoundsBeforeLoyaltyDegrades.intValue)
+      .count(roundId => gs.currentRoundId - roundId > MinimumRoundsBeforeLoyaltyDegrades.intValue)
    if province.heroCap >= notRecentHeroCount then Vector.empty
    else {
      val loyaltyHit =
        OverHeroCapLoyaltyDelta.doubleValue * (notRecentHeroCount - province.heroCap)

      province.rulingFactionHeroIds
-        .map(gameState.heroes)
+        .map(gs.heroes)
        .map(h =>
          ChangedHeroC(
            heroId = h.id,
@@ -309,7 +301,6 @@ case class NewRoundAction(gameState: GameState, gameHistory: GameHistory)
              else StatDelta(loyaltyHit)
          )
        )
-        .toVector
    }
    end if
  }
@@ -1,65 +1,50 @@
 package net.eagle0.eagle.library.actions.impl.action

-import net.eagle0.eagle.common.action_result_type.ActionResultType.{
-  END_FORCED_TURN_BACK_PHASE,
-  WEATHER_FORCED_SUPPLIES_BACK,
-  WEATHER_FORCED_SUPPLIES_LOST,
-  WEATHER_FORCED_TURN_BACK
-}
-import net.eagle0.eagle.common.round_phase.NewRoundPhase
-import net.eagle0.eagle.common.round_phase.RoundPhase.PROVINCE_MOVE_RESOLUTION
-import net.eagle0.eagle.internal.action_result.ActionResult
-import net.eagle0.eagle.internal.army.MovingArmy
-import net.eagle0.eagle.internal.changed_province.ChangedProvince
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.internal.province.Province
-import net.eagle0.eagle.internal.supplies.MovingSupplies
-import net.eagle0.eagle.library.actions.applier.ActionResultProtoApplier
-import net.eagle0.eagle.library.actions.impl.common.DeterministicSequentialResultsAction
+import net.eagle0.eagle.library.actions.impl.common.ProtolessSequentialResultsAction
 import net.eagle0.eagle.library.actions.util.ShatteredArmyUtils
 import net.eagle0.eagle.library.settings.WinterSuppliesLoss
-import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
-import net.eagle0.eagle.model.action_result.NotificationDetails.ShatteredArmy.Reason.Blizzard
-import net.eagle0.eagle.model.proto_converters.{ActionResultProtoConverter, ArmyConverter}
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
+import net.eagle0.eagle.library.util.province.ProvinceUtils
+import net.eagle0.eagle.model.action_result.{ActionResultT, NotificationDetails}
+import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
+import net.eagle0.eagle.model.action_result.concrete.ActionResultC
+import net.eagle0.eagle.model.action_result.types.{
+  EndForcedTurnBackPhaseResultType,
+  WeatherForcedSuppliesBackResultType,
+  WeatherForcedSuppliesLostResultType,
+  WeatherForcedTurnBackResultType
+}
+import net.eagle0.eagle.model.state.{MovingArmy, MovingSupplies, RoundPhase, Supplies}
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.ProvinceT
+import net.eagle0.eagle.RoundId

-case class PerformForcedTurnBackAction(gs: GameState) extends DeterministicSequentialResultsAction(gs) {
+case class PerformForcedTurnBackAction(gameState: GameState) extends ProtolessSequentialResultsAction {

-  val endPhaseResult: ActionResult = ActionResult(
-    `type` = END_FORCED_TURN_BACK_PHASE,
-    newRoundPhase = Some(NewRoundPhase(PROVINCE_MOVE_RESOLUTION))
+  val endPhaseResult: ActionResultT = ActionResultC(
+    actionResultType = EndForcedTurnBackPhaseResultType,
+    newRoundPhase = Some(RoundPhase.ProvinceMoveResolution)
  )

-  private def oneTurnBackSuppliesResult(is: MovingSupplies, p: Province) =
+  private def oneTurnBackSuppliesResult(is: MovingSupplies, p: ProvinceT): ActionResultT =
    is.originProvinceId.map { originPid =>
-      ActionResult(
-        `type` = WEATHER_FORCED_SUPPLIES_BACK,
-        player = Some(is.factionId),
-        province = Some(p.id),
+      ActionResultC(
+        actionResultType = WeatherForcedSuppliesBackResultType,
+        actingFactionId = Some(is.factionId),
+        provinceId = Some(p.id),
        changedProvinces = Vector(
-          ChangedProvince(
-            id = p.id,
+          ChangedProvinceC(
+            provinceId = p.id,
            removedIncomingShipmentIds = Vector(is.id)
          ),
-          ChangedProvince(
-            id = originPid,
-            addedIncomingShipments = Vector(
+          ChangedProvinceC(
+            provinceId = originPid,
+            newIncomingShipments = Vector(
              MovingSupplies(
-                supplies = is.supplies.map {
-                  _.update(
-                    _.food.modify(f =>
-                      Math
-                        .floor((1.0 - WinterSuppliesLoss.doubleValue) * f)
-                        .toInt
-                    ),
-                    _.gold.modify(g =>
-                      Math
-                        .floor((1.0 - WinterSuppliesLoss.doubleValue) * g)
-                        .toInt
-                    )
-                  )
-                },
-                arrivalRound = gs.currentRoundId + 1,
+                supplies = Supplies(
+                  gold = Math.floor((1.0 - WinterSuppliesLoss.doubleValue) * is.supplies.gold).toInt,
+                  food = Math.floor((1.0 - WinterSuppliesLoss.doubleValue) * is.supplies.food).toInt
+                ),
+                arrivalRound = gameState.currentRoundId + 1,
                destinationProvinceId = originPid,
                originProvinceId = None,
                factionId = is.factionId,
@@ -72,36 +57,36 @@ case class PerformForcedTurnBackAction(gs: GameState) extends DeterministicSeque
      )
    }
      .getOrElse(
-        ActionResult(
-          `type` = WEATHER_FORCED_SUPPLIES_LOST,
-          player = Some(is.factionId),
-          province = Some(p.id),
+        ActionResultC(
+          actionResultType = WeatherForcedSuppliesLostResultType,
+          actingFactionId = Some(is.factionId),
+          provinceId = Some(p.id),
          changedProvinces = Vector(
-            ChangedProvince(
-              id = p.id,
+            ChangedProvinceC(
+              provinceId = p.id,
              removedIncomingShipmentIds = Vector(is.id)
            )
          )
        )
      )

-  private def oneTurnBackArmyResult(ia: MovingArmy, p: Province): ActionResult =
-    ia.getArmy.fleeProvinceId.map { fleePid =>
-      ActionResult(
-        `type` = WEATHER_FORCED_TURN_BACK,
-        player = Some(ia.getArmy.factionId),
-        province = Some(ia.destinationProvince),
-        affectedPlayers = (Vector(ia.getArmy.factionId) ++ p.rulingFactionId).distinct,
+  private def oneTurnBackArmyResult(ia: MovingArmy, p: ProvinceT): ActionResultT =
+    ia.army.fleeProvinceId.map { fleePid =>
+      ActionResultC(
+        actionResultType = WeatherForcedTurnBackResultType,
+        actingFactionId = Some(ia.army.factionId),
+        provinceId = Some(ia.destinationProvinceId),
+        affectedFactionIds = (Vector(ia.army.factionId) ++ p.rulingFactionId).distinct,
        changedProvinces = Vector(
-          ChangedProvince(id = p.id, removedIncomingArmyIds = Vector(ia.id)),
-          ChangedProvince(
-            id = fleePid,
-            addedIncomingArmies = Vector(
+          ChangedProvinceC(provinceId = p.id, removedIncomingArmyIds = Vector(ia.id)),
+          ChangedProvinceC(
+            provinceId = fleePid,
+            newIncomingArmies = Vector(
              MovingArmy(
-                army = ia.army.map(_.clearFleeProvinceId),
-                arrivalRound = gs.currentRoundId + 1,
-                destinationProvince = fleePid,
-                originProvince = p.id,
+                army = ia.army.copy(fleeProvinceId = None),
+                arrivalRound = gameState.currentRoundId + 1,
+                destinationProvinceId = fleePid,
+                originProvinceId = p.id,
                supplies = ia.supplies,
                suppliesLoss = ia.suppliesLoss,
                id = ia.id,
@@ -113,35 +98,30 @@ case class PerformForcedTurnBackAction(gs: GameState) extends DeterministicSeque
      )
    }
      .getOrElse(
-        ActionResultProtoConverter.toProto(
-          ShatteredArmyUtils
-            .shatteredArmyResult(
-              currentRoundId = gs.currentRoundId,
-              province = ProvinceConverter.fromProto(p),
-              ma = ArmyConverter.fromProto(ia),
-              reason = Blizzard
-            )
+        ShatteredArmyUtils.shatteredArmyResult(
+          currentRoundId = gameState.currentRoundId,
+          province = p,
+          ma = ia,
+          reason = NotificationDetails.ShatteredArmy.Reason.Blizzard
        )
      )

-  private def turnBackArmiesResults: Vector[ActionResult] =
+  private def turnBackArmiesResults: Vector[ActionResultT] =
    (
      for {
-        p  <- gs.provinces.values.filter(LegacyProvinceUtils.hasBlizzard)
-        ia <- p.incomingArmies.filter(_.arrivalRound == gs.currentRoundId)
+        p  <- gameState.provinces.values.filter(ProvinceUtils.hasBlizzard)
+        ia <- p.incomingArmies.filter(_.arrivalRound == gameState.currentRoundId)
      } yield oneTurnBackArmyResult(ia, p)
    ).toVector

-  private def turnBackSuppliesResults: Vector[ActionResult] =
+  private def turnBackSuppliesResults: Vector[ActionResultT] =
    (
      for {
-        p  <- gs.provinces.values.filter(LegacyProvinceUtils.hasBlizzard)
-        is <- p.incomingShipments.filter(_.arrivalRound == gs.currentRoundId)
+        p  <- gameState.provinces.values.filter(ProvinceUtils.hasBlizzard)
+        is <- p.incomingShipments.filter(_.arrivalRound == gameState.currentRoundId)
      } yield oneTurnBackSuppliesResult(is, p)
    ).toVector

-  override def results(
-      actionResultProtoApplier: ActionResultProtoApplier
-  ): Vector[ActionResult] =
+  override def results: Vector[ActionResultT] =
    turnBackArmiesResults ++ turnBackSuppliesResults :+ endPhaseResult
 }
@@ -1,37 +1,32 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.{HeroId, ProvinceId, RoundId}
-import net.eagle0.eagle.common.action_result_notification_details.{HeroDepartureDetails, Notification}
-import net.eagle0.eagle.common.action_result_notification_details.Notification.Llm
-import net.eagle0.eagle.common.action_result_type.ActionResultType.{END_HERO_DEPARTURE_PHASE, HEROES_DEPARTED}
-import net.eagle0.eagle.common.recruitment_info.RecruitmentInfo
-import net.eagle0.eagle.common.recruitment_info.RecruitmentStatus.RECRUITMENT_STATUS_TRAVELER
-import net.eagle0.eagle.common.round_phase.NewRoundPhase
-import net.eagle0.eagle.common.round_phase.RoundPhase.UNAFFILIATED_HERO_ACTIONS
-import net.eagle0.eagle.common.unaffiliated_hero_type.UnaffiliatedHeroType.UNAFFILIATED_HERO_TRAVELER
-import net.eagle0.eagle.internal.action_result.ActionResult
-import net.eagle0.eagle.internal.changed_hero.ChangedHero
-import net.eagle0.eagle.internal.changed_province.ChangedProvince
-import net.eagle0.eagle.internal.event_for_hero_backstory.{EventForHeroBackstory, HeroDepartedBackstoryEvent}
-import net.eagle0.eagle.internal.game_state.GameState
-import net.eagle0.eagle.internal.generated_text_request.{GeneratedTextRequest, HeroDepartureMessage}
-import net.eagle0.eagle.internal.unaffiliated_hero.UnaffiliatedHero
-import net.eagle0.eagle.library.actions.applier.ActionResultProtoApplier
-import net.eagle0.eagle.library.actions.impl.common.DeterministicSequentialResultsAction
+import net.eagle0.eagle.{FactionId, HeroId, ProvinceId, RoundId}
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
 import net.eagle0.eagle.library.settings.{FactionBiasFromDeparture, LoyaltyThreshold}
-import net.eagle0.eagle.library.util.hero.LegacyHeroUtils
-import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
+import net.eagle0.eagle.library.util.hero.HeroUtils
+import net.eagle0.eagle.library.util.province.ProvinceUtils
+import net.eagle0.eagle.model.action_result.{ActionResultT, NotificationDetails, NotificationT}
+import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
+import net.eagle0.eagle.model.action_result.changed_province.ChangedProvinceT
+import net.eagle0.eagle.model.action_result.concrete.{ActionResultC, ChangedHeroC, NotificationC}
+import net.eagle0.eagle.model.action_result.generated_text_request.LlmRequestT
+import net.eagle0.eagle.model.action_result.generated_text_request.LlmRequestT.HeroDepartureMessage
+import net.eagle0.eagle.model.action_result.types.{EndHeroDeparturePhaseResultType, HeroesDepartedResultType}
+import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.hero.HeroDepartedBackstoryEvent
+import net.eagle0.eagle.model.state.province.ProvinceT
+import net.eagle0.eagle.model.state.unaffiliated_hero.{RecruitmentInfo, UnaffiliatedHeroType}
+import net.eagle0.eagle.model.state.unaffiliated_hero.concrete.UnaffiliatedHeroC
+import net.eagle0.eagle.model.state.RoundPhase

 object PerformHeroDeparturesAction {
  def provinceWithDepartedHeroes(
      gameState: GameState,
-      provinceId: ProvinceId,
+      province: ProvinceT,
      functionalRandom: FunctionalRandom
-  ): RandomState[Option[(ChangedProvince, Vector[HeroId])]] =
-    gameState
-      .provinces(provinceId)
-      .rulingFactionHeroIds
+  ): RandomState[Option[(ChangedProvinceT, Vector[HeroId])]] =
+    province.rulingFactionHeroIds
      .foldLeft(RandomState(Vector.empty[HeroId], functionalRandom)) {
        case (RandomState(acc, fr), hid) =>
          heroWillDepart(gameState, hid, fr).map(departed =>
@@ -43,28 +38,23 @@ object PerformHeroDeparturesAction {
        case items if items.isEmpty => None
        case dh                     =>
          Some(
-            LegacyProvinceUtils.afterHeroDeparture(
-              ChangedProvince(
-                id = provinceId,
-                removedRulingPlayerHeroIds = dh,
+            ProvinceUtils.afterHeroDeparture(
+              ChangedProvinceC(
+                provinceId = province.id,
+                removedRulingFactionHeroIds = dh,
                newUnaffiliatedHeroes = dh.map(hid =>
-                  UnaffiliatedHero(
+                  UnaffiliatedHeroC(
                    heroId = hid,
-                    `type` = UNAFFILIATED_HERO_TRAVELER,
+                    unaffiliatedHeroType = UnaffiliatedHeroType.Traveler,
                    recruitmentAttempted = true,
                    factionBiases = Map(
-                      gameState
-                        .provinces(provinceId)
-                        .rulingFactionId
-                        .get -> FactionBiasFromDeparture.doubleValue
+                      province.rulingFactionId.get -> FactionBiasFromDeparture.doubleValue
                    ),
-                    recruitmentInfo = Some(
-                      RecruitmentInfo(status = RECRUITMENT_STATUS_TRAVELER)
-                    )
+                    recruitmentInfo = RecruitmentInfo.Traveler
                  )
                )
              ),
-              gameState
+              province
            ),
            dh
          )
@@ -77,7 +67,10 @@ object PerformHeroDeparturesAction {
  ): RandomState[Boolean] =
    functionalRandom.nextOddsChance(
      departureOdds(
-        LegacyHeroUtils.effectiveLoyalty(heroId, gameState)
+        HeroUtils.effectiveLoyalty(
+          gameState.heroes(heroId),
+          gameState.factions.values.toVector
+        )
      )
    )

@@ -90,45 +83,47 @@ object PerformHeroDeparturesAction {
  private def notificationForHero(
      hid: HeroId,
      pid: ProvinceId,
-      gameState: GameState
-  ): Notification =
-    Notification(
-      details = HeroDepartureDetails(
+      rulingFactionId: FactionId,
+      currentRoundId: RoundId
+  ): NotificationC =
+    NotificationC(
+      details = NotificationDetails.HeroDeparture(
        departingHeroId = hid,
-        fromFactionId = gameState.provinces(pid).getRulingFactionId,
+        fromFactionId = rulingFactionId,
        provinceId = pid
      ),
-      llm = Llm.LlmId(notificationLlmId(gameState.currentRoundId, hid))
+      llm = NotificationT.Llm.Id(notificationLlmId(currentRoundId, hid)),
+      deferred = false
    )

  private def notificationLlmRequestForHero(
      hid: HeroId,
      pid: ProvinceId,
-      gameState: GameState
-  ): GeneratedTextRequest =
-    GeneratedTextRequest(
-      id = notificationLlmId(gameState.currentRoundId, hid),
-      eagleGameId = gameState.gameId,
-      details = HeroDepartureMessage(
-        departingHeroId = hid,
-        fromFactionId = gameState.provinces(pid).getRulingFactionId,
-        provinceId = pid
-      )
+      rulingFactionId: FactionId,
+      currentRoundId: RoundId,
+      gameId: Long
+  ): LlmRequestT =
+    HeroDepartureMessage(
+      requestId = notificationLlmId(currentRoundId, hid),
+      eagleGameId = gameId,
+      departingHeroId = hid,
+      fromFactionId = rulingFactionId,
+      provinceId = pid
    )
 }

 case class PerformHeroDeparturesAction(
-    startingState: GameState,
-    functionalRandom: FunctionalRandom
-) extends DeterministicSequentialResultsAction(startingState = startingState) {
-  override def results(
-      actionResultProtoApplier: ActionResultProtoApplier
-  ): Vector[ActionResult] =
-    startingState.provinces.values
+    gameState: GameState
+) extends ProtolessRandomSequentialResultsAction {
+
+  override protected def randomResults(
+      functionalRandom: FunctionalRandom
+  ): RandomState[Vector[ActionResultT]] =
+    gameState.provinces.values.toVector
      .filter(_.rulingFactionId.isDefined)
      .foldLeft(
        RandomState(
-          Vector[Option[(ChangedProvince, Vector[HeroId])]](),
+          Vector[Option[(ChangedProvinceT, Vector[HeroId])]](),
          functionalRandom
        )
      ) {
@@ -137,61 +132,58 @@ case class PerformHeroDeparturesAction(
            case (acc, fr) =>
              PerformHeroDeparturesAction
                .provinceWithDepartedHeroes(
-                  startingState,
-                  p.id,
+                  gameState,
+                  p,
                  fr
                )
                .map(tup => acc :+ tup)
          }
      }
      .map(_.flatten)
-      .map {
-        _.map {
+      .map { items =>
+        items.map {
          case (cp, hs) =>
-            ActionResult(
-              `type` = HEROES_DEPARTED,
-              province = Some(cp.id),
-              player = startingState.provinces(cp.id).rulingFactionId,
+            val provinceId      = cp.provinceId
+            val rulingFactionId = gameState.provinces(provinceId).rulingFactionId.get
+            ActionResultC(
+              actionResultType = HeroesDepartedResultType,
+              provinceId = Some(provinceId),
+              actingFactionId = Some(rulingFactionId),
              changedProvinces = Vector(cp),
              changedHeroes = hs.map { hid =>
-                ChangedHero(
-                  id = hid,
+                ChangedHeroC(
+                  heroId = hid,
                  clearFactionId = true,
-                  newBackstoryEvents = Vector(
-                    EventForHeroBackstory(
-                      date = startingState.currentDate,
-                      details = HeroDepartedBackstoryEvent(
-                        departedFromFactionId = startingState.provinces(cp.id).getRulingFactionId,
-                        departedFromProvinceId = cp.id
-                      )
+                  newEventsForHeroBackstory = Vector(
+                    HeroDepartedBackstoryEvent(
+                      date = gameState.currentDate.get,
+                      departedFromFactionId = rulingFactionId,
+                      departedFromProvinceId = provinceId
                    )
                  )
                )
              },
-              notificationsToDeliver = hs.map { hid =>
+              newNotifications = hs.map { hid =>
                PerformHeroDeparturesAction.notificationForHero(
                  hid = hid,
-                  pid = cp.id,
-                  gameState = startingState
+                  pid = provinceId,
+                  rulingFactionId = rulingFactionId,
+                  currentRoundId = gameState.currentRoundId
                )
              },
-              newGeneratedTextRequests = hs.flatMap { hid =>
-                Vector(
-                  PerformHeroDeparturesAction.notificationLlmRequestForHero(
-                    hid = hid,
-                    pid = cp.id,
-                    gameState = startingState
-                  )
+              newGeneratedTextRequests = hs.map { hid =>
+                PerformHeroDeparturesAction.notificationLlmRequestForHero(
+                  hid = hid,
+                  pid = provinceId,
+                  rulingFactionId = rulingFactionId,
+                  currentRoundId = gameState.currentRoundId,
+                  gameId = gameState.gameId
                )
              }
            )
-        }
-      } match {
-      case RandomState(ars, fr) =>
-        ars :+ ActionResult(
-          `type` = END_HERO_DEPARTURE_PHASE,
-          newRoundPhase = Some(NewRoundPhase(value = UNAFFILIATED_HERO_ACTIONS)),
-          newRandomSeed = Some(fr.seed)
+        } :+ ActionResultC(
+          actionResultType = EndHeroDeparturePhaseResultType,
+          newRoundPhase = Some(RoundPhase.UnaffiliatedHeroActions)
        )
-    }
+      }
 }
@@ -1,24 +1,7 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.common.action_result_type.ActionResultType
-import net.eagle0.eagle.common.beast_info.BeastInfo
-import net.eagle0.eagle.common.date.Date
-import net.eagle0.eagle.common.province_event.*
-import net.eagle0.eagle.common.round_phase.NewRoundPhase
-import net.eagle0.eagle.common.round_phase.RoundPhase.FORCED_TURN_BACK
-import net.eagle0.eagle.internal.action_result.ActionResult as ActionResultProto
-import net.eagle0.eagle.internal.battalion.Battalion
-import net.eagle0.eagle.internal.changed_faction.ChangedFaction
-import net.eagle0.eagle.internal.changed_hero.ChangedHero
-import net.eagle0.eagle.internal.changed_hero.ChangedHero.Vigor.VigorDelta
-import net.eagle0.eagle.internal.changed_province.ChangedProvince
-import net.eagle0.eagle.internal.changed_province.ChangedProvince.ProvinceEventsReplacement
-import net.eagle0.eagle.internal.faction.PrestigeModifier
-import net.eagle0.eagle.internal.game_state.GameState as GameStateProto
-import net.eagle0.eagle.internal.province.Province as ProvinceProto
-import net.eagle0.eagle.library.actions.applier.ActionResultProtoApplier
-import net.eagle0.eagle.library.actions.impl.common.RandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
 import net.eagle0.eagle.library.settings.{
  BaseBeastsCount,
  BeastsDurationMonths,
@@ -54,10 +37,33 @@ import net.eagle0.eagle.library.settings.{
  MonthsBetweenRiotsSupportMultiplier,
  RiotEventChance
 }
-import net.eagle0.eagle.library.util.*
-import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
-import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
+import net.eagle0.eagle.library.util.province.ProvinceUtils
+import net.eagle0.eagle.library.util.BeastUtils
+import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
+import net.eagle0.eagle.model.action_result.concrete.{
+  ActionResultC,
+  ChangedBattalionC,
+  ChangedFactionC,
+  ChangedHeroC,
+  StatDelta
+}
+import net.eagle0.eagle.model.action_result.types.ProvinceEventsChangedResultType
+import net.eagle0.eagle.model.action_result.ActionResultT
+import net.eagle0.eagle.model.state.{BeastInfo, RoundPhase}
+import net.eagle0.eagle.model.state.date.Date
+import net.eagle0.eagle.model.state.faction.PrestigeModifier
 import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.{
+  BeastsEvent,
+  BlizzardEvent,
+  DroughtEvent,
+  EpidemicEvent,
+  FestivalEvent,
+  FloodEvent,
+  ImminentRiotEvent,
+  ProvinceEvent
+}
+import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.FactionId

 case class ProvinceEventRolls(
@@ -103,20 +109,18 @@ object PerformProvinceEventsAction {
  }

  def beastsCount(
-      p: ProvinceProto,
+      p: ProvinceT,
      beastInfo: BeastInfo,
      beastCountRoll: Double
  ): Int =
-    ((BaseBeastsCount.intValue + LegacyProvinceUtils.effectiveEconomy(
-      p
-    ) * MaxBeastsIncreasePerEconomy.doubleValue) * beastInfo.maxCountMultiplier * beastCountRoll).ceil.toInt
+    ((BaseBeastsCount.intValue + ProvinceUtils.effectiveEconomy(p) * MaxBeastsIncreasePerEconomy.doubleValue) *
+      beastInfo.maxCountMultiplier * beastCountRoll).ceil.toInt
 }

 case class PerformProvinceEventsAction(
    gameState: GameState
-) extends RandomSequentialResultsAction(GameStateConverter.toProto(gameState)) {
-  private val startingState: GameStateProto = GameStateConverter.toProto(gameState)
-  import net.eagle0.eagle.library.util.DateProtoUtils.*
+) extends ProtolessRandomSequentialResultsAction {
+  import PerformProvinceEventsAction.*

  private val blizzardMonths = Set(12, 1, 2)
  private val floodMonths    = Set(6, 7, 8)
@@ -124,17 +128,23 @@ case class PerformProvinceEventsAction(
  private val epidemicMonths = Set(3, 4, 5, 6, 7, 8, 9, 10)
  private val droughtMonths  = Set(6, 7, 8, 9)

-  override def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultProtoApplier: ActionResultProtoApplier
-  ): RandomState[Vector[ActionResultProto]] =
-    if startingState.currentRoundId <= MinimumMonthsBeforeFirstProvinceEvents.intValue
-    then
+  private def currentDate: Date = gameState.currentDate.get
+  private def currentMonth: Int = currentDate.month.value
+
+  private def isUnderAttack(p: ProvinceT): Boolean =
+    p.incomingArmies
+      .filter(_.arrivalRound == gameState.currentRoundId)
+      .exists(ma => p.rulingFactionId.forall(_ != ma.army.factionId))
+
+  override protected def randomResults(
+      functionalRandom: FunctionalRandom
+  ): RandomState[Vector[ActionResultT]] =
+    if gameState.currentRoundId <= MinimumMonthsBeforeFirstProvinceEvents.intValue then
      RandomState(
        Vector(
-          ActionResultProto(
-            `type` = ActionResultType.PROVINCE_EVENTS_CHANGED,
-            newRoundPhase = Some(NewRoundPhase(value = FORCED_TURN_BACK))
+          ActionResultC(
+            actionResultType = ProvinceEventsChangedResultType,
+            newRoundPhase = Some(RoundPhase.ForcedTurnBack)
          )
        ),
        functionalRandom
@@ -142,14 +152,14 @@ case class PerformProvinceEventsAction(
    else
      changedProvinces(functionalRandom).map { cps =>
        Vector(
-          ActionResultProto(
-            `type` = ActionResultType.PROVINCE_EVENTS_CHANGED,
-            newRoundPhase = Some(NewRoundPhase(value = FORCED_TURN_BACK)),
+          ActionResultC(
+            actionResultType = ProvinceEventsChangedResultType,
+            newRoundPhase = Some(RoundPhase.ForcedTurnBack),
            changedProvinces = cps,
            changedBattalions = changedBattalions,
            changedHeroes = changedHeroes,
-            changedFactions = startingState.provinces.values
-              .foldLeft(Map[FactionId, ChangedFaction]()) {
+            changedFactions = gameState.provinces.values
+              .foldLeft(Map.empty[FactionId, ChangedFactionC]) {
                case (acc, p) =>
                  changedFaction(acc, p)
              }
@@ -159,229 +169,171 @@ case class PerformProvinceEventsAction(
        )
      }

-  def changedProvinces(
+  private def changedProvinces(
      fr: FunctionalRandom
-  ): RandomState[Vector[ChangedProvince]] =
-    startingState.provinces.values
-      .foldLeft(RandomState(Vector.empty[ChangedProvince], fr)) {
+  ): RandomState[Vector[ChangedProvinceC]] =
+    gameState.provinces.values
+      .foldLeft(RandomState(Vector.empty[ChangedProvinceC], fr)) {
        case (RandomState(acc, newR), province) =>
          ProvinceEventRolls.nextRolls(newR).map { rolls =>
            acc ++ changedProvince(province, rolls)
          }
      }

-  def changedProvinceFromEvents(
-      p: ProvinceProto,
-      cp: ChangedProvince,
+  private def changedProvinceFromEvents(
+      p: ProvinceT,
+      startingCp: ChangedProvinceC,
      epidemicEndRoll: Double
-  ): ChangedProvince =
-    p.activeEvents.foldLeft(cp) {
-      case (cp, event) =>
-        event match {
-          case _: BlizzardEvent                                          =>
-            cp.update(
-              _.optionalEconomyDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(0.0) + BlizzardEconomyDevastationDelta.doubleValue
-                )
-              ),
-              _.optionalAgricultureDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(
-                    0.0
-                  ) + BlizzardAgricultureDevastationDelta.doubleValue
-                )
-              ),
-              _.optionalInfrastructureDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(
-                    0.0
-                  ) + BlizzardInfrastructureDevastationDelta.doubleValue
-                )
-              )
+  ): ChangedProvinceC =
+    p.activeEvents.foldLeft(startingCp) { (cp: ChangedProvinceC, event: ProvinceEvent) =>
+      event match {
+        case _: BlizzardEvent                =>
+          cp.copy(
+            economyDevastationDelta =
+              Some(cp.economyDevastationDelta.getOrElse(0.0) + BlizzardEconomyDevastationDelta.doubleValue),
+            agricultureDevastationDelta =
+              Some(cp.agricultureDevastationDelta.getOrElse(0.0) + BlizzardAgricultureDevastationDelta.doubleValue),
+            infrastructureDevastationDelta = Some(
+              cp.infrastructureDevastationDelta.getOrElse(0.0) + BlizzardInfrastructureDevastationDelta.doubleValue
            )
-          case _: FloodEvent                                             =>
-            cp.update(
-              _.optionalAgricultureDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(
-                    0.0
-                  ) + (MaxFloodAgricultureDevastationDelta.doubleValue - p.infrastructure * FloodDevastationDeltaReductionPerInfrastructure.doubleValue)
-                    .max(0.0)
-                )
-              ),
-              _.optionalInfrastructureDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(
-                    0.0
-                  ) + (MaxFloodInfrastructureDevastationDelta.doubleValue - p.infrastructure * FloodDevastationDeltaReductionPerInfrastructure.doubleValue)
-                    .max(0.0)
-                )
-              )
+          )
+        case _: FloodEvent                   =>
+          cp.copy(
+            agricultureDevastationDelta = Some(
+              cp.agricultureDevastationDelta.getOrElse(0.0) +
+                (MaxFloodAgricultureDevastationDelta.doubleValue -
+                  p.infrastructure * FloodDevastationDeltaReductionPerInfrastructure.doubleValue).max(0.0)
+            ),
+            infrastructureDevastationDelta = Some(
+              cp.infrastructureDevastationDelta.getOrElse(0.0) +
+                (MaxFloodInfrastructureDevastationDelta.doubleValue -
+                  p.infrastructure * FloodDevastationDeltaReductionPerInfrastructure.doubleValue).max(0.0)
            )
-          case BeastsEvent(_, _, _, beastInfo, _ /* unknownFieldSet */ ) =>
-            beastInfo.map { beast =>
-              cp.update(
-                _.optionalEconomyDevastationDelta.modify(dd =>
-                  Some(dd.getOrElse(0.0) + beast.economyDevastation)
-                    .filterNot(_ == 0.0)
-                ),
-                _.optionalAgricultureDevastationDelta.modify(dd =>
-                  Some(dd.getOrElse(0.0) + beast.agricultureDevastation)
-                    .filterNot(_ == 0.0)
-                ),
-                _.optionalInfrastructureDevastationDelta.modify(dd =>
-                  Some(dd.getOrElse(0.0) + beast.infrastructureDevastation)
-                    .filterNot(_ == 0.0)
-                ),
-                _.optionalSupportDelta.modify(sd => Some(sd.getOrElse(0.0) - BeastsSupportDamage.doubleValue))
-              )
-            }
-              .getOrElse(cp)
-          case _: FestivalEvent                                          =>
-            cp.update(
-              _.optionalSupportDelta.modify(sd => Some(sd.getOrElse(0.0) + FestivalSupportDelta.doubleValue))
-            )
-          case _: EpidemicEvent                                          =>
-            cp.update(
-              _.optionalEconomyDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(0.0) + EpidemicEconomyDevastationDelta.doubleValue
-                )
-              ),
-              _.optionalNewProvinceEvents := Option.when(
-                !epidemicMonths.contains(startingState.currentDate.get.month) ||
-                  epidemicEndRoll < EpidemicEndChance.doubleValue
-              ) {
-                ProvinceEventsReplacement(
-                  newEvents = cp.newProvinceEvents
-                    .map(_.newEvents)
-                    .getOrElse(p.activeEvents)
-                    .filterNot(ProvinceEventUtils.isEpidemicEvent)
-                )
-              }
-            )
-          case _: DroughtEvent                                           =>
-            cp.update(
-              _.optionalAgricultureDevastationDelta.modify(dd =>
-                Some(
-                  dd.getOrElse(
-                    0.0
-                  ) + DroughtAgricultureDevastationDelta.doubleValue
-                )
-              )
-            )
-
-          case _: ImminentRiotEvent => cp
-          case ProvinceEvent.Empty  => cp
-        }
+          )
+        case BeastsEvent(_, _, _, beastInfo) =>
+          cp.copy(
+            economyDevastationDelta =
+              Some(cp.economyDevastationDelta.getOrElse(0.0) + beastInfo.economyDevastation).filterNot(_ == 0.0),
+            agricultureDevastationDelta = Some(
+              cp.agricultureDevastationDelta.getOrElse(0.0) + beastInfo.agricultureDevastation
+            ).filterNot(_ == 0.0),
+            infrastructureDevastationDelta = Some(
+              cp.infrastructureDevastationDelta.getOrElse(0.0) + beastInfo.infrastructureDevastation
+            ).filterNot(_ == 0.0),
+            supportDelta = Some(cp.supportDelta.getOrElse(0.0) - BeastsSupportDamage.doubleValue)
+          )
+        case _: FestivalEvent                =>
+          cp.copy(
+            supportDelta = Some(cp.supportDelta.getOrElse(0.0) + FestivalSupportDelta.doubleValue)
+          )
+        case _: EpidemicEvent                =>
+          val shouldEndEpidemic =
+            !epidemicMonths.contains(currentMonth) || epidemicEndRoll < EpidemicEndChance.doubleValue
+          cp.copy(
+            economyDevastationDelta =
+              Some(cp.economyDevastationDelta.getOrElse(0.0) + EpidemicEconomyDevastationDelta.doubleValue),
+            newProvinceEvents =
+              if shouldEndEpidemic then
+                Some(cp.newProvinceEvents.getOrElse(p.activeEvents).filterNot {
+                  case _: EpidemicEvent => true; case _ => false
+                })
+              else cp.newProvinceEvents
+          )
+        case _: DroughtEvent                 =>
+          cp.copy(
+            agricultureDevastationDelta =
+              Some(cp.agricultureDevastationDelta.getOrElse(0.0) + DroughtAgricultureDevastationDelta.doubleValue)
+          )
+        case _: ImminentRiotEvent            => cp
+      }
    }

-  def blizzardDurationMonths(currentMonth: Int): FactionId =
+  private def blizzardDurationMonths(currentMonth: Int): Int =
    (11 + MaxBlizzardDurationMonths.intValue - currentMonth) % 12

-  def newBlizzardEvent(
-      province: ProvinceProto,
+  private def newBlizzardEvent(
+      province: ProvinceT,
      blizzardEventRoll: Double
  ): Option[ProvinceEvent] =
    Option.when(
-      blizzardMonths
-        .contains(startingState.currentDate.get.month)
-        && !LegacyProvinceUtils.hasBlizzard(province)
+      blizzardMonths.contains(currentMonth)
+        && !ProvinceUtils.hasBlizzard(province)
        && blizzardEventRoll < BlizzardEventChance.doubleValue
    ) {
      BlizzardEvent(
-        startDate = Some(startingState.currentDate.get),
-        endDate = Some(
-          startingState.currentDate.get.addMonths(
-            blizzardDurationMonths(startingState.currentDate.get.month)
-          )
-        )
+        startDate = currentDate,
+        endDate = currentDate.addMonths(blizzardDurationMonths(currentMonth))
      )
    }

-  def newDroughtEvent(
-      province: ProvinceProto,
+  private def newDroughtEvent(
+      province: ProvinceT,
      droughtEventRoll: Double
  ): Option[ProvinceEvent] =
    Option.when(
-      droughtMonths
-        .contains(startingState.currentDate.get.month)
-        && !LegacyProvinceUtils.hasDrought(province)
-        && !LegacyProvinceUtils.hasFlood(province)
+      droughtMonths.contains(currentMonth)
+        && !ProvinceUtils.hasDrought(province)
+        && !ProvinceUtils.hasFlood(province)
        && droughtEventRoll < DroughtEventChance.doubleValue
    ) {
      DroughtEvent(
-        startDate = Some(startingState.currentDate.get),
-        endDate = Some(
-          startingState.currentDate.get.addMonths(
-            DroughtDurationMonths.intValue
-          )
-        )
+        startDate = currentDate,
+        endDate = currentDate.addMonths(DroughtDurationMonths.intValue)
      )
    }

-  def newFloodEvent(
-      province: ProvinceProto,
+  private def newFloodEvent(
+      province: ProvinceT,
      floodEventRoll: Double
  ): Option[ProvinceEvent] =
    Option.when(
-      floodMonths
-        .contains(startingState.currentDate.get.month)
-        && !LegacyProvinceUtils.hasFlood(province)
-        && !LegacyProvinceUtils.hasDrought(province)
+      floodMonths.contains(currentMonth)
+        && !ProvinceUtils.hasFlood(province)
+        && !ProvinceUtils.hasDrought(province)
        && floodEventRoll < FloodEventChance.doubleValue
    ) {
      FloodEvent(
-        startDate = Some(startingState.currentDate.get),
-        endDate = Some(
-          startingState.currentDate.get.addMonths(FloodDurationMonths.intValue)
-        )
+        startDate = currentDate,
+        endDate = currentDate.addMonths(FloodDurationMonths.intValue)
      )
    }

-  def newFestivalEvent(
-      province: ProvinceProto,
+  private def newFestivalEvent(
+      province: ProvinceT,
      festivalEventRoll: Double
  ): Option[ProvinceEvent] =
    Option.when(
-      festivalMonths
-        .contains(startingState.currentDate.get.month)
-        && !LegacyProvinceUtils.hasBlizzard(province)
-        && !LegacyProvinceUtils.hasDrought(province)
-        && !LegacyProvinceUtils.hasFestival(province)
+      festivalMonths.contains(currentMonth)
+        && !ProvinceUtils.hasBlizzard(province)
+        && !ProvinceUtils.hasDrought(province)
+        && !ProvinceUtils.hasFestival(province)
        && festivalEventRoll < FestivalEventChance.doubleValue
    ) {
      FestivalEvent(
-        startDate = Some(startingState.currentDate.get),
-        endDate = Some(
-          startingState.currentDate.get.addMonths(
-            MaxFestivalDurationMonths.intValue
-          )
-        )
+        startDate = currentDate,
+        endDate = currentDate.addMonths(MaxFestivalDurationMonths.intValue)
      )
    }

-  def newEpidemicEvent(
-      province: ProvinceProto,
+  private def newEpidemicEvent(
+      province: ProvinceT,
      epidemicRoll: Double
  ): Option[ProvinceEvent] =
    Option.when(
-      epidemicMonths
-        .contains(startingState.currentDate.get.month)
-        && !LegacyProvinceUtils.hasEpidemic(province)
-        && (epidemicRoll < EpidemicBreakoutChance.doubleValue || (province.neighbors
-          .map(_.provinceId)
-          .map(startingState.provinces)
-          .exists(
-            LegacyProvinceUtils.hasEpidemic
-          ) && epidemicRoll < EpidemicSpreadChance.doubleValue))
+      epidemicMonths.contains(currentMonth)
+        && !ProvinceUtils.hasEpidemic(province)
+        && (epidemicRoll < EpidemicBreakoutChance.doubleValue ||
+          (province.neighbors
+            .map(_.provinceId)
+            .map(gameState.provinces)
+            .exists(ProvinceUtils.hasEpidemic)
+            && epidemicRoll < EpidemicSpreadChance.doubleValue))
    ) {
-      EpidemicEvent(startDate = Some(startingState.currentDate.get))
+      EpidemicEvent(startDate = currentDate)
    }

-  def newBeastsEvent(
-      province: ProvinceProto,
+  private def newBeastsEvent(
+      province: ProvinceT,
      beastsEventRoll: Double,
      beastTypeRoll: Double,
      beastCountRoll: Double
@@ -390,71 +342,60 @@ case class PerformProvinceEventsAction(
      province.lastBeastsDate.isEmpty ||
        province.lastBeastsDate.exists(lbd =>
          lbd.addMonths(
-            (MonthsBetweenBeastsInfrastructureMultiplier.doubleValue * LegacyProvinceUtils
-              .effectiveInfrastructure(province)).floor.toInt
-          ) < startingState.currentDate.get
+            (MonthsBetweenBeastsInfrastructureMultiplier.doubleValue * ProvinceUtils.effectiveInfrastructure(
+              province
+            )).floor.toInt
+          ) < currentDate
        )

    Option.when(
      hasBeenLongEnough
        && beastsEventRoll < BeastsEventChance.doubleValue
-        && !LegacyProvinceUtils.hasBeasts(province)
-        && !LegacyProvinceUtils.hasFestival(province)
+        && !ProvinceUtils.hasBeasts(province)
+        && !ProvinceUtils.hasFestival(province)
        && province.rulingFactionId.isDefined
    ) {
      val beastInfo = PerformProvinceEventsAction.beastType(beastTypeRoll)
      BeastsEvent(
-        count = PerformProvinceEventsAction
-          .beastsCount(province, beastInfo, beastCountRoll),
-        startDate = Some(startingState.currentDate.get),
-        endDate = Some(
-          startingState.currentDate.get.addMonths(BeastsDurationMonths.intValue)
-        ),
-        beastInfo = Some(beastInfo)
+        count = PerformProvinceEventsAction.beastsCount(province, beastInfo, beastCountRoll),
+        startDate = currentDate,
+        endDate = currentDate.addMonths(BeastsDurationMonths.intValue),
+        beastInfo = beastInfo
      )
    }
  }

-  def newImminentRiotEvent(
-      province: ProvinceProto,
+  private def newImminentRiotEvent(
+      province: ProvinceT,
      riotEventRoll: Double
  ): Option[ProvinceEvent] = {
    val hasBeenLongEnough =
      province.lastRiotDate.isEmpty ||
-        province.lastRiotDate.exists(lbd =>
-          lbd.addMonths(
+        province.lastRiotDate.exists(lrd =>
+          lrd.addMonths(
            (MonthsBetweenRiotsSupportMultiplier.doubleValue * province.support).floor.toInt
-          ) < startingState.currentDate.get
+          ) < currentDate
        )

+    val hasActiveBeastsWithFutureEnd = province.activeEvents.exists {
+      case BeastsEvent(_, _, endDate, _) => endDate > currentDate
+      case _                             => false
+    }
+
    Option.when(
-      hasBeenLongEnough &&
-        riotEventRoll < RiotEventChance.doubleValue
+      hasBeenLongEnough
+        && riotEventRoll < RiotEventChance.doubleValue
        && province.support >= MinSupportForTaxes.doubleValue
-        && !IncomingArmyUtils.isUnderAttack(province, startingState)
-        && !LegacyProvinceUtils.hasEvent(
-          province,
-          {
-            case BeastsEvent(
-                  _: Int,
-                  _: Option[Date],
-                  endDate: Option[Date],
-                  _: Option[BeastInfo],
-                  _ /* unknownFieldSet */
-                ) =>
-              endDate.exists(_ > startingState.currentDate.get)
-            case _ => false
-          }
-        )
-        && !LegacyProvinceUtils.hasFestival(province)
+        && !isUnderAttack(province)
+        && !hasActiveBeastsWithFutureEnd
+        && !ProvinceUtils.hasFestival(province)
    ) {
      ImminentRiotEvent()
    }
  }

-  // We won't riot while there are beasts or a festival
-  def newProvinceEvents(
-      province: ProvinceProto,
+  private def newProvinceEvents(
+      province: ProvinceT,
      provinceEventRolls: ProvinceEventRolls
  ): Vector[ProvinceEvent] =
    newBlizzardEvent(province, provinceEventRolls.blizzardRoll)
@@ -469,34 +410,28 @@ case class PerformProvinceEventsAction(
          beastCountRoll = provinceEventRolls.beastCountRoll
        )
      )
-      .orElse(
-        newImminentRiotEvent(province, provinceEventRolls.riotRoll)
-      )
-      .orElse(
-        newEpidemicEvent(province, provinceEventRolls.epidemicStartRoll)
-      )
+      .orElse(newImminentRiotEvent(province, provinceEventRolls.riotRoll))
+      .orElse(newEpidemicEvent(province, provinceEventRolls.epidemicStartRoll))
      .toVector

-  def changedFaction(
-      existingCFs: Map[FactionId, ChangedFaction],
-      province: ProvinceProto
-  ): Map[FactionId, ChangedFaction] =
+  private def changedFaction(
+      existingCFs: Map[FactionId, ChangedFactionC],
+      province: ProvinceT
+  ): Map[FactionId, ChangedFactionC] =
    province.rulingFactionId.map { fid =>
-      val existingCf =
-        existingCFs.getOrElse(fid, ChangedFaction(id = fid))
+      val existingCf = existingCFs.getOrElse(fid, ChangedFactionC(factionId = fid))

-      val newCf = province.activeEvents.foldLeft(existingCf) {
-        case (cf, event) =>
-          event match {
-            case _: FestivalEvent =>
-              cf.update(
-                _.addedPrestigeModifiers :+= PrestigeModifier(
-                  `type` = PrestigeModifier.Type.FESTIVAL,
-                  value = FestivalPrestigeDelta.doubleValue
-                )
+      val newCf = province.activeEvents.foldLeft(existingCf) { (cf: ChangedFactionC, event: ProvinceEvent) =>
+        event match {
+          case _: FestivalEvent =>
+            cf.copy(
+              newPrestigeModifiers = cf.newPrestigeModifiers :+ PrestigeModifier(
+                prestigeModifierType = PrestigeModifier.Type.Festival,
+                value = FestivalPrestigeDelta.doubleValue
              )
-            case _                => cf
-          }
+            )
+          case _                => cf
+        }
      }

      if newCf == existingCf then existingCFs
@@ -504,37 +439,37 @@ case class PerformProvinceEventsAction(
    }
      .getOrElse(existingCFs)

-  def changedHeroes: Vector[ChangedHero] =
-    startingState.provinces.values
-      .filter(LegacyProvinceUtils.hasEpidemic)
+  private def changedHeroes: Vector[ChangedHeroC] =
+    gameState.provinces.values
+      .filter(ProvinceUtils.hasEpidemic)
      .flatMap(p => p.rulingFactionHeroIds ++ p.unaffiliatedHeroes.map(_.heroId))
-      .map(startingState.heroes)
-      .map(hero =>
-        ChangedHero(
-          id = hero.id,
-          vigor = VigorDelta(EpidemicVigorDelta.doubleValue)
+      .map(hid =>
+        ChangedHeroC(
+          heroId = hid,
+          vigorChange = StatDelta(EpidemicVigorDelta.doubleValue)
        )
      )
      .toVector

-  def changedBattalions: Vector[Battalion] =
-    startingState.provinces.values
-      .filter(LegacyProvinceUtils.hasEpidemic)
+  private def changedBattalions: Vector[ChangedBattalionC] =
+    gameState.provinces.values
+      .filter(ProvinceUtils.hasEpidemic)
      .flatMap(_.battalionIds)
-      .map(startingState.battalions)
+      .map(gameState.battalions)
      .map(b =>
-        b.update(
-          _.size
-            .modify(s => (s * (1.0 - EpidemicBattalionLossPercentage.doubleValue)).toInt)
+        ChangedBattalionC(
+          to = b.updateWith(
+            size = (b.size * (1.0 - EpidemicBattalionLossPercentage.doubleValue)).toInt
+          )
        )
      )
      .toVector

-  def changedProvince(
-      province: ProvinceProto,
+  private[action] def changedProvince(
+      province: ProvinceT,
      provinceEventRolls: ProvinceEventRolls
-  ): Option[ChangedProvince] = {
-    val startingCp = ChangedProvince(id = province.id)
+  ): Option[ChangedProvinceC] = {
+    val startingCp = ChangedProvinceC(provinceId = province.id)

    val fromProvinceEvents = changedProvinceFromEvents(
      province,
@@ -543,36 +478,18 @@ case class PerformProvinceEventsAction(
    )

    val newProvinceEventSet = province.activeEvents.filter {
-      case ProvinceEvent.Empty                                         => ???
-      case DroughtEvent(startDate, endDate, _ /* unknownFieldSet */ )  =>
-        endDate.exists(_ >= startingState.currentDate.get)
-      case BeastsEvent(
-            count,
-            startDate,
-            endDate,
-            beastInfo,
-            _ /* unknownFieldSet */
-          ) =>
-        endDate.exists(_ >= startingState.currentDate.get)
-      case BlizzardEvent(startDate, endDate, _ /* unknownFieldSet */ ) =>
-        endDate.exists(_ >= startingState.currentDate.get)
-      case FestivalEvent(startDate, endDate, _ /* unknownFieldSet */ ) =>
-        endDate.exists(_ >= startingState.currentDate.get)
-      case FloodEvent(startDate, endDate, _ /* unknownFieldSet */ )    =>
-        endDate.exists(_ >= startingState.currentDate.get)
-      case EpidemicEvent(startDate, _ /* unknownFieldSet */ )          => true
-      case ImminentRiotEvent(_ /* unknownFieldSet */ )                 => true
-    } ++ newProvinceEvents(
-      province,
-      provinceEventRolls
-    )
+      case DroughtEvent(_, endDate)      => endDate >= currentDate
+      case BeastsEvent(_, _, endDate, _) => endDate >= currentDate
+      case BlizzardEvent(_, endDate)     => endDate >= currentDate
+      case FestivalEvent(_, endDate)     => endDate >= currentDate
+      case FloodEvent(_, endDate)        => endDate >= currentDate
+      case _: EpidemicEvent              => true
+      case _: ImminentRiotEvent          => true
+    } ++ newProvinceEvents(province, provinceEventRolls)

    val withEventsReplacement =
      if newProvinceEventSet == province.activeEvents then fromProvinceEvents
-      else
-        fromProvinceEvents.withNewProvinceEvents(
-          ProvinceEventsReplacement(newProvinceEventSet)
-        )
+      else fromProvinceEvents.copy(newProvinceEvents = Some(newProvinceEventSet))

    Option.when(withEventsReplacement != startingCp)(withEventsReplacement)
  }
@@ -1,94 +1,64 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.internal.army.MovingArmy
-import net.eagle0.eagle.internal.game_state.GameState as GameStateProto
-import net.eagle0.eagle.internal.province.Province as ProvinceProto
-import net.eagle0.eagle.library.actions.applier.{ActionResultTApplier, ActionResultTWithResultingState}
-import net.eagle0.eagle.library.actions.impl.common.TRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.{ArmyConverter, SuppliesConverter}
-import net.eagle0.eagle.model.proto_converters.faction.FactionConverter
-import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
-import net.eagle0.eagle.model.proto_converters.hero.HeroConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
 import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.ProvinceT
+import net.eagle0.eagle.model.state.MovingArmy

 case class PerformProvinceMoveResolutionAction(
-    gameState: GameState
-) extends TRandomSequentialResultsAction(gameState) {
+    gameState: GameState,
+    actionResultApplier: ActionResultApplier
+) extends ProtolessRandomSequentialResultsAction {

  override protected def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultTApplier: ActionResultTApplier
+      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] = {
-    val startingState                   = GameStateConverter.toProto(gameState)
-    val provincesWithIncomingFriendlies = startingState.provinces.values
+    val provincesWithIncomingFriendlies = gameState.provinces.values
      .filter(_.rulingFactionId.isDefined)
-      .map(p =>
-        (
-          p,
-          p.incomingArmies.filter(ma =>
-            ma.arrivalRound == startingState.currentRoundId && isFriendlyMove(
-              ma,
-              p
-            )
-          )
-        )
-      )
-      .filter(_._2.nonEmpty)
-
-    val movingFriendliesStates = provincesWithIncomingFriendlies
-      .foldLeft(Vector(ActionResultTWithResultingState(null, startingState))) {
-        case (acc, (province, armies)) =>
-          armies.foldLeft(acc) {
-            case (acc2, army) =>
-              acc2 :+ actionResultTApplier.applyActionResult(
-                acc2.last.resultingState,
-                FriendlyMoveAction(
-                  ArmyConverter.fromProto(army),
-                  province.id
-                ).immediateExecute
-              )
-          }
+      .flatMap { province =>
+        val friendlyArmies = province.incomingArmies.filter { ma =>
+          ma.arrivalRound == gameState.currentRoundId && isFriendlyMove(ma, province)
+        }
+        friendlyArmies.map(army => (province.id, army))
      }
+      .toVector

-    val provincesWithIncomingShipments = startingState.provinces.values
-      .map(p =>
-        (
-          p,
-          p.incomingShipments
-            .filter(ma => ma.arrivalRound == startingState.currentRoundId)
-        )
-      )
-      .filter(_._2.nonEmpty)
+    val provincesWithIncomingShipments = gameState.provinces.values.flatMap { province =>
+      val arrivingShipments = province.incomingShipments
+        .filter(_.arrivalRound == gameState.currentRoundId)
+      arrivingShipments.map(shipment => (province.id, shipment))
+    }.toVector

-    val states = provincesWithIncomingShipments
-      .foldLeft(movingFriendliesStates) {
-        case (acc, (province, shipments)) =>
-          shipments.foldLeft(acc) {
-            case (acc2, supplies) =>
-              acc2 :+ actionResultTApplier.applyActionResult(
-                acc2.last.resultingState,
-                ShipmentArrivedAction(
-                  SuppliesConverter.fromProto(supplies),
-                  province.id
-                ).immediateExecute
-              )
-          }
-      }
-      .drop(1)
+    val sequencer = RandomStateSequencer(
+      initialState = gameState,
+      actionResultApplier = actionResultApplier,
+      functionalRandom = functionalRandom
+    )

-    val lastState = states.lastOption.map(_.resultingState).getOrElse(startingState)
-    EndProvinceMoveResolutionPhaseAction(
-      gameId = lastState.gameId,
-      factions = lastState.factions.values.map(FactionConverter.fromProto).toVector,
-      provinces = lastState.provinces.values.toVector.map(ProvinceConverter.fromProto),
-      heroes = lastState.heroes.values.toVector.map(HeroConverter.fromProto)
-    ).randomResults(functionalRandom)
-      .map(states.map(_.actionResult) ++ _)
+    val afterFriendlyMoves = provincesWithIncomingFriendlies.foldLeft(sequencer) {
+      case (seq, (provinceId, movingArmy)) =>
+        seq.withProtolessSimpleAction(_ => FriendlyMoveAction(movingArmy, provinceId))
+    }
+
+    val afterShipments = provincesWithIncomingShipments.foldLeft(afterFriendlyMoves) {
+      case (seq, (provinceId, movingSupplies)) =>
+        seq.withProtolessSimpleAction(_ => ShipmentArrivedAction(movingSupplies, provinceId))
+    }
+
+    afterShipments.withRandomActionResults { (gs, fr) =>
+      EndProvinceMoveResolutionPhaseAction(
+        gameId = gs.gameId,
+        factions = gs.factions.values.toVector,
+        provinces = gs.provinces.values.toVector,
+        heroes = gs.heroes.values.toVector
+      ).randomResults(fr)
+    }.actionResults
  }

-  private def isFriendlyMove(ma: MovingArmy, p: ProvinceProto): Boolean =
-    ma.army.forall(army => p.rulingFactionId.contains(army.factionId))
+  private def isFriendlyMove(ma: MovingArmy, province: ProvinceT): Boolean =
+    province.rulingFactionId.contains(ma.army.factionId)
 }
@@ -1,44 +1,40 @@
 package net.eagle0.eagle.library.actions.impl.action

 import net.eagle0.common.{FunctionalRandom, RandomState}
-import net.eagle0.eagle.internal.game_state.GameState as GameStateProto
-import net.eagle0.eagle.internal.province.IncomingEndTurnAction as IncomingEndTurnActionProto
-import net.eagle0.eagle.library.actions.applier.ActionResultTApplier
-import net.eagle0.eagle.library.actions.impl.common.{RandomStateTSequencer, TRandomSequentialResultsAction}
+import net.eagle0.eagle.library.actions.applier.ActionResultApplier
+import net.eagle0.eagle.library.actions.impl.common.ProtolessRandomSequentialResultsAction
+import net.eagle0.eagle.library.actions.random_state_sequencer.RandomStateSequencer
 import net.eagle0.eagle.library.util.view_filters.ProvinceViewFilter
 import net.eagle0.eagle.library.util.ReturningHeroes
 import net.eagle0.eagle.model.action_result.changed_province.concrete.ChangedProvinceC
 import net.eagle0.eagle.model.action_result.concrete.{ActionResultC, ChangedFactionC, ClientTextVisibilityExtensionC}
 import net.eagle0.eagle.model.action_result.types.{EndReconResolutionPhaseResultType, ReconSucceededResultType}
 import net.eagle0.eagle.model.action_result.ActionResultT
-import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
-import net.eagle0.eagle.model.proto_converters.province.ProvinceConverter
-import net.eagle0.eagle.model.proto_converters.IncomingEndTurnActionConverter
 import net.eagle0.eagle.model.state.game_state.GameState
+import net.eagle0.eagle.model.state.province.{IncomingEndTurnAction, IncomingRecon}
 import net.eagle0.eagle.model.state.RoundPhase
 import net.eagle0.eagle.ProvinceId

 case class PerformReconResolutionAction(
-    gameState: GameState
-) extends TRandomSequentialResultsAction(gameState) {
-
-  private val startingGameState: GameStateProto = GameStateConverter.toProto(gameState)
+    gameState: GameState,
+    actionResultApplier: ActionResultApplier
+) extends ProtolessRandomSequentialResultsAction {

  override protected def randomResults(
-      functionalRandom: FunctionalRandom,
-      actionResultTApplier: ActionResultTApplier
+      functionalRandom: FunctionalRandom
  ): RandomState[Vector[ActionResultT]] =
-    startingGameState.provinces.values
+    gameState.provinces.values
      .foldLeft(
-        RandomStateTSequencer.fromProto(
-          initialStateProto = startingGameState,
-          actionResultApplier = actionResultTApplier,
+        RandomStateSequencer(
+          initialState = gameState,
+          actionResultApplier = actionResultApplier,
          functionalRandom = functionalRandom
        )
      ) {
        case (sequencer, province) =>
-          province.incomingEndTurnActions
-            .filter(_.action.isRecon)
+          province.incomingEndTurnActions.collect {
+            case action @ IncomingEndTurnAction(_, _, _: IncomingRecon) => action
+          }
            .foldLeft(sequencer) {
              case (innerSequencer, action) =>
                innerSequencer.withRandomActionResult {
@@ -55,26 +51,25 @@ case class PerformReconResolutionAction(
        )
      }

-  def oneResult(
+  // Package-private for testing
+  private[action] def oneResult(
      provinceId: ProvinceId,
-      incomingEndTurnAction: IncomingEndTurnActionProto,
+      incomingEndTurnAction: IncomingEndTurnAction,
      functionalRandom: FunctionalRandom
  ): RandomState[ActionResultT] = {
-    val originProvince =
-      startingGameState.provinces(incomingEndTurnAction.fromProvinceId)
+    val originProvince = gameState.provinces(incomingEndTurnAction.fromProvinceId)
    val fromFactionId  = incomingEndTurnAction.fromFactionId
-    val targetProvince = startingGameState.provinces(provinceId)
+    val targetProvince = gameState.provinces(provinceId)

-    val recon = incomingEndTurnAction.getRecon
+    // Extract heroId from the recon action details
+    val heroId = incomingEndTurnAction.details.asInstanceOf[IncomingRecon].heroId

    ReturningHeroes
      .heroesReturningToFaction(
-        hids = Vector(recon.heroId),
+        hids = Vector(heroId),
        factionId = fromFactionId,
-        originProvince = ProvinceConverter.fromProto(originProvince),
-        provinces = startingGameState.provinces.values
-          .map(ProvinceConverter.fromProto)
-          .toVector,
+        originProvince = originProvince,
+        provinces = gameState.provinces.values.toVector,
        functionalRandom = functionalRandom
      )
      .map { returningHeroes =>
@@ -85,35 +80,25 @@ case class PerformReconResolutionAction(
            // the CP for the destination province
            ChangedProvinceC(
              provinceId = provinceId,
-              removedIncomingEndTurnActions = Vector(
-                IncomingEndTurnActionConverter.fromProto(incomingEndTurnAction)
-              )
+              removedIncomingEndTurnActions = Vector(incomingEndTurnAction)
            ),
            // the CP for the acting hero returning
            returningHeroes.changedProvince
          ),
          changedFactions = Vector(
            ChangedFactionC(
-              factionId = incomingEndTurnAction.fromFactionId,
+              factionId = fromFactionId,
              updatedReconnedProvinces = Vector(
-                ProvinceViewFilter
-                  .filteredProvinceView(
-                    targetProvince,
-                    startingGameState
-                    // FIXME: setting factionId to None right now to grab the full info. This
-                    // probably isn't exactly what we want.
-                  )
-                  .withAsOf(startingGameState.currentDate.get)
+                ProvinceViewFilter.filteredProvinceView(
+                  gameState.provinces(provinceId),
+                  gameState
+                )
              )
            )
          ),
          clientTextVisibilityExtensions = targetProvince.rulingFactionHeroIds.map { hid =>
            ClientTextVisibilityExtensionC(
-              textId = startingGameState
-                .heroes(hid)
-                .backstoryVersions
-                .last
-                .textId,
+              textId = gameState.heroes(hid).backstoryTextId,
              recipientFactionIds = Vector(fromFactionId)
            )
          }.toVector
--- a/Show More
+++ b/Show More