Remove cached images before pull to fix digest mismatch

Docker/containerd caches manifests locally which can conflict with
the registry when images are rebuilt with the same tag. Remove the
cached images before pulling to ensure a fresh pull.

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

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

.bazelrc

@@ -26,8 +26,11 @@ common --host_cxxopt="--std=c++23"
 common --javacopt="-Xlint:-options"
 
 # suppress warnings due to https://developer.apple.com/forums/thread/733317
-common --linkopt=-Wl
-common:macos --linkopt=-Wl,-no_warn_duplicate_libraries
+# Use host_linkopt for macOS-specific flags to avoid passing them to Linux cross-compilation
+common:macos --host_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

.gitattributes

@@ -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

.github/workflows/build_sysroot.yml

@@ -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 ")"

.github/workflows/docker_build.yml

@@ -0,0 +1,306 @@
+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
+    outputs:
+      image_tag: ${{ steps.push-eagle.outputs.image_tag }}
+    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
+        id: push-eagle
+        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+        env:
+          DOCKER_CONFIG: ${{ github.workspace }}/.docker
+        run: |
+          set -ex
+
+          # Build the push target to get crane in runfiles
+          bazel build //ci:eagle_server_push
+
+          # Use crane directly for push (avoids OCI->Docker digest mismatch)
+          CRANE="bazel-bin/ci/push_eagle_server_push.sh.runfiles/rules_oci~~oci~oci_crane_darwin_arm64/crane"
+          echo "Using crane: $CRANE"
+
+          # Push with SHA tag
+          GIT_SHA=$(git rev-parse --short=8 HEAD)
+          IMAGE_TAG="registry.digitalocean.com/eagle0/eagle-server:${GIT_SHA}"
+          echo "Pushing eagle image: $IMAGE_TAG"
+          $CRANE push bazel-bin/ci/eagle_server_image "$IMAGE_TAG"
+
+          # Output the full image tag for deploy step
+          echo "image_tag=$IMAGE_TAG" >> $GITHUB_OUTPUT
+
+          # Also update :latest for convenience (but deploy won't use it)
+          echo "Copying to :latest tag"
+          $CRANE copy "$IMAGE_TAG" "registry.digitalocean.com/eagle0/eagle-server:latest"
+
+  build-shardok:
+    runs-on: self-hosted
+    outputs:
+      image_tag: ${{ steps.push-shardok.outputs.image_tag }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          lfs: false
+
+      - name: Build Shardok binary (cross-compile for Linux)
+        run: |
+          set -ex
+
+          # Step 1: Build JUST the binary with cross-compilation
+          # We need --extra_toolchains to force the Linux toolchain to be used
+          # because toolchains_llvm registers with dev_dependency=True
+          echo "=== Building shardok-server binary for linux-x86_64 ==="
+          bazel build \
+            --platforms=//:linux_x86_64 \
+            --extra_toolchains=@llvm_toolchain_linux//:all \
+            //src/main/cpp/net/eagle0/shardok:shardok-server
+
+          # Step 2: Check the binary directly from bazel-bin
+          # bazel-bin is a symlink that points to the correct output directory
+          LINUX_BIN="bazel-bin/src/main/cpp/net/eagle0/shardok/shardok-server"
+          echo "=== Checking binary at: $LINUX_BIN ==="
+
+          if [ ! -f "$LINUX_BIN" ]; then
+            echo "ERROR: Binary not found at $LINUX_BIN"
+            exit 1
+          fi
+
+          # Debug: show what bazel-bin points to
+          echo "bazel-bin symlink target: $(readlink bazel-bin || echo 'not a symlink')"
+
+          # Step 3: Verify it's ELF (Linux) not Mach-O (macOS)
+          echo "=== Verifying binary format ==="
+          MAGIC=$(head -c 4 "$LINUX_BIN" | xxd -p)
+          echo "Binary magic bytes: $MAGIC"
+
+          if [ "$MAGIC" = "7f454c46" ]; then
+            echo "SUCCESS: Binary is ELF format (Linux)"
+          elif [ "$MAGIC" = "cfaeedfe" ] || [ "$MAGIC" = "cffaedfe" ]; then
+            echo "ERROR: Binary is Mach-O format (macOS) - cross-compilation failed!"
+            echo ""
+            echo "Debug info:"
+            echo "- bazel-bin points to: $(readlink bazel-bin)"
+            file "$LINUX_BIN" || true
+            exit 1
+          else
+            echo "WARNING: Unknown binary format: $MAGIC"
+            file "$LINUX_BIN" || true
+          fi
+
+      - name: Build Shardok Docker image
+        id: build-shardok
+        run: |
+          set -ex
+
+          # Build the OCI image with cross-compilation flags
+          bazel build \
+            --platforms=//:linux_x86_64 \
+            --extra_toolchains=@llvm_toolchain_linux//:all \
+            //ci:shardok_server_image
+
+          # The image is output to bazel-bin which is a symlink.
+          # Resolve it now before any other bazel commands change where it points.
+          IMAGE_PATH=$(readlink -f bazel-bin/ci/shardok_server_image)
+          echo "Image path: $IMAGE_PATH"
+          echo "image_path=$IMAGE_PATH" >> $GITHUB_OUTPUT
+
+          # Verify the binary inside the tar layer is ELF
+          echo "=== Verifying binary in image tar ==="
+          BINARY_TAR="bazel-bin/ci/shardok_binary_layer.tar"
+          if [ -f "$BINARY_TAR" ]; then
+            echo "Checking binary in $BINARY_TAR"
+            # Extract just the first 4 bytes of the binary from the tar
+            MAGIC=$(tar -xOf "$BINARY_TAR" app/shardok-server 2>/dev/null | head -c 4 | xxd -p)
+            echo "Binary magic in tar: $MAGIC"
+            if [ "$MAGIC" = "7f454c46" ]; then
+              echo "SUCCESS: Binary in tar is ELF format (Linux)"
+            else
+              echo "ERROR: Binary in tar is NOT ELF format!"
+              echo "This means pkg_tar is packaging the wrong binary."
+              exit 1
+            fi
+          else
+            echo "WARNING: Could not find $BINARY_TAR"
+          fi
+
+      - 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
+        id: push-shardok
+        if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+        env:
+          DOCKER_CONFIG: ${{ github.workspace }}/.docker
+        run: |
+          set -ex
+
+          # Use cross-compiled image path from build step
+          CROSS_IMAGE="${{ steps.build-shardok.outputs.image_path }}"
+          echo "Using cross-compiled image: $CROSS_IMAGE"
+
+          if [ -z "$CROSS_IMAGE" ] || [ ! -d "$CROSS_IMAGE" ]; then
+            echo "ERROR: Cross-compiled image not found at: $CROSS_IMAGE"
+            exit 1
+          fi
+
+          # Get crane from Eagle push target (which doesn't need cross-compilation)
+          # This gives us a macOS crane binary we can actually run.
+          # We can't build shardok_server_push with platform flags because it would
+          # download a Linux crane that can't run on macOS.
+          bazel build //ci:eagle_server_push
+
+          # Find the Darwin crane binary (may be a symlink)
+          RUNFILES="bazel-bin/ci/push_eagle_server_push.sh.runfiles"
+          CRANE=$(find "$RUNFILES" -path "*darwin*" -name crane 2>/dev/null | head -1)
+          if [ -z "$CRANE" ]; then
+            # Fallback to any crane
+            CRANE=$(find "$RUNFILES" -name crane 2>/dev/null | head -1)
+          fi
+          if [ -z "$CRANE" ] || [ ! -e "$CRANE" ]; then
+            echo "ERROR: crane not found. Listing runfiles:"
+            find "$RUNFILES" -name crane 2>/dev/null || true
+            exit 1
+          fi
+          echo "Using crane: $CRANE"
+
+          # Push the cross-compiled image with SHA tag
+          GIT_SHA=$(git rev-parse --short=8 HEAD)
+          IMAGE_TAG="registry.digitalocean.com/eagle0/shardok-server:${GIT_SHA}"
+          echo "Pushing shardok image: $IMAGE_TAG"
+          $CRANE push "$CROSS_IMAGE" "$IMAGE_TAG"
+
+          # Output the full image tag for deploy step
+          echo "image_tag=$IMAGE_TAG" >> $GITHUB_OUTPUT
+
+          # Also update :latest for convenience (but deploy won't use it)
+          echo "Copying to :latest tag"
+          $CRANE copy "$IMAGE_TAG" "registry.digitalocean.com/eagle0/shardok-server:latest"
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [build-eagle, build-shardok]
+    if: github.event_name == 'push' || (github.event_name == 'workflow_dispatch' && github.event.inputs.push_images == 'true')
+    environment: production
+    env:
+      EAGLE_IMAGE: ${{ needs.build-eagle.outputs.image_tag }}
+      SHARDOK_IMAGE: ${{ needs.build-shardok.outputs.image_tag }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Copy config files to droplet
+        uses: appleboy/scp-action@v0.1.7
+        with:
+          host: ${{ secrets.DO_DROPLET_IP }}
+          username: deploy
+          key: ${{ secrets.DO_SSH_KEY }}
+          source: "docker-compose.prod.yml,nginx/nginx.conf"
+          target: "/opt/eagle0"
+
+      - name: Deploy to production droplet
+        uses: appleboy/ssh-action@v1.0.3
+        with:
+          host: ${{ secrets.DO_DROPLET_IP }}
+          username: deploy
+          key: ${{ secrets.DO_SSH_KEY }}
+          script_stop: true
+          envs: EAGLE_IMAGE,SHARDOK_IMAGE
+          script: |
+            set -x
+            cd /opt/eagle0
+
+            # Login to registry
+            echo "${{ secrets.DO_REGISTRY_TOKEN }}" | docker login registry.digitalocean.com -u "${{ secrets.DO_REGISTRY_TOKEN }}" --password-stdin
+
+            # Use exact image tags passed from build jobs (no :latest fallback)
+            echo "Using images: $EAGLE_IMAGE, $SHARDOK_IMAGE"
+
+            # Remove cached images to avoid digest mismatch errors
+            # Docker/containerd caches manifests locally which can conflict with registry
+            echo "Removing cached images to avoid digest conflicts..."
+            docker image rm "$EAGLE_IMAGE" 2>/dev/null || true
+            docker image rm "$SHARDOK_IMAGE" 2>/dev/null || true
+
+            # Pull fresh images with exact SHA tags
+            echo "Pulling Eagle image: $EAGLE_IMAGE"
+            docker pull "${EAGLE_IMAGE}" || { echo "ERROR: Failed to pull eagle image"; exit 1; }
+
+            echo "Pulling Shardok image: $SHARDOK_IMAGE"
+            docker pull "${SHARDOK_IMAGE}" || { echo "ERROR: Failed to pull shardok image"; exit 1; }
+
+            # Also pull other compose images
+            docker pull nginx:alpine || true
+            docker pull certbot/certbot || true
+
+            echo "All images pulled successfully"
+
+            # Force recreate containers to ensure new image is used
+            docker compose -f docker-compose.prod.yml up -d --force-recreate --remove-orphans
+
+            # Restart nginx to pick up new container IPs
+            # (nginx caches DNS at startup, so it needs restart after eagle/shardok)
+            docker compose -f docker-compose.prod.yml restart nginx
+
+            # Wait for health checks
+            sleep 10
+            docker compose -f docker-compose.prod.yml ps
+
+            # Verify containers are using correct images
+            echo "=== Verifying container image tags ==="
+            docker compose -f docker-compose.prod.yml images
+
+            # Cleanup old images
+            docker image prune -f

BUILD.bazel

@@ -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

CLAUDE.md

@@ -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:

MODULE.bazel

@@ -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 = "a06475004fe8003ae7ccb4fe1d5511feb9b27cce4a8826eb1dfd686ed83f3dba",
+    urls = ["https://eagle0-windows.sfo3.digitaloceanspaces.com/sysroot/v3/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,13 @@ 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, OAuth HTTP calls)
+        "com.squareup.okhttp3:okhttp:4.12.0",
+        "com.squareup.okhttp3:okhttp-sse:4.12.0",
+
+        # JWT (for OAuth token handling)
+        "com.nimbusds:nimbus-jose-jwt:9.37.3",
     ],
     duplicate_version_warning = "error",
     fail_if_repin_required = True,
@@ -169,7 +219,6 @@ maven.install(
         "https://repo1.maven.org/maven2",
     ],
 )
-
 use_repo(maven, "maven", "unpinned_maven")
 
 #
@@ -177,6 +226,7 @@ use_repo(maven, "maven", "unpinned_maven")
 #
 
 http_archive = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
+http_file = use_repo_rule("@bazel_tools//tools/build_defs/repo:http.bzl", "http_file")
 
 # GTL (for parallel_hashmap)
 GTL_VERSION = "1.2.0"
@@ -205,6 +255,16 @@ http_archive(
     ],
 )
 
+# Busybox static binary for Docker health checks (provides nc, wget, etc.)
+# https://busybox.net/downloads/binaries/
+http_file(
+    name = "busybox_x86_64",
+    sha256 = "6e123e7f3202a8c1e9b1f94d8941580a25135382b99e8d3e34fb858bba311348",
+    urls = ["https://busybox.net/downloads/binaries/1.35.0-x86_64-linux-musl/busybox"],
+    downloaded_file_path = "busybox",
+    executable = True,
+)
+
 #
 # Toolchain Registration
 #
@@ -217,5 +277,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,
 )

MODULE.bazel.lock

@@ -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~"
-          ]
-        ]
-      }
     }
   }
 }

ci/BUILD.bazel

@@ -0,0 +1,152 @@
+load("@rules_oci//oci:defs.bzl", "oci_image", "oci_load", "oci_push")
+load("@rules_pkg//pkg:tar.bzl", "pkg_tar")
+
+#
+# Shared utilities layer (busybox for nc, wget, etc.)
+#
+
+pkg_tar(
+    name = "busybox_layer",
+    srcs = ["@busybox_x86_64//file"],
+    package_dir = "/usr/local/bin",
+    remap_paths = {
+        "file/busybox": "busybox",
+    },
+    symlinks = {
+        "/usr/local/bin/nc": "busybox",
+    },
+)
+
+#
+# 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 = [
+        ":busybox_layer",
+        ":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
+# Note: No remote_tags here - DigitalOcean converts OCI to Docker format,
+# changing the digest and breaking oci_push's tag-by-digest logic.
+# Tagging is handled in the CI workflow using crane copy/tag.
+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 = [
+        ":busybox_layer",
+        ":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
+# Note: No remote_tags here - DigitalOcean converts OCI to Docker format,
+# changing the digest and breaking oci_push's tag-by-digest logic.
+# Tagging is handled in the CI workflow using crane copy/tag.
+oci_push(
+    name = "shardok_server_push",
+    image = ":shardok_server_image",
+    repository = "registry.digitalocean.com/eagle0/shardok-server",
+)

docker-compose.prod.yml

@@ -0,0 +1,89 @@
+# Docker Compose for production deployment
+#
+# Local testing:
+#   Build images: bazel run //ci:eagle_server_load && bazel run //ci:shardok_server_load
+#   Run: docker compose -f docker-compose.prod.yml up
+#
+# Production deployment:
+#   Run: docker compose -f docker-compose.prod.yml up -d
+
+services:
+  eagle:
+    image: ${EAGLE_IMAGE:-registry.digitalocean.com/eagle0/eagle-server:latest}
+    container_name: eagle-server
+    command:
+      - "--gpt-model-name"
+      - "${GPT_MODEL_NAME:-gpt-5.1}"
+      - "--shardok-interface-remote-address"
+      - "shardok:40042"
+    ports:
+      - "40032:40032"
+    environment:
+      OPENAI_API_KEY: "${OPENAI_API_KEY:-}"
+    volumes:
+      - ./saves:/app/saves
+    depends_on:
+      - shardok
+    restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "100m"
+        max-file: "5"
+    healthcheck:
+      test: ["CMD-SHELL", "nc -z localhost 40032 || exit 1"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 30s
+
+  shardok:
+    image: ${SHARDOK_IMAGE:-registry.digitalocean.com/eagle0/shardok-server:latest}
+    container_name: shardok-server
+    ports:
+      - "40042:40042"
+      - "40052:40052"
+    environment:
+      SHARDOK_RESOURCES_PATH: "/app/resources"
+      SHARDOK_MAPS_PATH: "/app/resources/maps"
+      SHARDOK_EAGLE_INTERFACE_ADDRESS: "0.0.0.0:40042"
+    restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "100m"
+        max-file: "5"
+    healthcheck:
+      test: ["CMD-SHELL", "nc -z localhost 40042 || exit 1"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 10s
+
+  nginx:
+    image: nginx:alpine
+    container_name: nginx
+    ports:
+      - "443:443"
+      - "80:80"
+    volumes:
+      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
+      - ./certbot/conf:/etc/letsencrypt:ro
+      - ./certbot/www:/var/www/certbot:ro
+      - ./auth:/etc/nginx/auth:ro
+    depends_on:
+      - eagle
+    restart: unless-stopped
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "50m"
+        max-file: "3"
+
+  certbot:
+    image: certbot/certbot
+    container_name: certbot
+    volumes:
+      - ./certbot/conf:/etc/letsencrypt
+      - ./certbot/www:/var/www/certbot
+    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"

docs/DEPROTO_PLAN.md

@@ -45,11 +45,12 @@
 | 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 | **In Progress** | Converting actions called by RoundPhaseAdvancer to take Scala GameState |
+| Phase 5c: RoundPhaseAdvancer Actions | **Complete** | All actions called by RoundPhaseAdvancer accept Scala GameState |
+| Phase 5d: RoundPhaseAdvancer Itself | **Complete** | RoundPhaseAdvancer.checkForPhaseAdvancement takes Scala GameState |
 
-### Phase 5c Progress
+### Phase 5c/5d Progress (Complete)
 
-Actions called by `RoundPhaseAdvancer` that need to accept Scala `GameState`:
+`RoundPhaseAdvancer.checkForPhaseAdvancement` now accepts Scala `GameState` and `ActionResultApplier` directly (PR #4677).
 
 | Action | PR | Status |
 |--------|-----|--------|
@@ -57,10 +58,16 @@ Actions called by `RoundPhaseAdvancer` that need to accept Scala `GameState`:
 | `PerformForcedTurnBackAction` | #4671 | ✅ Merged |
 | `PerformHeroDeparturesAction` | #4672 | ✅ Merged |
 | `RequestFreeForAllBattlesAction` | #4673 | ✅ Merged |
-| `EndPlayerCommandsPhaseAction` | #4674 | ✅ Created |
-| `EndDiplomacyResolutionPhaseAction` | - | 🔄 In Progress |
-| `EndBattleAftermathPhaseAction` | - | Pending |
-| Other RoundPhaseAdvancer actions | - | Pending |
+| `EndPlayerCommandsPhaseAction` | #4674 | ✅ Merged |
+| `EndDiplomacyResolutionPhaseAction` | #4675 | ✅ Merged |
+| `RoundPhaseAdvancer` itself | #4677 | ✅ Merged |
+
+### EngineImpl Progress
+
+| Change | PR | Status |
+|--------|-----|--------|
+| `recursiveTransform` deleted | #4677 | ✅ Merged |
+| `recursiveTransformT` uses `RandomStateTSequencer` | #4677 | ✅ Merged |
 
 ### Current Architecture
 
@@ -99,7 +106,7 @@ Action.execute()
 ```
 Action.execute()
     → ActionResultT
-    → ActionResultTApplier.applyActionResults()
+    → ActionResultApplier.applyActionResults()
     → GameStateC
 
     (Proto conversion only at boundaries)
@@ -107,17 +114,17 @@ Action.execute()
 
 ### Key Files to Convert
 
-**Tier 1 - Core Applier:**
+**Tier 1 - Core Applier:** ✅ **Complete**
 ```
-src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultProtoApplierImpl.scala
+src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplierImpl.scala
 ```
-Create `ActionResultApplier` that applies `ActionResultT` directly to Scala `GameState`.
+`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:**
+**Tier 2 - RoundPhaseAdvancer:** ✅ **Complete**
 ```
 src/main/scala/net/eagle0/eagle/library/RoundPhaseAdvancer.scala
 ```
-Currently has ~20 calls to `ActionResultProtoConverter.toProto()`. After Tier 1, these become unnecessary.
+Now accepts Scala `GameState` and `ActionResultApplier`. Only converts to proto lazily for `AvailableCommandsFactory` calls.
 
 **Tier 3 - Sequencers:**
 ```
@@ -140,6 +147,32 @@ Modify `RandomStateTSequencer` to thread Scala `GameState` throughout (currently
 4. Once all actions migrated, deprecate/remove proto-based callbacks
 5. Remove `lastStateProto` once no longer used
 
+**RandomStateSequencer Migration Progress** (PR #4679 introduced protoless `RandomStateSequencer`):
+
+| Action | Status |
+|--------|--------|
+| `TruceTurnBackPhaseAction` | ✅ Migrated (PR #4680) |
+| `EndHandleRiotsPhaseAction` | ✅ Migrated (PR #4684) |
+| `PerformVassalCommandsPhaseAction` | ✅ Migrated |
+| `PerformVassalDefenseDecisionsAction` | ✅ Migrated |
+| `EndVassalCommandsPhaseAction` | ✅ Migrated |
+| `PerformReconResolutionAction` | ✅ Migrated |
+| `NewRoundAction` | ✅ Migrated (PR #4698) |
+| `EndBattleAftermathPhaseAction` | ✅ Migrated (PR #4699) |
+| `EndDiplomacyResolutionPhaseAction` | ✅ Migrated |
+| `PerformUnaffiliatedHeroesAction` | ✅ Migrated |
+| `EngineImpl.recursiveTransformT` | ✅ Migrated (PR #4704) |
+| `ProtolessSequentialResultsActionWrapper` | ✅ Migrated (PR #4705) |
+| `LegacyRandomStateTSequencer` | ✅ **Deleted** (PR #4705) |
+
+**TCommandFactory Extraction** (PR #4684):
+
+To enable lightweight mocking of command creation in tests, `TCommandFactory` trait was extracted from `CommandFactory`. This allows tests to mock just the `makeTCommand` method without pulling in all 40+ command dependencies that `CommandFactory` requires.
+
+- `TCommandFactory` - lightweight trait with just `makeTCommand`
+- `CommandFactory extends TCommandFactory` - maintains backward compatibility
+- Actions accepting command factories now use `TCommandFactory` type for better testability
+
 **Tier 4 - History APIs:**
 ```
 src/main/scala/net/eagle0/eagle/service/InMemoryHistory.scala
@@ -149,38 +182,102 @@ Change APIs to vend Scala `GameState` and `ActionResultT` instead of proto versi
 
 ### ActionResultProto Consumer Inventory
 
-| File | Usage | Target |
+| File | Usage | Status |
 |------|-------|--------|
-| `ActionResultTApplierImpl.scala` | Converts T→Proto, delegates to proto applier | Replace with `ActionResultApplier` |
-| `RoundPhaseAdvancer.scala` | ~20 converter calls | Eliminate after applier conversion |
-| `RandomStateTSequencer.scala` | Converts T→Proto internally | Thread Scala GameState throughout |
-| `RandomStateProtoSequencer.scala` | Returns `Vector[ActionResultProto]` | Evaluate if still needed |
-| `VigorXPApplier.scala` | Wraps proto results | Convert to work with T |
-| `ResolveBattleAction.scala` | 2 converter calls | Convert after dependencies |
-| `PerformForcedTurnBackAction.scala` | 1 converter call | Convert after dependencies |
-| `EndFreeForAllDecisionPhaseAction.scala` | ~~fromProtoState~~ | **Complete** - now takes Scala GameState |
-| `EndBattleRequestPhaseAction.scala` | ~~fromProtoState~~ | **Complete** - now takes Scala GameState |
-| `EndDefenseDecisionPhaseAction.scala` | ~~fromProtoState~~ | **Complete** - now takes Scala GameState |
-| `EndPleaseRecruitMePhaseAction.scala` | ~~fromProtoState~~ | **Complete** - now takes Scala GameState |
-| `InMemoryHistory.scala` | Stores proto results | Vend Scala types, remove proto entirely |
-| `PersistedHistory.scala` | Stores proto results | Vend Scala types, convert internally for disk |
+| `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) |
 
-### Estimated Effort
+### Remaining Proto Usage in Actions
 
-| Component | Lines | Complexity |
-|-----------|-------|------------|
-| `ActionResultApplier` | ~900 | High (port of proto applier) |
-| `RandomStateTSequencer` refactor | ~150 | Medium |
-| `RoundPhaseAdvancer` updates | ~100 | Medium |
-| History API updates | ~100 | Low |
-| Action/utility updates | ~200 | Low |
-| **Total** | **~1450** | |
+**Progress: 47 of 52 action files (90%) are fully protoless.**
+
+The following 5 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 |
+
+**Note:** `NewRoundAction` is now fully protoless after converting `ChronicleEventGenerator` to return Scala `ChronicleEvent` types directly.
+
+**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) |
+| History API updates | ~100 | Low | - |
+| **Total Remaining** | **~2600** | | |
+
+**Completed:**
+- `ChronicleEventGenerator` converted to return Scala `ChronicleEvent` types directly
+
+### CommandChoiceHelpers Migration Status
+
+Several command selectors have already been converted to use Scala types:
+
+| File | Status | Notes |
+|------|--------|-------|
+| `AttackCommandChooser.scala` | ✅ **Protoless** | Uses Scala `GameState`, `HeroT`, `ProvinceT` |
+| `AlmsCommandSelector.scala` | ✅ **Protoless** | Uses Scala `GameState`, `HeroT`, `ProvinceT` |
+| `FoodConsumptionUtils.scala` | ✅ **Protoless** | Uses Scala `GameState`, `ProvinceT`, `RoundPhase` |
+| `MarchSuppliesHelpers.scala` | ✅ **Protoless** | Uses `BattalionT` |
+| `CombatUnitSelector.scala` | ✅ **Protoless** | Uses `HeroT`, `BattalionT`, `BattalionType` |
+| `ExpandCommandSelector.scala` | ✅ **Protoless** | Uses Scala `GameState`, `ProvinceT`, `FactionT` |
+| `ImproveCommandSelector.scala` | ✅ **Protoless** | Uses Scala `GameState`, `ProvinceT`, `HeroT` |
+| `OrganizeCommandSelector.scala` | ✅ **Protoless** | Uses Scala `GameState`, `BattalionT`, `BattalionType` |
+| `RansomOfferHelpers.scala` | ✅ **Protoless** | Uses Scala `GameState`, `FactionT` |
+| `CommandChoiceHelpers.scala` | ❌ Proto | Main entry point, converts to Scala when calling converted selectors |
+| `ProvinceGoldSurplusCalculator.scala` | **Partial** | Has both Scala and proto overloads |
+| Other selectors | ❌ Proto | Various proto dependencies |
+
+**Pattern**: `CommandChoiceHelpers` currently uses `GameStateConverter.fromProto(gameState)` when calling already-converted selectors like `AlmsCommandSelector` and `AttackCommandChooser`. This allows incremental migration.
+
+**Next Steps**:
+1. ~~Convert `ExpandCommandSelector` to Scala types~~ ✅ Done
+2. ~~Convert `ImproveCommandSelector` to Scala types~~ ✅ Done
+3. ~~Convert `OrganizeCommandSelector` to Scala types~~ ✅ Done (PR #4812)
+4. ~~Convert `RansomOfferHelpers` to Scala types~~ ✅ Done (PR #4821)
+5. Convert remaining selectors one at a time
+6. Update `CommandChoiceHelpers` to accept Scala `GameState` once all selectors are converted
+
+### Progress Summary
+
+| Metric | Value |
+|--------|-------|
+| Action files fully protoless | 47 / 52 (90%) |
+| Proto usages in remaining actions | 32 total |
+| Biggest blocker | `ResolveBattleAction` (24 usages) |
+| Second biggest blocker | `CommandChoiceHelpers` (blocks 4 actions) |
 
 ### Validation
-- [ ] `ActionResultApplier` created and tested
-- [ ] `RandomStateTSequencer` threads Scala GameState throughout
-- [ ] `RoundPhaseAdvancer` uses T-types internally
+- [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
@@ -196,11 +293,35 @@ Remove remaining direct proto imports from utility classes.
 
 | File | Status |
 |------|--------|
+| `CommandChoiceHelpers.scala` | Accepts proto `GameState`; blocks full deproto of `PerformVassalCommandsPhaseAction` and `PerformVassalDefenseDecisionsAction` |
+| `LegacyProvinceUtils.scala` | Replace with `ProvinceUtils.scala` - `hasImminentRiot` added (PR #4683) |
 | `LegacyFactionUtils.scala` | Replace proto imports with `FactionT` |
 | `LegacyUnaffiliatedHeroUtils.scala` | Replace proto imports with Scala models |
 | `BattalionTypeLoader.scala` | Keep proto for file loading, convert immediately after |
 | `BeastUtils.scala` | **Complete** - now uses Scala `BeastInfo` only |
 
+### View Filters (Partially Complete)
+
+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
+
 ---
 
 ## Phase 8: Verify Boundaries
@@ -227,7 +348,7 @@ Confirm protos are used correctly at boundaries — and ONLY there.
 
 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. Should views also have Scala models, or is proto acceptable for client-facing projections?
+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.
 
 ---
 

docs/OAUTH_IMPLEMENTATION_PLAN.md

@@ -0,0 +1,189 @@
+# Discord + Google OAuth Implementation Plan
+
+## Overview
+
+Replace HTTP Basic Auth with OAuth 2.0 (Discord + Google) for Eagle0. Users authenticate via system browser, receive JWT tokens, and choose their own display names.
+
+## Architecture
+
+```
+Unity Client                                          Eagle Server
+     |                                                      |
+     |  1. Click "Login with Discord/Google"                |
+     |  ------------------------------------------------->  |
+     |     GetOAuthUrl(provider) -> auth_url + state        |
+     |                                                      |
+     |  2. Open system browser -> OAuth consent             |
+     |  3. User authenticates with provider                 |
+     |  4. Redirect to eagle0://auth/callback?code=xxx      |
+     |                                                      |
+     |  5. ExchangeCode(code, state)                        |
+     |  ------------------------------------------------->  |
+     |     Exchange code with provider                      |
+     |     Fetch user info (id, email, avatar)              |
+     |     Create/update user record                        |
+     |     Issue JWT + refresh token                        |
+     |  <-------------------------------------------------  |
+     |     (jwt, refresh_token, user_info, is_new_user)     |
+     |                                                      |
+     |  6. [If new user] SetDisplayName(name)               |
+     |  ------------------------------------------------->  |
+     |                                                      |
+     |  7. Subsequent gRPC calls                            |
+     |     Authorization: Bearer <jwt>                      |
+     |  ------------------------------------------------->  |
+```
+
+## Key Design Decisions
+
+| Decision | Choice | Rationale |
+|----------|--------|-----------|
+| OAuth flow | System browser + deep link | Secure, supports password managers |
+| Code exchange | Eagle server directly | No separate auth service needed |
+| JWT signing | RS256 (asymmetric) | Future flexibility for token verification |
+| User storage | Protobuf file via Persister | Consistent with existing patterns |
+| Token expiry | 7-day access, 30-day refresh | Balance security and gaming UX |
+
+## Implementation Phases
+
+### Phase 1: Proto Definitions & Infrastructure
+
+**New files:**
+- `src/main/protobuf/net/eagle0/eagle/api/auth.proto` - Auth API messages
+- `src/main/protobuf/net/eagle0/eagle/internal/user.proto` - User storage schema
+
+**Key proto messages:**
+```protobuf
+// API
+GetOAuthUrlRequest/Response     // Get OAuth URL to open in browser
+ExchangeCodeRequest/Response    // Exchange auth code for JWT
+SetDisplayNameRequest/Response  // Set user's display name
+RefreshTokenRequest/Response    // Refresh expired access token
+
+// Internal storage
+User                           // user_id, display_name, oauth_identities
+UserDatabase                   // All users + indexes for lookup
+```
+
+### Phase 2: Eagle Server Auth Services
+
+**New Scala files:**
+- `src/main/scala/net/eagle0/eagle/auth/OAuthConfig.scala` - Discord/Google config from env vars
+- `src/main/scala/net/eagle0/eagle/auth/JwtService.scala` - JWT creation/validation (RS256)
+- `src/main/scala/net/eagle0/eagle/auth/UserService.scala` - User CRUD, display name validation
+- `src/main/scala/net/eagle0/eagle/auth/OAuthService.scala` - OAuth code exchange
+- `src/main/scala/net/eagle0/eagle/service/AuthServiceImpl.scala` - gRPC service implementation
+
+**Modify:**
+- `src/main/scala/net/eagle0/eagle/service/AuthorizationInterceptor.scala`
+  - Replace Basic Auth parsing with JWT validation
+  - Skip auth for public endpoints (GetOAuthUrl, ExchangeCode, RefreshToken)
+- `src/main/scala/net/eagle0/eagle/service/AuthorizationUtils.scala`
+  - Change context keys from `userName` to `userId` + `displayName`
+- `src/main/scala/net/eagle0/eagle/service/Main.scala`
+  - Wire up new auth services and JWT key loading
+
+### Phase 3: Unity Client OAuth Flow
+
+**New C# files:**
+- `Assets/Auth/OAuthManager.cs` - OAuth flow + deep link handling
+- `Assets/Auth/TokenStorage.cs` - Secure token persistence
+- `Assets/Auth/AuthClient.cs` - gRPC client for auth service
+
+**Modify:**
+- `Assets/EagleConnection.cs`
+  - Replace `AuthInterceptor` (Basic Auth) with `JwtAuthInterceptor` (Bearer token)
+- `Assets/ConnectionHandler/ConnectionHandler.cs`
+  - Replace username/password UI with Discord/Google login buttons
+  - Add display name setup flow for new users
+
+### Phase 4: Platform Configuration
+
+**Deep link registration:**
+- iOS: Add `eagle0://` to CFBundleURLSchemes in Info.plist
+- Android: Add intent-filter for `eagle0://auth` in AndroidManifest.xml
+- Desktop: Register URL scheme (Windows registry / macOS plist)
+
+**OAuth provider setup:**
+1. Discord Developer Portal: Create app, add redirect URI `eagle0://auth/callback`
+2. Google Cloud Console: Create OAuth client, add redirect URI
+
+**Environment variables (server):**
+```
+DISCORD_CLIENT_ID
+DISCORD_CLIENT_SECRET
+GOOGLE_CLIENT_ID
+GOOGLE_CLIENT_SECRET
+JWT_PRIVATE_KEY_PATH
+JWT_PUBLIC_KEY_PATH
+```
+
+### Phase 5: Testing
+
+**Unit tests:**
+- `JwtServiceSpec.scala` - Token creation/validation
+- `UserServiceSpec.scala` - Display name validation, uniqueness
+- `OAuthServiceSpec.scala` - OAuth flow with mocked providers
+
+**Integration tests:**
+- Full OAuth flow with mock provider
+- JWT validation in AuthorizationInterceptor
+- gRPC calls with valid/invalid tokens
+
+**Manual testing:**
+- [ ] Discord login (Windows, macOS)
+- [ ] Google login (Windows, macOS)
+- [ ] Deep link callback works
+- [ ] Display name validation
+- [ ] Session persistence across restarts
+- [ ] Token refresh
+
+## Files Summary
+
+### Create
+| File | Purpose |
+|------|---------|
+| `src/main/protobuf/net/eagle0/eagle/api/auth.proto` | Auth API definitions |
+| `src/main/protobuf/net/eagle0/eagle/internal/user.proto` | User storage schema |
+| `src/main/scala/net/eagle0/eagle/auth/OAuthConfig.scala` | Provider config |
+| `src/main/scala/net/eagle0/eagle/auth/JwtService.scala` | JWT handling |
+| `src/main/scala/net/eagle0/eagle/auth/UserService.scala` | User management |
+| `src/main/scala/net/eagle0/eagle/auth/OAuthService.scala` | OAuth flow |
+| `src/main/scala/net/eagle0/eagle/service/AuthServiceImpl.scala` | gRPC service |
+| `Assets/Auth/OAuthManager.cs` | Unity OAuth manager |
+| `Assets/Auth/TokenStorage.cs` | Token storage |
+| `Assets/Auth/AuthClient.cs` | Auth gRPC client |
+
+### Modify
+| File | Changes |
+|------|---------|
+| `AuthorizationInterceptor.scala` | Basic Auth -> JWT validation |
+| `AuthorizationUtils.scala` | userName -> userId + displayName |
+| `Main.scala` | Wire auth services |
+| `EagleConnection.cs` | AuthInterceptor -> JwtAuthInterceptor |
+| `ConnectionHandler.cs` | Login UI -> OAuth buttons + display name |
+
+### Delete
+- nginx htpasswd configuration (no longer needed)
+
+## Security Considerations
+
+1. **State parameter** - CSRF protection in OAuth flow
+2. **PKCE** - Consider adding for mobile (enhancement)
+3. **Secure storage** - Use Keychain (iOS) / Keystore (Android) for tokens
+4. **Token refresh** - 7-day access tokens with 30-day refresh
+5. **Rate limiting** - Limit login attempts per IP
+
+## Dependencies to Add
+
+**Scala (MODULE.bazel):**
+- JWT library (e.g., `jwt-scala` or `nimbus-jose-jwt`)
+- HTTP client (e.g., `sttp` for OAuth requests)
+
+**Unity:**
+- Deep linking is built-in (Unity 2021+)
+- No additional packages required
+
+## Rollback Plan
+
+Keep Basic Auth code in a feature branch. Both auth methods can coexist during transition via feature flag if needed.

maven_install.json

@@ -1,9 +1,10 @@
 {
   "__AUTOGENERATED_FILE_DO_NOT_MODIFY_THIS_FILE_MANUALLY": "THERE_IS_NO_DATA_ONLY_ZUUL",
-  "__INPUT_ARTIFACTS_HASH": 571423113,
-  "__RESOLVED_ARTIFACTS_HASH": 438039003,
+  "__INPUT_ARTIFACTS_HASH": -1064460283,
+  "__RESOLVED_ARTIFACTS_HASH": -1574144850,
   "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",
@@ -47,6 +48,12 @@
       },
       "version": "2.12.7"
     },
+    "com.github.stephenc.jcip:jcip-annotations": {
+      "shasums": {
+        "jar": "4fccff8382aafc589962c4edb262f6aa595e34f1e11e61057d1c6a96e8fc7323"
+      },
+      "version": "1.0-1"
+    },
     "com.google.android:annotations": {
       "shasums": {
         "jar": "ba734e1e84c09d615af6a09d33034b4f0442f8772dec120efb376d86a565ae15"
@@ -155,6 +162,24 @@
       },
       "version": "1.4.2"
     },
+    "com.nimbusds:nimbus-jose-jwt": {
+      "shasums": {
+        "jar": "12ae4a3a260095d7aeba2adea7ae396e8b9570db8b7b409e09a824c219cc0444"
+      },
+      "version": "9.37.3"
+    },
+    "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 +188,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 +475,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 +822,26 @@
       "org.checkerframework:checker-qual",
       "org.ow2.asm:asm"
     ],
+    "com.nimbusds:nimbus-jose-jwt": [
+      "com.github.stephenc.jcip:jcip-annotations"
+    ],
+    "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 +1049,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"
     ],
@@ -1306,6 +1370,9 @@
       "com.fasterxml.jackson.databind.type",
       "com.fasterxml.jackson.databind.util"
     ],
+    "com.github.stephenc.jcip:jcip-annotations": [
+      "net.jcip.annotations"
+    ],
     "com.google.android:annotations": [
       "android.annotation"
     ],
@@ -1451,6 +1518,61 @@
     "com.google.truth:truth": [
       "com.google.common.truth"
     ],
+    "com.nimbusds:nimbus-jose-jwt": [
+      "com.nimbusds.jose",
+      "com.nimbusds.jose.crypto",
+      "com.nimbusds.jose.crypto.bc",
+      "com.nimbusds.jose.crypto.factories",
+      "com.nimbusds.jose.crypto.impl",
+      "com.nimbusds.jose.crypto.opts",
+      "com.nimbusds.jose.crypto.utils",
+      "com.nimbusds.jose.jca",
+      "com.nimbusds.jose.jwk",
+      "com.nimbusds.jose.jwk.gen",
+      "com.nimbusds.jose.jwk.source",
+      "com.nimbusds.jose.mint",
+      "com.nimbusds.jose.proc",
+      "com.nimbusds.jose.produce",
+      "com.nimbusds.jose.shaded.gson",
+      "com.nimbusds.jose.shaded.gson.annotations",
+      "com.nimbusds.jose.shaded.gson.internal",
+      "com.nimbusds.jose.shaded.gson.internal.bind",
+      "com.nimbusds.jose.shaded.gson.internal.bind.util",
+      "com.nimbusds.jose.shaded.gson.internal.reflect",
+      "com.nimbusds.jose.shaded.gson.internal.sql",
+      "com.nimbusds.jose.shaded.gson.reflect",
+      "com.nimbusds.jose.shaded.gson.stream",
+      "com.nimbusds.jose.util",
+      "com.nimbusds.jose.util.cache",
+      "com.nimbusds.jose.util.events",
+      "com.nimbusds.jose.util.health",
+      "com.nimbusds.jwt",
+      "com.nimbusds.jwt.proc",
+      "com.nimbusds.jwt.util"
+    ],
+    "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 +1581,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 +1936,7 @@
       "kotlin.annotation",
       "kotlin.collections",
       "kotlin.collections.builders",
+      "kotlin.collections.jdk8",
       "kotlin.collections.unsigned",
       "kotlin.comparisons",
       "kotlin.concurrent",
@@ -1822,24 +1945,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",
@@ -2252,6 +2387,7 @@
       "com.fasterxml.jackson.core:jackson-annotations",
       "com.fasterxml.jackson.core:jackson-core",
       "com.fasterxml.jackson.core:jackson-databind",
+      "com.github.stephenc.jcip:jcip-annotations",
       "com.google.android:annotations",
       "com.google.api.grpc:proto-google-common-protos",
       "com.google.auth:google-auth-library-credentials",
@@ -2270,8 +2406,12 @@
       "com.google.protobuf:protobuf-java",
       "com.google.re2j:re2j",
       "com.google.truth:truth",
+      "com.nimbusds:nimbus-jose-jwt",
+      "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 +2464,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",

nginx/nginx.conf

@@ -0,0 +1,100 @@
+events {
+    worker_connections 1024;
+}
+
+http {
+    # Logging
+    log_format grpc_json escape=json '{'
+        '"time":"$time_iso8601",'
+        '"client":"$remote_addr",'
+        '"uri":"$uri",'
+        '"status":$status,'
+        '"grpc_status":"$sent_http_grpc_status",'
+        '"request_time":$request_time,'
+        '"upstream_time":"$upstream_response_time"'
+    '}';
+
+    access_log /var/log/nginx/access.log grpc_json;
+    error_log /var/log/nginx/error.log warn;
+
+    # Rate limiting zone
+    limit_req_zone $binary_remote_addr zone=grpc_limit:10m rate=100r/s;
+
+    # Docker DNS resolver - re-resolve hostnames every 10s
+    # This prevents stale IP caching when containers restart
+    resolver 127.0.0.11 valid=10s ipv6=off;
+
+    # Upstream for Eagle gRPC server
+    upstream eagle_grpc {
+        server eagle:40032;
+        keepalive 100;
+    }
+
+    # HTTP server for Let's Encrypt challenge and redirect
+    server {
+        listen 80;
+        server_name prod.eagle0.net;
+
+        # Let's Encrypt challenge
+        location /.well-known/acme-challenge/ {
+            root /var/www/certbot;
+        }
+
+        # Redirect all other HTTP to HTTPS
+        location / {
+            return 301 https://$host$request_uri;
+        }
+    }
+
+    # HTTPS server for gRPC
+    server {
+        listen 443 ssl;
+        http2 on;
+        server_name prod.eagle0.net;
+
+        # SSL certificates (managed by certbot)
+        ssl_certificate /etc/letsencrypt/live/prod.eagle0.net/fullchain.pem;
+        ssl_certificate_key /etc/letsencrypt/live/prod.eagle0.net/privkey.pem;
+
+        # SSL configuration
+        ssl_protocols TLSv1.2 TLSv1.3;
+        ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;
+        ssl_prefer_server_ciphers off;
+        ssl_session_timeout 1d;
+        ssl_session_cache shared:SSL:10m;
+        ssl_session_tickets off;
+
+        # gRPC proxy for Eagle service
+        location /net.eagle0.eagle.api.Eagle {
+            # Rate limiting
+            limit_req zone=grpc_limit burst=50 nodelay;
+
+            # gRPC proxy
+            grpc_pass grpc://eagle_grpc;
+
+            # Timeouts for long-running streams
+            grpc_read_timeout 1200s;
+            grpc_send_timeout 1200s;
+            grpc_socket_keepalive on;
+
+            # Error handling
+            error_page 502 = /error502grpc;
+        }
+
+        # Health check endpoint
+        location /health {
+            access_log off;
+            return 200 "OK\n";
+            add_header Content-Type text/plain;
+        }
+
+        # gRPC error handling
+        location = /error502grpc {
+            internal;
+            default_type application/grpc;
+            add_header grpc-status 14;
+            add_header grpc-message "unavailable";
+            return 204;
+        }
+    }
+}

scripts/generate_changelog.sh

@@ -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

scripts/setup_droplet.sh

@@ -0,0 +1,149 @@
+#!/bin/bash
+#
+# Setup script for Eagle0 production droplet
+# Run this on a fresh DigitalOcean droplet (Ubuntu 24.04)
+#
+# Usage: curl -sSL https://raw.githubusercontent.com/nolen777/eagle0/main/scripts/setup_droplet.sh | sudo bash
+#
+
+set -euo pipefail
+
+DOMAIN="${DOMAIN:-eagle0.net}"
+DEPLOY_USER="${DEPLOY_USER:-deploy}"
+APP_DIR="/opt/eagle0"
+
+echo "=== Eagle0 Production Server Setup ==="
+echo "Domain: ${DOMAIN}"
+echo "Deploy user: ${DEPLOY_USER}"
+echo ""
+
+# Check if running as root
+if [[ $EUID -ne 0 ]]; then
+   echo "This script must be run as root (use sudo)"
+   exit 1
+fi
+
+echo "=== Updating system ==="
+apt-get update
+apt-get upgrade -y
+
+echo "=== Installing Docker ==="
+if ! command -v docker &> /dev/null; then
+    curl -fsSL https://get.docker.com | sh
+    systemctl enable docker
+    systemctl start docker
+else
+    echo "Docker already installed"
+fi
+
+echo "=== Installing Docker Compose plugin ==="
+apt-get install -y docker-compose-plugin
+
+echo "=== Installing additional utilities ==="
+apt-get install -y \
+    curl \
+    wget \
+    git \
+    netcat-openbsd \
+    jq \
+    htop \
+    unattended-upgrades
+
+echo "=== Configuring automatic security updates ==="
+cat > /etc/apt/apt.conf.d/20auto-upgrades << 'EOF'
+APT::Periodic::Update-Package-Lists "1";
+APT::Periodic::Unattended-Upgrade "1";
+APT::Periodic::AutocleanInterval "7";
+EOF
+
+echo "=== Creating deploy user ==="
+if ! id "${DEPLOY_USER}" &>/dev/null; then
+    useradd -m -s /bin/bash -G docker "${DEPLOY_USER}"
+    mkdir -p "/home/${DEPLOY_USER}/.ssh"
+    chmod 700 "/home/${DEPLOY_USER}/.ssh"
+    chown -R "${DEPLOY_USER}:${DEPLOY_USER}" "/home/${DEPLOY_USER}/.ssh"
+    echo ""
+    echo "*** IMPORTANT: Add your SSH public key to /home/${DEPLOY_USER}/.ssh/authorized_keys ***"
+    echo ""
+else
+    echo "User ${DEPLOY_USER} already exists"
+    # Ensure user is in docker group
+    usermod -aG docker "${DEPLOY_USER}"
+fi
+
+echo "=== Creating application directory ==="
+mkdir -p "${APP_DIR}"/{nginx,certbot/conf,certbot/www,saves}
+chown -R "${DEPLOY_USER}:${DEPLOY_USER}" "${APP_DIR}"
+
+echo "=== Configuring Docker registry authentication ==="
+echo ""
+echo "*** IMPORTANT: Run the following command to authenticate with DigitalOcean Container Registry: ***"
+echo "  docker login registry.digitalocean.com"
+echo ""
+
+echo "=== Creating systemd service ==="
+cat > /etc/systemd/system/eagle0.service << EOF
+[Unit]
+Description=Eagle0 Game Servers
+Requires=docker.service
+After=docker.service
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+WorkingDirectory=${APP_DIR}
+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_USER}
+Group=${DEPLOY_USER}
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+systemctl daemon-reload
+systemctl enable eagle0
+
+echo "=== Configuring firewall (UFW) ==="
+if ! command -v ufw &> /dev/null; then
+    apt-get install -y ufw
+fi
+
+ufw default deny incoming
+ufw default allow outgoing
+ufw allow ssh
+ufw allow 80/tcp
+ufw allow 443/tcp
+ufw --force enable
+
+echo "=== Setting up log rotation ==="
+cat > /etc/logrotate.d/eagle0 << EOF
+/var/log/eagle0/*.log {
+    daily
+    missingok
+    rotate 14
+    compress
+    delaycompress
+    notifempty
+    create 0640 ${DEPLOY_USER} ${DEPLOY_USER}
+    sharedscripts
+}
+EOF
+
+mkdir -p /var/log/eagle0
+chown "${DEPLOY_USER}:${DEPLOY_USER}" /var/log/eagle0
+
+echo ""
+echo "=== Setup Complete ==="
+echo ""
+echo "Next steps:"
+echo "1. Add SSH public key to /home/${DEPLOY_USER}/.ssh/authorized_keys"
+echo "2. Copy docker-compose.prod.yml to ${APP_DIR}/"
+echo "3. Copy nginx/nginx.conf to ${APP_DIR}/nginx/"
+echo "4. Create .env file in ${APP_DIR}/ with OPENAI_API_KEY"
+echo "5. Run: docker login registry.digitalocean.com"
+echo "6. Get SSL certificate: (see init_ssl.sh)"
+echo "7. Start services: systemctl start eagle0"
+echo ""
+echo "Server IP: $(curl -s ifconfig.me)"
+echo ""

src/main/cpp/net/eagle0/common/FilesystemUtils.cpp

@@ -26,6 +26,13 @@ namespace fs = std::filesystem;
 static string rLocation;
 
 auto rloc(const string& execPath) -> string {
+    // First check for environment variable override for Docker deployment
+    const char* resourcesPath = getenv("SHARDOK_RESOURCES_PATH");
+    if (resourcesPath != nullptr) {
+        return "";  // Return empty so StaticShardokFilesDirectory uses env var directly
+    }
+
+    // Fall back to Bazel runfiles for development
     string error;
     const std::unique_ptr<Runfiles> runfiles(Runfiles::Create(execPath, &error));
 
@@ -58,10 +65,14 @@ auto FilesystemUtils::FileExistsAtPath(const string& path) -> bool { return fs::
 auto FilesystemUtils::StaticEagle0FilesDirectory() -> string { return "/usr/local/share/eagle0/"; }
 
 auto FilesystemUtils::StaticShardokFilesDirectory() -> string {
+    const char* resourcesPath = getenv("SHARDOK_RESOURCES_PATH");
+    if (resourcesPath != nullptr) { return string(resourcesPath) + "/"; }
     return rLocation + "/src/main/resources/net/eagle0/shardok/";
 }
 
 auto FilesystemUtils::MapFilesDirectory() -> string {
+    const char* mapsPath = getenv("SHARDOK_MAPS_PATH");
+    if (mapsPath != nullptr) { return string(mapsPath) + "/"; }
     return StaticShardokFilesDirectory() + "maps/";
 }
 

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

@@ -7,6 +7,7 @@
 
 #include <algorithm>
 #include <bit>
+#include <cstdint>
 #include <cstdlib>
 
 #define ITERABLE_BITSET_INDEX_CHECKS false

src/main/cpp/net/eagle0/common/MapUtils.cpp

@@ -9,6 +9,7 @@
 #include "MapUtils.hpp"
 
 #include <algorithm>
+#include <stdexcept>
 
 static inline std::string StringForKey(
         const std::unordered_map<std::string, std::string>& map,

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

@@ -9,6 +9,7 @@
 #ifndef byte_vector_h
 #define byte_vector_h
 
+#include <cstdint>
 #include <cstring>
 #include <fstream>
 #include <sstream>

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

@@ -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; }

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

@@ -4,6 +4,7 @@
 
 #include "TranspositionTable.hpp"
 
+#include <cinttypes>
 #include <cstdio>
 #include <cstring>
 
@@ -101,10 +102,10 @@ void TranspositionTable::clear() {
 
 void TranspositionTable::printStats() const {
     printf("TranspositionTable Stats:\n");
-    printf("  Probes: %llu\n", stats.probes.load());
-    printf("  Hits: %llu (%.1f%%)\n", stats.hits.load(), stats.hitRate());
-    printf("  Stores: %llu\n", stats.stores.load());
-    printf("  Collisions: %llu\n", stats.collisions.load());
+    printf("  Probes: %" PRIu64 "\n", stats.probes.load());
+    printf("  Hits: %" PRIu64 " (%.1f%%)\n", stats.hits.load(), stats.hitRate());
+    printf("  Stores: %" PRIu64 "\n", stats.stores.load());
+    printf("  Collisions: %" PRIu64 "\n", stats.collisions.load());
     printf("  Table size: %zu entries (%.1f MB)\n",
            TABLE_SIZE,
            (TABLE_SIZE * sizeof(TTEntry)) / (1024.0 * 1024.0));

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

@@ -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

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

@@ -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
 

src/main/cpp/net/eagle0/shardok/server/EagleInterfaceGrpcServer.cpp

@@ -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

src/main/cpp/net/eagle0/shardok/server/EagleInterfaceGrpcServer.hpp

@@ -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
 

src/main/cpp/net/eagle0/shardok/server/ServerConfiguration.cpp

@@ -8,6 +8,7 @@
 
 #include "ServerConfiguration.hpp"
 
+#include <cstdlib>
 #include <cstring>
 #include <fstream>
 #include <iostream>
@@ -30,9 +31,16 @@ using std::unordered_map;
 unordered_map<string, string> DefaultValues();
 
 unordered_map<string, string> DefaultValues() {
+    // Check environment variables for Docker deployment
+    // Docker containers should set SHARDOK_EAGLE_INTERFACE_ADDRESS=0.0.0.0:40042
+    // to listen on all interfaces for container networking
+    const char* eagleInterfaceAddr = getenv("SHARDOK_EAGLE_INTERFACE_ADDRESS");
+    const char* shardokAddr = getenv("SHARDOK_GRPC_ADDRESS");
+
     return unordered_map<string, string>{
-            {ServerConfiguration::kShardokGrpcAddress, "localhost"},
-            {ServerConfiguration::kEagleInterfaceGrpcAddress, "localhost"}};
+            {ServerConfiguration::kShardokGrpcAddress, shardokAddr ? shardokAddr : "localhost"},
+            {ServerConfiguration::kEagleInterfaceGrpcAddress,
+             eagleInterfaceAddr ? eagleInterfaceAddr : "localhost:40042"}};
 }
 
 ServerConfiguration::ServerConfiguration(const string& filePath) {

src/main/csharp/net/eagle0/clients/unity/eagle0/Assembly-CSharp.csproj

@@ -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" />

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

@@ -77,11 +77,14 @@ public class AuthInterceptor : Interceptor {
 };
 
 public class ConnectionHandler : MonoBehaviour, ILobbySubscriber, IDisposable {
-    public TMP_InputField urlField;
+    public TMP_Dropdown environmentDropdown;
     public TMP_InputField nameField;
     public TMP_InputField passwordField;
     public TMP_Dropdown resolutionDropdown;
 
+    [Header("Status Display")]
+    public TextMeshProUGUI connectionStatusText;
+
     public GameObject connectionPanel;
     public GameObject gameSelectionPanel;
     public GameObject customBattlePanel;
@@ -112,11 +115,22 @@ public class ConnectionHandler : MonoBehaviour, ILobbySubscriber, IDisposable {
 
     public ClientPregeneratedText clientPregeneratedText;
 
-    const String DefaultUrl = "eagle0.net";
-    const String URLKey = "urlKey";
+    const String BaseDomain = "eagle0.net";
+    const String EnvironmentKey = "environmentKey";
     const String NameKey = "nameKey";
     const String PasswordKey = "passwordKey";
 
+    // Environment options: index 0 = prod., index 1 = qa., index 2 = (none)
+    private static readonly List<string> EnvironmentOptions = new() { "prod.", "qa.", "" };
+    private static readonly List<string> EnvironmentDisplayNames =
+            new() { "prod.", "qa.", "(none)" };
+
+    private string GetUrlFromEnvironment() {
+        int envIndex = environmentDropdown.value;
+        string prefix = EnvironmentOptions[envIndex];
+        return prefix + BaseDomain;
+    }
+
     public void ReceiveLobbyUpdate(LobbyResponse lobbyResponse) {
         _handleLobbyResponse(lobbyResponse);
     }
@@ -133,7 +147,11 @@ public class ConnectionHandler : MonoBehaviour, ILobbySubscriber, IDisposable {
         resolutionDropdown.AddOptions(resolutions.Select(r => $"{r.width} x {r.height}").ToList());
         resolutionDropdown.value = resolutions.ToList().IndexOf(currentResolution);
 
-        urlField.text = PlayerPrefs.GetString(URLKey, DefaultUrl);
+        // Set up environment dropdown
+        environmentDropdown.ClearOptions();
+        environmentDropdown.AddOptions(EnvironmentDisplayNames);
+        environmentDropdown.value = PlayerPrefs.GetInt(EnvironmentKey, 0);
+
         nameField.text = PlayerPrefs.GetString(NameKey, "sample_name");
         passwordField.text = PlayerPrefs.GetString(PasswordKey, "sample_password");
 
@@ -147,6 +165,78 @@ public class ConnectionHandler : MonoBehaviour, ILobbySubscriber, IDisposable {
         customBattlePanel.gameObject.SetActive(false);
 
         errorHandler.gameObject.SetActive(true);
+
+        // Initialize status text
+        UpdateConnectionStatus();
+    }
+
+    private float _statusUpdateTimer = 0f;
+    private const float StatusUpdateInterval = 0.5f;
+
+    void Update() {
+        // Only update status periodically and when connection panel is visible
+        if (!connectionPanel.activeInHierarchy) return;
+
+        _statusUpdateTimer += Time.deltaTime;
+        if (_statusUpdateTimer >= StatusUpdateInterval) {
+            _statusUpdateTimer = 0f;
+            UpdateConnectionStatus();
+        }
+    }
+
+    private void UpdateConnectionStatus() {
+        if (connectionStatusText == null) return;
+
+        // No connection yet - show nothing
+        if (_persistentClientConnection == null) {
+            connectionStatusText.text = "";
+            return;
+        }
+
+        var circuitState = _persistentClientConnection.CircuitBreaker.CurrentState;
+        var connState = _persistentClientConnection.CurrentState;
+
+        // Circuit breaker takes precedence
+        if (circuitState == eagle.ConnectionCircuitBreaker.State.Open) {
+            var nextTest = _persistentClientConnection.CircuitBreaker.NextTestAttempt;
+            if (nextTest.HasValue) {
+                var timeUntilTest = nextTest.Value - DateTime.UtcNow;
+                if (timeUntilTest.TotalSeconds > 0) {
+                    int seconds = Math.Min(10, (int)Math.Ceiling(timeUntilTest.TotalSeconds));
+                    connectionStatusText.text =
+                            $"<color=red>●</color> Server unavailable. Retry in {seconds}s";
+                    return;
+                }
+            }
+            connectionStatusText.text = "<color=red>●</color> Server unavailable";
+            return;
+        }
+
+        if (circuitState == eagle.ConnectionCircuitBreaker.State.HalfOpen) {
+            connectionStatusText.text = "<color=yellow>●</color> Testing connection...";
+            return;
+        }
+
+        // Normal connection states
+        connectionStatusText.text = connState switch {
+            eagle.ConnectionState.Connected => "<color=green>●</color> Connected",
+            eagle.ConnectionState.Connecting => "<color=yellow>●</color> Connecting...",
+            eagle.ConnectionState.Disconnected => "<color=red>●</color> Disconnected",
+            eagle.ConnectionState.Reconnecting => GetReconnectingText(),
+            eagle.ConnectionState.SubscriptionPending => "<color=yellow>●</color> Subscribing...",
+            _ => ""
+        };
+    }
+
+    private string GetReconnectingText() {
+        var nextAttempt = _persistentClientConnection?.NextReconnectAttempt;
+        if (!nextAttempt.HasValue) return "<color=yellow>●</color> Reconnecting...";
+
+        var timeUntilRetry = nextAttempt.Value - DateTime.UtcNow;
+        if (timeUntilRetry.TotalSeconds <= 0) { return "<color=yellow>●</color> Reconnecting..."; }
+
+        int seconds = Math.Min(10, (int)Math.Ceiling(timeUntilRetry.TotalSeconds));
+        return $"<color=orange>●</color> Retry in {seconds}s";
     }
 
     public void EditorButtonClicked() { SceneManager.LoadScene("Map Editor"); }
@@ -267,7 +357,7 @@ public class ConnectionHandler : MonoBehaviour, ILobbySubscriber, IDisposable {
     }
 
     private void _createConnection() {
-        PlayerPrefs.SetString(URLKey, urlField.text);
+        PlayerPrefs.SetInt(EnvironmentKey, environmentDropdown.value);
         PlayerPrefs.SetString(NameKey, nameField.text);
         PlayerPrefs.SetString(PasswordKey, passwordField.text);
 
@@ -280,7 +370,8 @@ public class ConnectionHandler : MonoBehaviour, ILobbySubscriber, IDisposable {
         // Initialize cancellation token for thread management
         _cancellationTokenSource = new CancellationTokenSource();
 
-        eagleConnection = new EagleConnection(nameField.text, passwordField.text, urlField.text);
+        string url = GetUrlFromEnvironment();
+        eagleConnection = new EagleConnection(nameField.text, passwordField.text, url);
         _persistentClientConnection = new PersistentClientConnection(
                 eagleConnection.EagleGrpcClient,
                 eagleConnection.credentials,

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

@@ -1,6 +1,8 @@
 using System;
 using System.Threading;
+#if UNITY_EDITOR
 using UnityEditor;
+#endif
 using UnityEngine;
 
 public class ConnectionKiller : MonoBehaviour {
@@ -10,6 +12,10 @@ public class ConnectionKiller : MonoBehaviour {
     public void OnApplicationQuit() { ShutdownAll(); }
 
 #if UNITY_EDITOR
+    void OnEnable() { EditorApplication.playModeStateChanged += OnPlayModeStateChanged; }
+
+    void OnDisable() { EditorApplication.playModeStateChanged -= OnPlayModeStateChanged; }
+
     void OnPlayModeStateChanged(PlayModeStateChange state) {
         if (state == PlayModeStateChange.ExitingPlayMode) { ShutdownAll(); }
     }

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

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

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

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

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

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

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

@@ -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...";

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

@@ -2,6 +2,7 @@ using System;
 using Net.Eagle0.Eagle.Api;
 using TMPro;
 using UnityEngine;
+using UnityEngine.UI;
 
 namespace eagle {
     /// <summary>
@@ -26,6 +27,9 @@ namespace eagle {
         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;
         private float _timeSinceLastUpdate = 0f;
@@ -39,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>
@@ -73,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;
@@ -86,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;
             }
@@ -94,6 +101,11 @@ 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 => GetConnectedStatusText(),
                 ConnectionState.Connecting => "<color=yellow>●</color> Connecting...",
@@ -142,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(); }
+        }
     }
 }

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

@@ -188,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(); }
 
@@ -226,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

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

@@ -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
@@ -105,9 +105,12 @@ namespace eagle {
                 _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
                             };
                         })
@@ -142,6 +145,11 @@ namespace eagle {
         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
@@ -190,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)) {
@@ -232,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>();
 
@@ -245,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;
             }
 
@@ -303,8 +313,10 @@ namespace eagle {
                         ServerStatus = updateItem.ActionResultResponse.ServerGameStatus;
                     }
 
-                    _lastUnfilteredResultCount =
-                            updateItem.ActionResultResponse.UnfilteredResultCountAfter;
+                    // 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 !=
@@ -330,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;
                             }
                         }
@@ -358,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);
@@ -393,10 +411,12 @@ namespace eagle {
                     }
                     break;
 
-                    // Note: Shardok counts are tracked in ShardokGameModel.History.Count
-                    // which is updated in ReceiveGameUpdate on the main thread.
-                    // For now, Shardok reconnects may still get duplicate data, but
-                    // the primary issue (Eagle duplicates) is fixed here.
+                case GameUpdate.GameUpdateDetailsOneofCase.ShardokActionResultResponse:
+                    foreach (var response in update.ShardokActionResultResponse
+                                     .ShardokGameResponses) {
+                        _shardokResultCounts[response.ShardokGameId] = response.NewResultViewCount;
+                    }
+                    break;
             }
         }
 
@@ -465,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) {
@@ -762,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);

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

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

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

@@ -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();

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

@@ -17,6 +17,10 @@ namespace eagle {
 
         private readonly Queue<Notification> _notes = new();
 
+        // Incremented when DismissAll is clicked; pending AddNote calls check this
+        // to skip adding if a dismiss happened since they were enqueued
+        private int _dismissGeneration = 0;
+
         private void SetPopupInfos() {
             PopupInfos = _notes.Select(note => new PopupInfo {
                                    titleText = note.Title,
@@ -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();
         }

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

@@ -57,7 +57,8 @@ namespace eagle.Notifications {
             { BreakAllianceAcceptedDetails, BreakAllianceAcceptedNotificationGenerator.Generator },
             { VassalExiledDetails, VassalExiledDetailsNotificationGenerator.Generator },
             { WithdrewForTruce, WithdrewForTruceDetailsNotificationGenerator.Generator },
-            { ProfessionGainedDetails, ProfessionGainedDetailsNotificationGenerator.Generator }
+            { ProfessionGainedDetails, ProfessionGainedDetailsNotificationGenerator.Generator },
+            { NewFactionHeadDetails, NewFactionHeadDetailsNotificationGenerator.Generator }
         };
 
         public static IEnumerable<Notification> GenerateNotifications(

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

@@ -0,0 +1,98 @@
+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 NewFactionHeadDetailsNotificationGenerator {
+        public static readonly ARNNotificationGenerator Generator = GenerateNotifications;
+
+        private static readonly Random Random = new();
+
+        private static readonly List<string> NotificationTitles = new() {
+            "New Leadership",
+            "Succession",
+            "A New Era",
+            "Rise to Power",
+            "The Mantle Passes",
+            "Heir Ascendant",
+            "Crown of Command",
+            "Leadership Transferred",
+            "The Torch Passes",
+            "New Commander"
+        };
+
+        private static string GetNotificationTitle() {
+            return NotificationTitles[Random.Next(NotificationTitles.Count)];
+        }
+
+        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(
+                Net.Eagle0.Eagle.Common.Notification notification,
+                IGameModel currentModel) {
+            var details = notification.Details.NewFactionHeadDetails;
+            var newHeadHero = currentModel.Heroes[details.NewHeadHeroId];
+            var previousHeadHero =
+                    currentModel.Heroes.TryGetValue(details.PreviousHeadHeroId, out var prev)
+                            ? prev
+                            : null;
+
+            string textTemplate;
+            List<ProvinceId> affectedProvinces;
+
+            if (details.FactionId == currentModel.PlayerId) {
+                // Player's own faction - their new faction head
+                string previousHeadDescription =
+                        previousHeadHero != null ? $"Following the death of {{PreviousHead}}, your"
+                                                 : "Your";
+                textTemplate =
+                        $"{previousHeadDescription} sworn {DisplayNames.SiblingDescription(newHeadHero.PronounGender)} {{NewHead}} now leads your faction.\n\n";
+
+                var heroProvinceId = FindProvinceForHero(details.NewHeadHeroId, currentModel);
+                affectedProvinces = heroProvinceId.HasValue
+                                            ? new List<ProvinceId> { heroProvinceId.Value }
+                                            : currentModel.ProvincesForFaction(details.FactionId);
+            } else {
+                // Another faction
+                var factionName = currentModel.FactionName(details.FactionId);
+                if (previousHeadHero != null) {
+                    textTemplate =
+                            $"Following the death of {{PreviousHead}}, {{NewHead}} now leads {factionName}.\n\n";
+                } else {
+                    textTemplate = $"{{NewHead}} now leads {factionName}.\n\n";
+                }
+                affectedProvinces = currentModel.ProvincesForFaction(details.FactionId);
+            }
+
+            var heroPlaceholders = new Dictionary<string, (string nameTextId, string fallback)> {
+                { "NewHead", (newHeadHero.NameTextId, "A hero") }
+            };
+            if (previousHeadHero != null) {
+                heroPlaceholders["PreviousHead"] =
+                        (previousHeadHero.NameTextId, "the previous leader");
+            }
+
+            var displayedHeroes = new List<HeroView> { newHeadHero };
+            if (previousHeadHero != null) { displayedHeroes.Add(previousHeadHero); }
+
+            yield return DynamicTextNotification.StreamingDynamicNotification(
+                    title: GetNotificationTitle(),
+                    textTemplate: textTemplate,
+                    heroPlaceholders: heroPlaceholders,
+                    llmId: notification.LlmId,
+                    provinceIds: affectedProvinces,
+                    displayedHeroes: displayedHeroes);
+        }
+    }
+}

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

@@ -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") }

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

@@ -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",

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

@@ -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);
             }

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

@@ -69,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);
         }
@@ -226,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 {
@@ -703,9 +712,23 @@ 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).
@@ -1048,51 +1071,69 @@ namespace eagle {
             }
         }
 
+        // 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
-            if (response.GameSyncResults.Count > 0) {
-                foreach (var syncResult in response.GameSyncResults) {
-                    if (!syncResult.EagleInSync) {
+            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}: Eagle out of sync, " +
-                                $"server has {syncResult.ServerUnfilteredResultCount} results");
+                                $"[SYNC_MISMATCH] Game {syncResult.GameId}, Shardok {shardokResult.ShardokGameId}: " +
+                                $"out of sync, server has {shardokResult.ServerFilteredResultCount} results");
                         LogConnectionEvent(
-                                "sync_mismatch_eagle",
-                                $"game={syncResult.GameId}, server_count={syncResult.ServerUnfilteredResultCount}");
-                    }
-
-                    foreach (var shardokResult in syncResult.ShardokSyncResults) {
-                        if (!shardokResult.InSync) {
-                            _remoteEagleClientLogger.LogLine(
-                                    $"[SYNC_MISMATCH] Game {syncResult.GameId}, Shardok {shardokResult.ShardokGameId}: " +
-                                    $"out of sync, server has {shardokResult.ServerFilteredResultCount} results");
-                            LogConnectionEvent(
-                                    "sync_mismatch_shardok",
-                                    $"game={syncResult.GameId}, shardok={shardokResult.ShardokGameId}, " +
-                                            $"server_count={shardokResult.ServerFilteredResultCount}");
-                        }
+                                "sync_mismatch_shardok",
+                                $"game={syncResult.GameId}, shardok={shardokResult.ShardokGameId}, " +
+                                        $"server_count={shardokResult.ServerFilteredResultCount}");
+                        hasMismatch = true;
                     }
                 }
-
-                // 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");
             }
+
+            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");
         }
     }
 }

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

@@ -1,14 +1,17 @@
 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();
 
-    // Limit actions per frame to prevent blocking when resuming from background
-    private const int MaxActionsPerFrame = 10;
+    // 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;
@@ -21,19 +24,29 @@ public class MainQueue : MonoBehaviour {
 
     // Update is called once per frame
     void Update() {
-        int actionsProcessed = 0;
         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 > MaxActionsPerFrame && queueDepthBefore != _lastLoggedQueueDepth) {
+        if (queueDepthBefore > 100 && queueDepthBefore != _lastLoggedQueueDepth) {
             Debug.Log($"[MainQueue] Processing backlog: {queueDepthBefore} actions queued");
             _lastLoggedQueueDepth = queueDepthBefore;
-        } else if (queueDepthBefore <= MaxActionsPerFrame) {
+        } else if (queueDepthBefore <= 100) {
             _lastLoggedQueueDepth = 0;
         }
 
+        var stopwatch = Stopwatch.StartNew();
         Action possibleAction;
         do {
             possibleAction = null;
@@ -41,11 +54,8 @@ public class MainQueue : MonoBehaviour {
                 if (_actionQueue.Count > 0) { possibleAction = _actionQueue.Dequeue(); }
             }
 
-            if (possibleAction != null) {
-                possibleAction.Invoke();
-                actionsProcessed++;
-            }
-        } while (possibleAction != null && actionsProcessed < MaxActionsPerFrame);
+            if (possibleAction != null) { possibleAction.Invoke(); }
+        } while (possibleAction != null && stopwatch.ElapsedMilliseconds < MaxMillisecondsPerFrame);
 
         lock (_nextUpdateQueue) {
             foreach (Action action in _nextUpdateQueue) { Enqueue(action); }

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

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

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

@@ -511,6 +511,7 @@ public class HexGrid : MonoBehaviour {
     }
 
     public void ClearCellLabels() {
+        if (cells == null) return;
         for (int i = 0; i < width * height; i++) {
             cells[i].UpperUnitInfoLabel.text = "";
             cells[i].LowerUnitInfoLabel.text = "";

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

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

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

@@ -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));

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

@@ -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) {

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/common/GUIUtils/AutoScrollingText.cs

@@ -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);
+        }
+    }
+}

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/common/GUIUtils/AutoScrollingText.cs.meta

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

src/main/csharp/net/eagle0/clients/unity/eagle0/Assets/common/GUIUtils/ErrorHandler.cs

@@ -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) {

src/main/protobuf/net/eagle0/common/shardok_internal_interface.proto

@@ -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;

src/main/protobuf/net/eagle0/eagle/api/BUILD.bazel

@@ -3,6 +3,22 @@ load("@io_bazel_rules_go//proto:def.bzl", "go_proto_library")
 load("@rules_proto//proto:defs.bzl", "proto_library")
 load("@rules_scala//scala_proto:scala_proto.bzl", "scala_proto_library")
 
+# Auth service for OAuth login
+scala_proto_library(
+    name = "auth_scala_grpc",
+    visibility = [
+        "//src/main/scala/net/eagle0:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle:__subpackages__",
+    ],
+    deps = [":auth_grpc"],
+)
+
+proto_library(
+    name = "auth_grpc",
+    srcs = ["auth.proto"],
+    visibility = ["//visibility:public"],
+)
+
 scala_proto_library(
     name = "eagle_scala_grpc",
     visibility = [
@@ -242,6 +258,7 @@ go_proto_library(
     compilers = ["@io_bazel_rules_go//proto:go_grpc"],  # keep
     importpath = "github.com/nolen777/eagle0/src/main/protobuf/net/eagle0/eagle/api/eagle",  # keep
     protos = [
+        ":auth_grpc",
         ":available_command_proto",
         ":command_proto",
         ":eagle_grpc",

src/main/protobuf/net/eagle0/eagle/api/auth.proto

@@ -0,0 +1,108 @@
+//
+// Copyright 2025 Dan Crosby
+//
+
+syntax = "proto3";
+
+package net.eagle0.eagle.api.auth;
+
+option java_multiple_files = true;
+option java_package = "net.eagle0.eagle.api.auth";
+option java_outer_classname = "AuthProto";
+option objc_class_prefix = "E0A";
+
+// Authentication service for OAuth login
+service Auth {
+    // Get OAuth URL to open in system browser
+    rpc GetOAuthUrl(GetOAuthUrlRequest) returns (GetOAuthUrlResponse) {}
+
+    // Exchange authorization code for JWT tokens
+    rpc ExchangeCode(ExchangeCodeRequest) returns (ExchangeCodeResponse) {}
+
+    // Set or update display name (requires valid JWT)
+    rpc SetDisplayName(SetDisplayNameRequest) returns (SetDisplayNameResponse) {}
+
+    // Refresh access token using refresh token
+    rpc RefreshToken(RefreshTokenRequest) returns (RefreshTokenResponse) {}
+
+    // Get current user info (validates JWT)
+    rpc GetCurrentUser(GetCurrentUserRequest) returns (GetCurrentUserResponse) {}
+
+    // Logout - invalidates refresh token
+    rpc Logout(LogoutRequest) returns (LogoutResponse) {}
+}
+
+// OAuth provider enumeration
+enum OAuthProvider {
+    OAUTH_PROVIDER_UNSPECIFIED = 0;
+    OAUTH_PROVIDER_DISCORD = 1;
+    OAUTH_PROVIDER_GOOGLE = 2;
+}
+
+// Request to initiate OAuth flow
+message GetOAuthUrlRequest {
+    OAuthProvider provider = 1;
+    string redirect_uri = 2;  // e.g., "eagle0://auth/callback"
+}
+
+message GetOAuthUrlResponse {
+    string auth_url = 1;  // Full OAuth URL to open in system browser
+    string state = 2;     // State parameter for CSRF protection
+}
+
+// Exchange authorization code for JWT
+message ExchangeCodeRequest {
+    OAuthProvider provider = 1;
+    string authorization_code = 2;
+    string state = 3;         // Must match state from GetOAuthUrlResponse
+    string redirect_uri = 4;  // Must match exactly what was used in GetOAuthUrlRequest
+}
+
+message ExchangeCodeResponse {
+    string access_token = 1;   // JWT for API access
+    string refresh_token = 2;  // Long-lived token for getting new access tokens
+    int64 expires_at = 3;      // Unix timestamp when access_token expires
+    UserInfo user = 4;
+    bool is_new_user = 5;      // True if user needs to set display name
+}
+
+// User information returned from auth endpoints
+message UserInfo {
+    string user_id = 1;       // Internal Eagle0 user ID (UUID)
+    string display_name = 2;  // Player-chosen display name (may be empty for new users)
+    string avatar_url = 3;    // Profile picture URL from OAuth provider
+    OAuthProvider provider = 4;
+}
+
+// Set or update display name
+message SetDisplayNameRequest {
+    string display_name = 1;  // 3-20 characters, alphanumeric + underscore
+}
+
+message SetDisplayNameResponse {
+    bool success = 1;
+    string error_message = 2;  // If not success: "Name taken", "Invalid characters", etc.
+    UserInfo user = 3;
+}
+
+// Refresh access token
+message RefreshTokenRequest {
+    string refresh_token = 1;
+}
+
+message RefreshTokenResponse {
+    string access_token = 1;
+    int64 expires_at = 2;
+}
+
+// Get current user info
+message GetCurrentUserRequest {}
+
+message GetCurrentUserResponse {
+    UserInfo user = 1;
+}
+
+// Logout
+message LogoutRequest {}
+
+message LogoutResponse {}

src/main/protobuf/net/eagle0/eagle/common/action_result_notification_details.proto

@@ -284,6 +284,12 @@ message ProfessionGainedDetails {
     Profession new_profession = 3;
 }
 
+message NewFactionHeadDetails {
+    int32 new_head_hero_id = 1;
+    int32 faction_id = 2;
+    int32 previous_head_hero_id = 3;
+}
+
 message NotificationDetails {
     oneof sealed_value {
         AllianceAcceptedDetails alliance_accepted_details = 30;
@@ -324,5 +330,6 @@ message NotificationDetails {
         VassalExiledDetails vassal_exiled_details = 8;
         WithdrewForTruceDetails withdrew_for_truce = 3;
         ProfessionGainedDetails profession_gained_details = 35;
+        NewFactionHeadDetails new_faction_head_details = 39;
     }
 }

src/main/protobuf/net/eagle0/eagle/internal/BUILD.bazel

@@ -772,6 +772,17 @@ proto_library(
     ],
 )
 
+scala_proto_library(
+    name = "user_scala_proto",
+    deps = [":user_proto"],
+)
+
+proto_library(
+    name = "user_proto",
+    srcs = ["user.proto"],
+    deps = ["@com_google_protobuf//:timestamp_proto"],
+)
+
 go_proto_library(
     name = "internal_go_proto",
     importpath = "github.com/nolen777/eagle0/src/main/protobuf/net/eagle0/eagle/internal",
@@ -802,6 +813,7 @@ go_proto_library(
         ":shardok_results_proto",
         ":supplies_proto",
         ":unaffiliated_hero_proto",
+        ":user_proto",
     ],
     deps = [
         "//src/main/protobuf/net/eagle0/common:common_go_proto",

src/main/protobuf/net/eagle0/eagle/internal/changed_faction.proto

@@ -53,4 +53,6 @@ message ChangedFaction {
 
     .google.protobuf.Int32Value new_last_acted_province_id = 22;
     bool clear_last_acted_province_id = 23;
+
+    .google.protobuf.StringValue new_name = 26;
 }

src/main/protobuf/net/eagle0/eagle/internal/client_text.proto

@@ -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 {

src/main/protobuf/net/eagle0/eagle/internal/generated_text_request.proto

@@ -72,6 +72,7 @@ message GeneratedTextRequestDetails {
         PrisonerReleasedMessage prisoner_released_message = 32;
         PrisonerExiledMessage prisoner_exiled_message = 33;
         PrisonerReturnedMessage prisoner_returned_message = 34;
+        NewFactionHeadMessage new_faction_head_message = 35;
     }
 }
 
@@ -334,3 +335,13 @@ message PrisonerReturnedMessage {
     int32 to_faction_id = 4;
     int32 province_id = 5;
 }
+
+message NewFactionHeadMessage {
+    int32 new_head_hero_id = 1;
+    int32 faction_id = 2;
+    string previous_faction_name = 3;
+    // If present, the faction is being renamed to this
+    string new_faction_name = 4;
+    // The previous faction head who was executed
+    int32 previous_head_hero_id = 5;
+}

src/main/protobuf/net/eagle0/eagle/internal/hero.proto

@@ -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;
 }

src/main/protobuf/net/eagle0/eagle/internal/user.proto

@@ -0,0 +1,65 @@
+//
+// Copyright 2025 Dan Crosby
+//
+
+syntax = "proto3";
+
+package net.eagle0.eagle.internal.user;
+
+import "google/protobuf/timestamp.proto";
+
+option java_multiple_files = true;
+option java_package = "net.eagle0.eagle.internal.user";
+
+// Internal user record stored in users.pb
+message User {
+    string user_id = 1;              // UUID generated by Eagle
+    string display_name = 2;         // Unique, player-chosen name
+    string display_name_lower = 3;   // Lowercase version for uniqueness checks
+
+    // OAuth identities (a user can have multiple linked providers)
+    repeated OAuthIdentity oauth_identities = 4;
+
+    google.protobuf.Timestamp created_at = 5;
+    google.protobuf.Timestamp last_login_at = 6;
+
+    string avatar_url = 7;
+
+    // Admin flag - allows impersonating other users for debugging
+    // Set manually in the database, not via API
+    bool is_admin = 8;
+}
+
+// OAuth identity from a provider
+message OAuthIdentity {
+    string provider = 1;           // "discord" or "google"
+    string provider_user_id = 2;   // ID from the OAuth provider
+    string email = 3;              // Email from provider (for account recovery)
+    google.protobuf.Timestamp linked_at = 4;
+}
+
+// Container for all users (stored as single file)
+message UserDatabase {
+    repeated User users = 1;
+
+    // Indexes for fast lookup (provider:provider_user_id -> user_id)
+    map<string, string> oauth_index = 2;
+
+    // display_name_lower -> user_id
+    map<string, string> display_name_index = 3;
+}
+
+// Refresh token record
+message RefreshToken {
+    string token_id = 1;           // UUID
+    string user_id = 2;
+    string token_hash = 3;         // SHA-256 hash of actual token
+    google.protobuf.Timestamp created_at = 4;
+    google.protobuf.Timestamp expires_at = 5;
+    bool revoked = 6;
+}
+
+// Container for refresh tokens
+message RefreshTokenDatabase {
+    repeated RefreshToken tokens = 1;
+}

src/main/protobuf/net/eagle0/eagle/views/faction_view.proto

@@ -43,4 +43,6 @@ message FactionViewDiff {
     repeated .net.eagle0.eagle.common.DiplomacyOffer removed_incoming_diplomacy_offers = 13;
 
     .google.protobuf.Int32Value new_focus_province_id = 11;
+
+    .google.protobuf.StringValue new_name = 14;
 }

src/main/resources/net/eagle0/eagle/BUILD.bazel

@@ -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__",
     ],

src/main/resources/net/eagle0/shardok/BUILD.bazel

@@ -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__",

src/main/scala/net/eagle0/common/llm_integration/ApiKeys.scala

@@ -7,7 +7,11 @@ object ApiKeys {
   private val apiKeyFilePath =
     "src/main/scala/net/eagle0/common/llm_integration/api_keys.txt"
 
-  // These must have valid values set in api_keys.txt
+  // Environment variable names
+  private val openAIEnvVar    = "OPENAI_API_KEY"
+  private val anthropicEnvVar = "ANTHROPIC_API_KEY"
+
+  // File key names
   private val openAIKeyName    = "openai_api_key"
   private val anthropicKeyName = "anthropic_api_key"
 
@@ -23,25 +27,31 @@ object ApiKeys {
           )
       }.toMap
     }.getOrElse {
-      throw new ApiKeyException(
-        "Failed to read api_keys.txt. Make sure you have copied api_keys_template.txt to api_keys.txt and set the keys."
-      )
+      Map.empty // Return empty map if file doesn't exist; we'll check env vars
     }
 
   private val dictionary = readDictionary()
 
-  private def getKey(key: String): String =
-    dictionary.get(key) match {
-      case None                                     =>
-        throw new ApiKeyException(s"$key not found")
-      case Some(value) if value.startsWith("your_") =>
-        throw new ApiKeyException(
-          s"API key for $key is not set. Please set it in $apiKeyFilePath."
-        )
-      case Some(value)                              => value
+  private def getKey(key: String, envVar: String): String =
+    // First check environment variable
+    Option(System.getenv(envVar)).filter(_.nonEmpty) match {
+      case Some(value) => value
+      case None        =>
+        // Fall back to file-based dictionary
+        dictionary.get(key) match {
+          case None                                     =>
+            throw new ApiKeyException(
+              s"$key not found. Set $envVar environment variable or add to $apiKeyFilePath."
+            )
+          case Some(value) if value.startsWith("your_") =>
+            throw new ApiKeyException(
+              s"API key for $key is not set. Set $envVar environment variable or update $apiKeyFilePath."
+            )
+          case Some(value)                              => value
+        }
     }
 
-  lazy val openAI: String = getKey(openAIKeyName)
+  lazy val openAI: String = getKey(openAIKeyName, openAIEnvVar)
 
-  lazy val anthropic: String = getKey(anthropicKeyName)
+  lazy val anthropic: String = getKey(anthropicKeyName, anthropicEnvVar)
 }

src/main/scala/net/eagle0/common/llm_integration/BUILD.bazel

@@ -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"],

src/main/scala/net/eagle0/common/llm_integration/ExternalTextGenerationCaller.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()
+    }
   }
 }

src/main/scala/net/eagle0/common/llm_integration/ExternalTextGenerationCallerApp.scala

@@ -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 { _ =>

src/main/scala/net/eagle0/common/llm_integration/OpenAIResponsesServiceImpl.scala

@@ -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)
+        )
+    )
+}

src/main/scala/net/eagle0/common/sse/BUILD.bazel

@@ -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",
+    ],
+)

src/main/scala/net/eagle0/common/sse/OkHttpSseListener.scala

@@ -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)
+    }
+}

src/main/scala/net/eagle0/eagle/BUILD.bazel

@@ -7,19 +7,26 @@ scala_binary(
     visibility = ["//visibility:public"],
     deps = [
         ":eagle_pkg",
+        "//src/main/protobuf/net/eagle0/eagle/api:auth_scala_grpc",
         "//src/main/protobuf/net/eagle0/eagle/api:eagle_scala_grpc",
+        "//src/main/protobuf/net/eagle0/eagle/internal:user_scala_proto",
         "//src/main/scala/net/eagle0/common:functional_random",
         "//src/main/scala/net/eagle0/common:simple_timed_logger",
+        "//src/main/scala/net/eagle0/eagle/auth:jwt_service",
+        "//src/main/scala/net/eagle0/eagle/auth:oauth_service",
+        "//src/main/scala/net/eagle0/eagle/auth:user_service",
         "//src/main/scala/net/eagle0/eagle/service",
+        "//src/main/scala/net/eagle0/eagle/service:auth_service",
         "//src/main/scala/net/eagle0/eagle/service:authorization_interceptor",
         "//src/main/scala/net/eagle0/eagle/service:custom_battle_manager",
         "//src/main/scala/net/eagle0/eagle/service:exception_interceptor",
         "//src/main/scala/net/eagle0/eagle/service:games_manager",
         "//src/main/scala/net/eagle0/eagle/service:server_setup_helpers",
+        "//src/main/scala/net/eagle0/eagle/service/persistence:local_file_persister",
+        "//src/main/scala/net/eagle0/eagle/service/persistence:save_directory",
         "//src/main/scala/net/eagle0/eagle/shardok_interface:battle_resolution",
         "//src/main/scala/net/eagle0/eagle/shardok_interface:battle_update",
         "//src/main/scala/net/eagle0/eagle/shardok_interface:battle_update_receiver",
-        # "@maven//:com_thesamet_scalapb_scalapb_runtime_3",
     ],
 )
 

src/main/scala/net/eagle0/eagle/Main.scala

@@ -6,8 +6,11 @@ import scala.util.Random
 
 import io.grpc.{Server, ServerBuilder}
 import net.eagle0.common.{FunctionalRandom, SeededRandom, SimpleTimedLogger}
+import net.eagle0.eagle.api.auth.auth.AuthGrpc
 import net.eagle0.eagle.api.eagle.EagleGrpc
+import net.eagle0.eagle.auth.{JwtService, JwtServiceImpl, OAuthServiceImpl, UserServiceImpl}
 import net.eagle0.eagle.service.*
+import net.eagle0.eagle.service.persistence.{LocalFilePersister, SaveDirectory}
 
 object Main {
   import ServerSetupHelpers.*
@@ -92,6 +95,13 @@ object Main {
   ): Server = {
     val serverBuilder = ServerBuilder.forPort(grpcPort)
 
+    // Initialize auth services
+    val jwtService: Option[JwtService] = JwtServiceImpl.fromEnvironment()
+    val authPersister                  = LocalFilePersister(SaveDirectory.saveDirectory)
+    val userService                    = new UserServiceImpl(authPersister)
+    val oauthService                   = new OAuthServiceImpl()
+
+    // Add Eagle game service
     serverBuilder.addService(
       EagleGrpc
         .bindService(
@@ -99,8 +109,27 @@ object Main {
           ExecutionContext.global
         )
     )
+
+    // Add Auth service (only if JWT is configured)
+    jwtService.foreach { jwt =>
+      serverBuilder.addService(
+        AuthGrpc
+          .bindService(
+            AuthServiceImpl(oauthService, userService, jwt),
+            ExecutionContext.global
+          )
+      )
+      SimpleTimedLogger.printLogger.logLine("OAuth auth service enabled")
+    }
+
+    if jwtService.isEmpty then {
+      SimpleTimedLogger.printLogger.logLine(
+        "OAuth auth service disabled (no JWT keys configured). Using Basic Auth only."
+      )
+    }
+
     serverBuilder.intercept(new ExceptionInterceptor)
-    serverBuilder.intercept(new AuthorizationInterceptor)
+    serverBuilder.intercept(new AuthorizationInterceptor(jwtService))
 
     serverBuilder.build
   }

src/main/scala/net/eagle0/eagle/ai/AIClient.scala

@@ -195,7 +195,7 @@ case class AIClient(
             AlmsCommandSelector
               .chosenAlmsForSupportWithMinimumCommandForProvince(
                 actingFactionId = fid,
-                gameState = gs,
+                gameState = GameStateConverter.fromProto(gs),
                 availableCommands = acs,
                 minimumFood = 0,
                 provinceId = opac.provinceId

src/main/scala/net/eagle0/eagle/ai/BUILD.bazel

@@ -74,6 +74,8 @@ scala_library(
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:available_command_selector",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:province_gold_surplus_calculator",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:trust_for_diplomacy",
+        "//src/main/scala/net/eagle0/eagle/model/proto_converters/game_state",
+        "//src/main/scala/net/eagle0/eagle/model/state/game_state",
     ],
 )
 
@@ -187,14 +189,15 @@ scala_library(
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:available_command_selector",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:command_chooser",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:expand_command_selector",
-        "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:food_consumption_utils",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:fulfill_quests_command_selector",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:improve_command_selector",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:organize_command_selector",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:province_gold_surplus_calculator",
         "//src/main/scala/net/eagle0/eagle/library/util/faction_utils:legacy_faction_utils",
+        "//src/main/scala/net/eagle0/eagle/library/util/food_consumption:legacy_food_consumption_utils",
         "//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/model/proto_converters/game_state",
     ],
 )
 
@@ -236,7 +239,10 @@ scala_library(
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:available_command_selector",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:command_chooser",
         "//src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers:ransom_offer_helpers",
+        "//src/main/scala/net/eagle0/eagle/library/util/faction_utils",
         "//src/main/scala/net/eagle0/eagle/library/util/faction_utils:legacy_faction_utils",
+        "//src/main/scala/net/eagle0/eagle/model/state/faction",
+        "//src/main/scala/net/eagle0/eagle/model/state/province",
     ],
 )
 

src/main/scala/net/eagle0/eagle/ai/InvitationCommandSelector.scala

@@ -8,6 +8,7 @@ import net.eagle0.eagle.library.settings.MinChanceForAIInvite
 import net.eagle0.eagle.library.util.command_choice_helpers.{ProvinceGoldSurplusCalculator, TrustForDiplomacy}
 import net.eagle0.eagle.library.util.command_choice_helpers.AvailableCommandSelector.flatSelectionForType
 import net.eagle0.eagle.library.util.CommandSelection
+import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
 import net.eagle0.eagle.FactionId
 
 object InvitationCommandSelector {
@@ -22,16 +23,16 @@ object InvitationCommandSelector {
       availableCommands: Vector[AvailableCommand]
   ): Option[CommandSelection] =
     flatSelectionForType[DiplomacyAvailableCommand](acs = availableCommands) { diplomacyAvailableCommand =>
+      val nativeGameState = GameStateConverter.fromProto(gameState)
       diplomacyAvailableCommand.options.collect { case io: InvitationOption => io }.filter { invitationOption =>
         TrustForDiplomacy.meetsConditionsForInvitation(
           actingFactionId = actingFactionId,
           targetFactionId = invitationOption.targetFactionId,
-          gameState = gameState
+          gameState = nativeGameState
         )
       }.filter { invitationOption =>
         ProvinceGoldSurplusCalculator.provinceGoldSurplus(
-          diplomacyAvailableCommand.actingProvinceId,
-          gameState
+          nativeGameState.provinces(diplomacyAvailableCommand.actingProvinceId)
         ) >= invitationOption.goldCost
       }.map { invitationOption =>
         InvitationOptionWithChance(
@@ -39,7 +40,8 @@ object InvitationCommandSelector {
           acceptanceChance = ResolveDiplomacyCommandSelector.invitationAcceptanceChance(
             actingFactionId,
             invitationOption.targetFactionId,
-            gameState
+            nativeGameState.factions.values.toVector,
+            nativeGameState.provinces.values.toVector
           )
         )
       }.maxByOption(_.acceptanceChance)

src/main/scala/net/eagle0/eagle/ai/MidGameAIClient.scala

@@ -19,7 +19,6 @@ import net.eagle0.eagle.library.util.command_choice_helpers.{
   CommandChoiceHelpers,
   CommandChooser,
   ExpandCommandSelector,
-  FoodConsumptionUtils,
   FulfillQuestsCommandSelector,
   ImproveCommandSelector,
   OrganizeCommandSelector,
@@ -29,9 +28,11 @@ import net.eagle0.eagle.library.util.command_choice_helpers.AvailableCommandSele
 import net.eagle0.eagle.library.util.command_choice_helpers.CommandChoiceHelpers.*
 import net.eagle0.eagle.library.util.command_choice_helpers.CommandChooserImplicits.*
 import net.eagle0.eagle.library.util.faction_utils.LegacyFactionUtils
+import net.eagle0.eagle.library.util.food_consumption.LegacyFoodConsumptionUtils
 import net.eagle0.eagle.library.util.hero.LegacyHeroUtils
 import net.eagle0.eagle.library.util.province.LegacyProvinceUtils
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
+import net.eagle0.eagle.model.proto_converters.game_state.GameStateConverter
 import net.eagle0.eagle.views.battalion_view.BattalionView
 import net.eagle0.eagle.views.province_view.FullProvinceInfo
 
@@ -137,7 +138,7 @@ object MidGameAIClient {
           ) =>
         val actingProvince       = gameState.provinces(actingProvinceId)
         val foodMonthsToHoldBack =
-          FoodConsumptionUtils.foodConsumptionMonthsToHold(
+          LegacyFoodConsumptionUtils.foodConsumptionMonthsToHold(
             actingProvinceId,
             gameState
           )
@@ -269,7 +270,7 @@ object MidGameAIClient {
             RandomState(
               ImproveCommandSelector.chosenImproveCommand(
                 actingFactionId,
-                gameState,
+                GameStateConverter.fromProto(gameState),
                 availableCommands
               ),
               functionalRandom
@@ -298,7 +299,7 @@ object MidGameAIClient {
             RandomState(
               ImproveCommandSelector.chosenImproveCommand(
                 actingFactionId,
-                gameState,
+                GameStateConverter.fromProto(gameState),
                 availableCommands
               ),
               functionalRandom
@@ -345,7 +346,18 @@ object MidGameAIClient {
             acs = availableCommands,
             choosersAndReasons = Vector(
               (
-                ExpandCommandSelector.maybeChosenExpandCommand,
+                (
+                    fid: FactionId,
+                    gs: GameState,
+                    acs: Vector[AvailableCommand],
+                    fr: FunctionalRandom
+                ) =>
+                  ExpandCommandSelector.maybeChosenExpandCommand(
+                    fid,
+                    GameStateConverter.fromProto(gs),
+                    acs,
+                    fr
+                  ),
                 "no hostile neighbors, expand"
               ),
               (
@@ -362,7 +374,7 @@ object MidGameAIClient {
                   RandomState(
                     ImproveCommandSelector.chosenImproveCommand(
                       actingFactionId,
-                      gameState,
+                      GameStateConverter.fromProto(gameState),
                       availableCommands
                     ),
                     functionalRandom
@@ -450,7 +462,7 @@ object MidGameAIClient {
                   RandomState(
                     ImproveCommandSelector.chosenImproveCommand(
                       actingFactionId,
-                      gameState,
+                      GameStateConverter.fromProto(gameState),
                       availableCommands
                     ),
                     functionalRandom
@@ -505,7 +517,7 @@ object MidGameAIClient {
 
     AttackCommandChooser.chosenAttackCommand(
       actingFactionId,
-      gs,
+      GameStateConverter.fromProto(gs),
       acs,
       reconnedHeroCountFor,
       reconnedBattalionsFor
@@ -525,13 +537,13 @@ object MidGameAIClient {
         AlmsCommandSelector
           .chosenAlmsForSupportCommand(
             actingFactionId = actingFactionId,
-            gameState = gameState,
+            gameState = GameStateConverter.fromProto(gameState),
             availableCommands = availableCommands
           )
           .orElse {
             ImproveCommandSelector.chosenImproveCommand(
               actingFactionId = actingFactionId,
-              gameState = gameState,
+              gameState = GameStateConverter.fromProto(gameState),
               availableCommands = availableCommands
             )
           }
@@ -564,7 +576,7 @@ object MidGameAIClient {
             RandomState(
               AttackCommandChooser.chosenSupportAttackCommand(
                 actingFactionId,
-                gameState,
+                GameStateConverter.fromProto(gameState),
                 availableCommands
               ),
               functionalRandom
@@ -790,7 +802,7 @@ object MidGameAIClient {
                       OrganizeCommandSelector
                         .chosenOrganizeCommandWithFoodSurplus(
                           actingFactionId = fid,
-                          gameState = gs,
+                          gameState = GameStateConverter.fromProto(gs),
                           availableCommands = acs,
                           extraFoodSurplus = foodSurplus(
                             gs,

src/main/scala/net/eagle0/eagle/ai/ResolveDiplomacyCommandSelector.scala

@@ -39,10 +39,12 @@ import net.eagle0.eagle.library.util.command_choice_helpers.AvailableCommandSele
   randomSelectionForType,
   selectionForType
 }
-import net.eagle0.eagle.library.util.faction_utils.LegacyFactionUtils
+import net.eagle0.eagle.library.util.faction_utils.{FactionUtils, LegacyFactionUtils}
 import net.eagle0.eagle.library.util.CommandSelection
 import net.eagle0.eagle.library.util.EagleRequire.internalRequire
 import net.eagle0.eagle.library.EagleInternalException
+import net.eagle0.eagle.model.state.faction.FactionT
+import net.eagle0.eagle.model.state.province.ProvinceT
 import net.eagle0.eagle.FactionId
 
 object ResolveDiplomacyCommandSelector {
@@ -140,6 +142,20 @@ object ResolveDiplomacyCommandSelector {
       - LegacyFactionUtils.prestige(invitedFid, gs)
       - MinimumPrestigeDifferenceToInvite.doubleValue).floor.toInt.max(0)
 
+  /** Protoless version */
+  def invitationAcceptanceChance(
+      originatingFid: FactionId,
+      invitedFid: FactionId,
+      factions: Vector[FactionT],
+      provinces: Vector[ProvinceT]
+  ): Int = {
+    val originatingFaction = factions.find(_.id == originatingFid).get
+    val invitedFaction     = factions.find(_.id == invitedFid).get
+    (FactionUtils.prestige(originatingFaction, provinces)
+      - FactionUtils.prestige(invitedFaction, provinces)
+      - MinimumPrestigeDifferenceToInvite.doubleValue).floor.toInt.max(0)
+  }
+
   private def resolveTruceOfferSelectedCommand(
       actingFactionId: FactionId,
       gameState: GameState,

src/main/scala/net/eagle0/eagle/ai/SeekMoreLeadersCommandChooser.scala

@@ -97,7 +97,7 @@ object SeekMoreLeadersCommandChooser {
             .filter(_.rulingFactionHeroIds.length > 1)
             .flatMap { province =>
               SwornBrotherChooser
-                .bestChoice(
+                .bestChoiceProto(
                   province.rulingFactionHeroIds.map(gameState.heroes),
                   gameState.factions(actingFactionId).leaders.toVector
                 )
@@ -142,7 +142,7 @@ object SeekMoreLeadersCommandChooser {
         MoreOption
           .flatWhen(needsMoreLeaders(actingFactionId, gameState)) {
             // First try a hero that's already here
-            val desiredHero = SwornBrotherChooser.bestChoice(
+            val desiredHero = SwornBrotherChooser.bestChoiceProto(
               leaderProvince.rulingFactionHeroIds.map(gameState.heroes),
               faction.leaders.toVector
             )
@@ -151,7 +151,6 @@ object SeekMoreLeadersCommandChooser {
               SwearBrotherhoodCommandSelector
                 .chosenCommandForSpecificHero(
                   actingFactionId = actingFactionId,
-                  gameState = gameState,
                   availableCommands = acs,
                   desiredHeroId = hero.id
                 )
@@ -170,7 +169,6 @@ object SeekMoreLeadersCommandChooser {
                 .orElse {
                   HeroGiftCommandSelector.chosenCommandForSpecificHero(
                     actingFactionId = actingFactionId,
-                    gameState = gameState,
                     availableCommands = acs,
                     heroId = hero.id,
                     reason = "want to make this hero a leader"

src/main/scala/net/eagle0/eagle/auth/BUILD.bazel

@@ -0,0 +1,51 @@
+load("@rules_scala//scala:scala.bzl", "scala_library")
+
+scala_library(
+    name = "jwt_service",
+    srcs = ["JwtService.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle:__subpackages__",
+    ],
+    deps = [
+        "@maven//:com_nimbusds_nimbus_jose_jwt",
+    ],
+)
+
+scala_library(
+    name = "oauth_config",
+    srcs = ["OAuthConfig.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle:__subpackages__",
+    ],
+)
+
+scala_library(
+    name = "oauth_service",
+    srcs = ["OAuthService.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle:__subpackages__",
+    ],
+    deps = [
+        ":oauth_config",
+        "//src/main/protobuf/net/eagle0/eagle/api:auth_scala_grpc",
+        "@maven//:org_json4s_json4s_ast_3",
+        "@maven//:org_json4s_json4s_core_3",
+        "@maven//:org_json4s_json4s_native_3",
+    ],
+)
+
+scala_library(
+    name = "user_service",
+    srcs = ["UserService.scala"],
+    visibility = [
+        "//src/main/scala/net/eagle0/eagle:__subpackages__",
+        "//src/test/scala/net/eagle0/eagle:__subpackages__",
+    ],
+    deps = [
+        "//src/main/protobuf/net/eagle0/eagle/internal:user_scala_proto",
+        "//src/main/scala/net/eagle0/eagle/service/persistence:persister",
+    ],
+)

src/main/scala/net/eagle0/eagle/auth/JwtService.scala

@@ -0,0 +1,182 @@
+package net.eagle0.eagle.auth
+
+import java.security.MessageDigest
+import java.time.Instant
+import java.util.{Date, UUID}
+
+import scala.jdk.CollectionConverters.*
+import scala.util.Try
+
+import com.nimbusds.jose.{JWSAlgorithm, JWSHeader}
+import com.nimbusds.jose.crypto.{RSASSASigner, RSASSAVerifier}
+import com.nimbusds.jose.jwk.gen.RSAKeyGenerator
+import com.nimbusds.jose.jwk.RSAKey
+import com.nimbusds.jwt.{JWTClaimsSet, SignedJWT}
+
+/** JWT claims extracted from a validated token */
+case class JwtClaims(
+    userId: String,
+    displayName: String,
+    isAdmin: Boolean,
+    issuedAt: Instant,
+    expiresAt: Instant
+)
+
+/** Refresh token with metadata */
+case class RefreshTokenInfo(
+    tokenId: String,
+    userId: String,
+    tokenHash: String,
+    expiresAt: Instant
+)
+
+/** Service for creating and validating JWT tokens */
+trait JwtService {
+
+  /** Create an access token for a user */
+  def createAccessToken(userId: String, displayName: String, isAdmin: Boolean): String
+
+  /** Create a refresh token (returns token string and info for storage) */
+  def createRefreshToken(userId: String): (String, RefreshTokenInfo)
+
+  /** Validate an access token and extract claims */
+  def validateAccessToken(token: String): Option[JwtClaims]
+
+  /** Hash a refresh token for storage */
+  def hashRefreshToken(token: String): String
+}
+
+class JwtServiceImpl(rsaKey: RSAKey) extends JwtService {
+
+  private val accessTokenDuration  = java.time.Duration.ofDays(7)
+  private val refreshTokenDuration = java.time.Duration.ofDays(30)
+  private val issuer               = "eagle0"
+
+  private val signer   = new RSASSASigner(rsaKey)
+  private val verifier = new RSASSAVerifier(rsaKey.toPublicJWK)
+
+  override def createAccessToken(
+      userId: String,
+      displayName: String,
+      isAdmin: Boolean
+  ): String = {
+    val now       = Instant.now()
+    val expiresAt = now.plus(accessTokenDuration)
+
+    val claimsBuilder = new JWTClaimsSet.Builder()
+      .subject(userId)
+      .issuer(issuer)
+      .issueTime(Date.from(now))
+      .expirationTime(Date.from(expiresAt))
+      .claim("name", displayName)
+
+    // Only include admin claim if true to keep tokens smaller
+    if isAdmin then {
+      claimsBuilder.claim("admin", true)
+    }
+
+    val signedJWT = new SignedJWT(
+      new JWSHeader.Builder(JWSAlgorithm.RS256).keyID(rsaKey.getKeyID).build(),
+      claimsBuilder.build()
+    )
+
+    signedJWT.sign(signer)
+    signedJWT.serialize()
+  }
+
+  override def createRefreshToken(userId: String): (String, RefreshTokenInfo) = {
+    val tokenId     = UUID.randomUUID().toString
+    val tokenSecret = UUID.randomUUID().toString
+    val token       = s"$tokenId.$tokenSecret"
+    val tokenHash   = hashRefreshToken(token)
+    val expiresAt   = Instant.now().plus(refreshTokenDuration)
+
+    val info = RefreshTokenInfo(
+      tokenId = tokenId,
+      userId = userId,
+      tokenHash = tokenHash,
+      expiresAt = expiresAt
+    )
+
+    (token, info)
+  }
+
+  override def validateAccessToken(token: String): Option[JwtClaims] =
+    Try {
+      val signedJWT = SignedJWT.parse(token)
+
+      // Verify signature
+      if !signedJWT.verify(verifier) then {
+        return None
+      }
+
+      val claims = signedJWT.getJWTClaimsSet
+
+      // Check issuer
+      if claims.getIssuer != issuer then {
+        return None
+      }
+
+      // Check expiration
+      val expirationTime = claims.getExpirationTime
+      if expirationTime == null || expirationTime.before(new Date()) then {
+        return None
+      }
+
+      val userId      = claims.getSubject
+      val displayName = Option(claims.getStringClaim("name")).getOrElse("")
+      val isAdmin     = Option(claims.getBooleanClaim("admin")).map(_.booleanValue()).getOrElse(false)
+      val issuedAt    = claims.getIssueTime.toInstant
+      val expiresAt   = expirationTime.toInstant
+
+      Some(
+        JwtClaims(
+          userId = userId,
+          displayName = displayName,
+          isAdmin = isAdmin,
+          issuedAt = issuedAt,
+          expiresAt = expiresAt
+        )
+      )
+    }.toOption.flatten
+
+  override def hashRefreshToken(token: String): String = {
+    val digest    = MessageDigest.getInstance("SHA-256")
+    val hashBytes = digest.digest(token.getBytes("UTF-8"))
+    hashBytes.map("%02x".format(_)).mkString
+  }
+}
+
+object JwtServiceImpl {
+
+  /** Generate a new RSA key pair for JWT signing */
+  def generateKey(): RSAKey =
+    new RSAKeyGenerator(2048)
+      .keyID(UUID.randomUUID().toString)
+      .generate()
+
+  /** Load RSA key from JSON string (JWK format) */
+  def loadKey(json: String): RSAKey =
+    RSAKey.parse(json)
+
+  /** Create a JwtService with a new generated key (for testing) */
+  def withGeneratedKey(): JwtServiceImpl =
+    new JwtServiceImpl(generateKey())
+
+  /** Create a JwtService from a JWK JSON string */
+  def fromKeyJson(json: String): JwtServiceImpl =
+    new JwtServiceImpl(loadKey(json))
+
+  /**
+   * Create a JwtService from environment variables.
+   *
+   * Looks for JWT_PRIVATE_KEY environment variable containing RSA key in JWK format. If not found, returns None (auth
+   * will fall back to Basic Auth only).
+   */
+  def fromEnvironment(): Option[JwtServiceImpl] =
+    sys.env.get("JWT_PRIVATE_KEY").flatMap { keyJson =>
+      Try {
+        fromKeyJson(keyJson)
+      }.toOption
+    }
+}

src/main/scala/net/eagle0/eagle/auth/OAuthConfig.scala

@@ -0,0 +1,41 @@
+package net.eagle0.eagle.auth
+
+/** Configuration for an OAuth provider */
+case class OAuthProviderConfig(
+    clientId: String,
+    clientSecret: String,
+    authorizationEndpoint: String,
+    tokenEndpoint: String,
+    userInfoEndpoint: String,
+    scopes: Seq[String]
+)
+
+/** OAuth configuration loaded from environment variables */
+object OAuthConfig {
+
+  def discord: OAuthProviderConfig = OAuthProviderConfig(
+    clientId = sys.env.getOrElse("DISCORD_CLIENT_ID", ""),
+    clientSecret = sys.env.getOrElse("DISCORD_CLIENT_SECRET", ""),
+    authorizationEndpoint = "https://discord.com/api/oauth2/authorize",
+    tokenEndpoint = "https://discord.com/api/oauth2/token",
+    userInfoEndpoint = "https://discord.com/api/users/@me",
+    scopes = Seq("identify", "email")
+  )
+
+  def google: OAuthProviderConfig = OAuthProviderConfig(
+    clientId = sys.env.getOrElse("GOOGLE_CLIENT_ID", ""),
+    clientSecret = sys.env.getOrElse("GOOGLE_CLIENT_SECRET", ""),
+    authorizationEndpoint = "https://accounts.google.com/o/oauth2/v2/auth",
+    tokenEndpoint = "https://oauth2.googleapis.com/token",
+    userInfoEndpoint = "https://www.googleapis.com/oauth2/v2/userinfo",
+    scopes = Seq("openid", "email", "profile")
+  )
+
+  /** Check if Discord OAuth is configured */
+  def isDiscordConfigured: Boolean =
+    discord.clientId.nonEmpty && discord.clientSecret.nonEmpty
+
+  /** Check if Google OAuth is configured */
+  def isGoogleConfigured: Boolean =
+    google.clientId.nonEmpty && google.clientSecret.nonEmpty
+}

src/main/scala/net/eagle0/eagle/auth/OAuthService.scala

@@ -0,0 +1,213 @@
+// Copyright 2025 Dan Crosby
+package net.eagle0.eagle.auth
+
+import java.net.{URI, URLEncoder}
+import java.net.http.{HttpClient, HttpRequest, HttpResponse}
+import java.nio.charset.StandardCharsets
+import java.time.Duration
+import java.util.UUID
+
+import scala.collection.concurrent.TrieMap
+import scala.util.Try
+
+import net.eagle0.eagle.api.auth.auth.OAuthProvider
+import org.json4s.{DefaultFormats, JObject, JString}
+import org.json4s.jvalue2extractable
+import org.json4s.jvalue2monadic
+import org.json4s.native.Json
+
+/** User info from OAuth provider */
+case class ProviderUserInfo(
+    id: String,
+    email: String,
+    avatarUrl: String,
+    username: String
+)
+
+/** Service for OAuth code exchange */
+trait OAuthService {
+
+  /** Generate OAuth authorization URL */
+  def getAuthUrl(provider: OAuthProvider, redirectUri: String): (String, String) // (url, state)
+
+  /** Exchange authorization code for user info */
+  def exchangeCode(
+      provider: OAuthProvider,
+      code: String,
+      state: String,
+      redirectUri: String
+  ): Either[String, ProviderUserInfo]
+}
+
+class OAuthServiceImpl extends OAuthService {
+
+  private implicit val formats: DefaultFormats.type = DefaultFormats
+  private val json                                  = new Json(formats)
+
+  private val httpClient = HttpClient
+    .newBuilder()
+    .connectTimeout(Duration.ofSeconds(10))
+    .build()
+
+  // State parameter storage with timestamp (for CSRF protection)
+  private val stateStore = TrieMap[String, Long]()
+
+  // State expiration (10 minutes)
+  private val stateExpirationMs = 600000L
+
+  override def getAuthUrl(provider: OAuthProvider, redirectUri: String): (String, String) = {
+    val config = getConfig(provider)
+
+    val state = UUID.randomUUID().toString
+    stateStore.put(state, System.currentTimeMillis())
+
+    // Clean old states
+    val cutoff = System.currentTimeMillis() - stateExpirationMs
+    stateStore.filterInPlace((_, timestamp) => timestamp > cutoff)
+
+    val params = Map(
+      "client_id"     -> config.clientId,
+      "redirect_uri"  -> redirectUri,
+      "response_type" -> "code",
+      "scope"         -> config.scopes.mkString(" "),
+      "state"         -> state
+    )
+
+    val queryString = params.map {
+      case (k, v) =>
+        s"$k=${URLEncoder.encode(v, StandardCharsets.UTF_8)}"
+    }
+      .mkString("&")
+
+    val url = s"${config.authorizationEndpoint}?$queryString"
+    (url, state)
+  }
+
+  override def exchangeCode(
+      provider: OAuthProvider,
+      code: String,
+      state: String,
+      redirectUri: String
+  ): Either[String, ProviderUserInfo] = {
+    // Verify state
+    stateStore.remove(state) match {
+      case Some(timestamp) if System.currentTimeMillis() - timestamp < stateExpirationMs =>
+      // Valid state
+      case _                                                                             =>
+        return Left("Invalid or expired state parameter")
+    }
+
+    val config = getConfig(provider)
+
+    // Exchange code for access token
+    val tokenResult = exchangeCodeForToken(config, code, redirectUri)
+    tokenResult match {
+      case Left(error)        => Left(error)
+      case Right(accessToken) =>
+        // Fetch user info
+        fetchUserInfo(provider, config, accessToken)
+    }
+  }
+
+  private def getConfig(provider: OAuthProvider): OAuthProviderConfig =
+    provider match {
+      case OAuthProvider.OAUTH_PROVIDER_DISCORD => OAuthConfig.discord
+      case OAuthProvider.OAUTH_PROVIDER_GOOGLE  => OAuthConfig.google
+      case _ => throw new IllegalArgumentException(s"Unsupported provider: $provider")
+    }
+
+  private def exchangeCodeForToken(
+      config: OAuthProviderConfig,
+      code: String,
+      redirectUri: String
+  ): Either[String, String] =
+    Try {
+      val formData = Map(
+        "client_id"     -> config.clientId,
+        "client_secret" -> config.clientSecret,
+        "grant_type"    -> "authorization_code",
+        "code"          -> code,
+        "redirect_uri"  -> redirectUri
+      )
+
+      val formBody = formData.map {
+        case (k, v) =>
+          s"${URLEncoder.encode(k, StandardCharsets.UTF_8)}=${URLEncoder.encode(v, StandardCharsets.UTF_8)}"
+      }
+        .mkString("&")
+
+      val request = HttpRequest
+        .newBuilder()
+        .uri(URI.create(config.tokenEndpoint))
+        .timeout(Duration.ofSeconds(10))
+        .header("Content-Type", "application/x-www-form-urlencoded")
+        .header("Accept", "application/json")
+        .POST(HttpRequest.BodyPublishers.ofString(formBody))
+        .build()
+
+      val response = httpClient.send(request, HttpResponse.BodyHandlers.ofString())
+      val body     = response.body()
+
+      if response.statusCode() < 200 || response.statusCode() >= 300 then {
+        return Left(s"Token exchange failed: ${response.statusCode()} - $body")
+      }
+
+      val parsed      = json.parse(body)
+      val accessToken = (parsed \ "access_token").extract[String]
+      Right(accessToken)
+    }.toEither.left.map(e => s"Token exchange error: ${e.getMessage}").flatten
+
+  private def fetchUserInfo(
+      provider: OAuthProvider,
+      config: OAuthProviderConfig,
+      accessToken: String
+  ): Either[String, ProviderUserInfo] =
+    Try {
+      val request = HttpRequest
+        .newBuilder()
+        .uri(URI.create(config.userInfoEndpoint))
+        .timeout(Duration.ofSeconds(10))
+        .header("Authorization", s"Bearer $accessToken")
+        .header("Accept", "application/json")
+        .GET()
+        .build()
+
+      val response = httpClient.send(request, HttpResponse.BodyHandlers.ofString())
+      val body     = response.body()
+
+      if response.statusCode() < 200 || response.statusCode() >= 300 then {
+        return Left(s"User info fetch failed: ${response.statusCode()} - $body")
+      }
+
+      val parsed = json.parse(body)
+      parseUserInfo(provider, parsed)
+    }.toEither.left.map(e => s"User info fetch error: ${e.getMessage}").flatten
+
+  private def parseUserInfo(
+      provider: OAuthProvider,
+      data: org.json4s.JValue
+  ): Either[String, ProviderUserInfo] =
+    Try {
+      provider match {
+        case OAuthProvider.OAUTH_PROVIDER_DISCORD =>
+          val id         = (data \ "id").extract[String]
+          val username   = (data \ "username").extract[String]
+          val email      = (data \ "email").extractOpt[String].getOrElse("")
+          val avatarHash = (data \ "avatar").extractOpt[String]
+          val avatarUrl  = avatarHash
+            .map(hash => s"https://cdn.discordapp.com/avatars/$id/$hash.png")
+            .getOrElse("")
+          ProviderUserInfo(id, email, avatarUrl, username)
+
+        case OAuthProvider.OAUTH_PROVIDER_GOOGLE =>
+          val id        = (data \ "id").extract[String]
+          val email     = (data \ "email").extractOpt[String].getOrElse("")
+          val name      = (data \ "name").extractOpt[String].getOrElse("")
+          val avatarUrl = (data \ "picture").extractOpt[String].getOrElse("")
+          ProviderUserInfo(id, email, avatarUrl, name)
+
+        case _ =>
+          throw new IllegalArgumentException(s"Unsupported provider: $provider")
+      }
+    }.toEither.left.map(e => s"Failed to parse user info: ${e.getMessage}")
+}

src/main/scala/net/eagle0/eagle/auth/UserService.scala

@@ -0,0 +1,176 @@
+// Copyright 2025 Dan Crosby
+package net.eagle0.eagle.auth
+
+import java.time.Instant
+import java.util.UUID
+
+import scala.util.{Success, Using}
+
+import com.google.protobuf.timestamp.Timestamp
+import net.eagle0.eagle.internal.user.user.{OAuthIdentity, User, UserDatabase}
+import net.eagle0.eagle.service.persistence.Persister
+
+/** Service for managing user records */
+trait UserService {
+
+  /** Find or create a user from OAuth provider info */
+  def findOrCreateUser(
+      provider: String,
+      providerUserId: String,
+      email: String,
+      avatarUrl: String
+  ): User
+
+  /** Find user by internal user ID */
+  def findByUserId(userId: String): Option[User]
+
+  /** Find user by display name (case-insensitive) */
+  def findByDisplayName(displayName: String): Option[User]
+
+  /** Set or update display name */
+  def setDisplayName(userId: String, displayName: String): Either[String, User]
+
+  /** Check if display name is available */
+  def isDisplayNameAvailable(displayName: String): Boolean
+}
+
+class UserServiceImpl(persister: Persister) extends UserService {
+
+  private val usersPath = "auth/users.pb"
+
+  // Thread-safe access to user database
+  private var database: UserDatabase = loadDatabase()
+  private val lock                   = new Object
+
+  private def loadDatabase(): UserDatabase =
+    persister.retrieveAsStream(usersPath) match {
+      case Success(stream) =>
+        Using(stream) { s =>
+          UserDatabase.parseFrom(s)
+        }.getOrElse(UserDatabase.defaultInstance)
+      case _               => UserDatabase.defaultInstance
+    }
+
+  private def saveDatabase(): Unit = {
+    persister.save(usersPath, database.toByteArray)
+    ()
+  }
+
+  private def nowTimestamp: Timestamp = {
+    val now = Instant.now()
+    Timestamp(now.getEpochSecond, now.getNano)
+  }
+
+  override def findOrCreateUser(
+      provider: String,
+      providerUserId: String,
+      email: String,
+      avatarUrl: String
+  ): User = lock.synchronized {
+    val oauthKey = s"$provider:$providerUserId"
+
+    database.oauthIndex.get(oauthKey) match {
+      case Some(existingUserId) =>
+        // Update last login, avatar
+        val user    = findByUserIdInternal(existingUserId).get
+        val updated = user.copy(
+          lastLoginAt = Some(nowTimestamp),
+          avatarUrl = avatarUrl
+        )
+        updateUser(updated)
+        updated
+
+      case None =>
+        // Create new user
+        val userId   = UUID.randomUUID().toString
+        val now      = nowTimestamp
+        val identity = OAuthIdentity(
+          provider = provider,
+          providerUserId = providerUserId,
+          email = email,
+          linkedAt = Some(now)
+        )
+        val user     = User(
+          userId = userId,
+          displayName = "",
+          displayNameLower = "",
+          oauthIdentities = Seq(identity),
+          createdAt = Some(now),
+          lastLoginAt = Some(now),
+          avatarUrl = avatarUrl,
+          isAdmin = false
+        )
+
+        database = database.copy(
+          users = database.users :+ user,
+          oauthIndex = database.oauthIndex + (oauthKey -> userId)
+        )
+        saveDatabase()
+        user
+    }
+  }
+
+  override def findByUserId(userId: String): Option[User] = lock.synchronized {
+    findByUserIdInternal(userId)
+  }
+
+  private def findByUserIdInternal(userId: String): Option[User] =
+    database.users.find(_.userId == userId)
+
+  override def findByDisplayName(displayName: String): Option[User] = lock.synchronized {
+    val lowerName = displayName.toLowerCase
+    database.displayNameIndex.get(lowerName).flatMap(findByUserIdInternal)
+  }
+
+  override def setDisplayName(userId: String, displayName: String): Either[String, User] =
+    lock.synchronized {
+      // Validate: 3-20 chars, alphanumeric + underscore
+      val validPattern = "^[a-zA-Z0-9_]{3,20}$".r
+      if !validPattern.matches(displayName) then {
+        return Left("Display name must be 3-20 characters, alphanumeric and underscore only")
+      }
+
+      val lowerName = displayName.toLowerCase
+
+      // Check uniqueness
+      database.displayNameIndex.get(lowerName) match {
+        case Some(existingId) if existingId != userId =>
+          Left("Display name already taken")
+        case _                                        =>
+          findByUserIdInternal(userId) match {
+            case Some(user) =>
+              // Remove old name from index if exists
+              val newIndex = user.displayNameLower match {
+                case ""  => database.displayNameIndex
+                case old => database.displayNameIndex - old
+              }
+
+              val updated = user.copy(
+                displayName = displayName,
+                displayNameLower = lowerName
+              )
+
+              database = database.copy(
+                users = database.users.filterNot(_.userId == userId) :+ updated,
+                displayNameIndex = newIndex + (lowerName -> userId)
+              )
+              saveDatabase()
+              Right(updated)
+
+            case None =>
+              Left("User not found")
+          }
+      }
+    }
+
+  override def isDisplayNameAvailable(displayName: String): Boolean = lock.synchronized {
+    !database.displayNameIndex.contains(displayName.toLowerCase)
+  }
+
+  private def updateUser(user: User): Unit = {
+    database = database.copy(
+      users = database.users.filterNot(_.userId == user.userId) :+ user
+    )
+    saveDatabase()
+  }
+}

src/main/scala/net/eagle0/eagle/client_text/ClientText.scala

@@ -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)

src/main/scala/net/eagle0/eagle/client_text/ClientTextStore.scala

@@ -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(

src/main/scala/net/eagle0/eagle/client_text/ClientTextStoreImpl.scala

@@ -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 =>

src/main/scala/net/eagle0/eagle/library/BUILD.bazel

@@ -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,11 +211,9 @@ 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/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",
@@ -218,11 +224,8 @@ scala_library(
         "//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",

src/main/scala/net/eagle0/eagle/library/EngineImpl.scala

@@ -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,36 @@ 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(
+    ).withTCommandAndLastCommand(
+      commandGen = gs =>
+        commandFactory.makeTCommand(
           actingFactionId = factionId,
-          gameState = GameStateConverter.fromProto(gs),
+          gameState = gs,
           availableCommand = availableCommand,
           selectedCommand = selectedCommand
-        )
-        .execute(actionResultProtoApplier)
-        .map(_.actionResult)
+        ),
+      selectedCommand = selectedCommand
+    ).withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator(gs))
 
-      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"
+    // 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"
+    )
 
-      results
-    }.withProtolessSequentialResultsAction(gs => HeroBackstoryUpdateActionGenerator.fromGameState(gs))
-
-    appliedResults(
+    appliedResultsScala(
       engine = this,
-      results = sequencer.results.newValue
+      results = sequencer.resultsWithStates.newValue
     )
   }
 }

src/main/scala/net/eagle0/eagle/library/GameHistory.scala

@@ -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(

src/main/scala/net/eagle0/eagle/library/RoundPhaseAdvancer.scala

@@ -3,38 +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.validations.ScalaRuntimeValidator
 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
@@ -48,332 +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 NEW_ROUND =>
-        NewRoundAction(GameStateConverter.fromProto(currentState), history).execute(actionResultProtoApplier)
-
-      case PRISONER_EXCHANGE =>
-        actionResultProtoApplier.applyActionResults(
+      case PrisonerExchange =>
+        actionResultApplier.applyActionResults(
           currentState,
-          PrisonerExchangeAction(GameStateConverter.fromProto(currentState)).results
-            .map(ActionResultProtoConverter.toProto)
+          PrisonerExchangeAction(currentState).results
         )
 
-      case PROVINCE_EVENTS =>
-        PerformProvinceEventsAction(
-          GameStateConverter.fromProto(currentState)
-        ).execute(currentState, actionResultProtoApplier)
-
-      case FORCED_TURN_BACK =>
-        actionResultProtoApplier.applyActionResults(
+      case ProvinceEvents =>
+        actionResultApplier.applyActionResults(
           currentState,
-          PerformForcedTurnBackAction(GameStateConverter.fromProto(currentState)).results
-            .map(ActionResultProtoConverter.toProto)
+          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,
-            applier = ActionResultTApplierImpl(ScalaRuntimeValidator)
-          ).execute(currentState, actionResultProtoApplier)
+            actionResultApplier = actionResultApplier
+          ).results(SeededRandom(currentState.randomSeed))
+            .map(VigorXPApplier.withVigorXp)
+          actionResultApplier.applyActionResults(currentState, actionResults)
 
-      case HERO_DEPARTURES =>
-        PerformHeroDeparturesAction(
-          gameState = GameStateConverter.fromProto(currentState)
-        ).execute(currentState, 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(GameStateConverter.fromProto(currentState)).immediateExecute
-              )
+              EndPleaseRecruitMePhaseAction(currentState).immediateExecute
             )
           )
 
-      case VASSAL_COMMANDS =>
+      case VassalCommands =>
         val vassalCommandResults = PerformVassalCommandsPhaseAction(
-          gameState = GameStateConverter.fromProto(currentState),
+          gameState = currentState,
           commandsForProvince = availableCommandsFactory
-            .commandPhaseCommandsForProvince(currentState, _),
+            .commandPhaseCommandsForProvince(currentStateProto, _),
           commandFactory = commandFactory,
-          applier = ActionResultTApplierImpl(ScalaRuntimeValidator)
-        ).execute(currentState, actionResultProtoApplier)
+          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(
-              GameStateConverter.fromProto(currentState),
-              ActionResultTApplierImpl(ScalaRuntimeValidator)
-            ).randomResults(functionalRandom = SeededRandom(currentState.randomSeed))
-              .newValue
-              .map(
-                ActionResultProtoConverter.toProto(_)
-              )
+              currentState,
+              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(GameStateConverter.fromProto(currentState)).results.map(
-              ActionResultProtoConverter.toProto(_)
-            )
+            EndFreeForAllDecisionPhaseAction(currentState).results
           )
 
-      case FREE_FOR_ALL_BATTLE_REQUEST =>
-        val requestResults = actionResultProtoApplier.applyActionResults(
+      case FreeForAllBattleRequest =>
+        val requestResults = actionResultApplier.applyActionResults(
           currentState,
-          RequestFreeForAllBattlesAction(
-            GameStateConverter.fromProto(currentState)
-          ).results.map(ActionResultProtoConverter.toProto)
+          RequestFreeForAllBattlesAction(currentState).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(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(
-            GameStateConverter.fromProto(currentState)
+            gameId = currentState.gameId,
+            currentRoundId = currentState.currentRoundId,
+            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(
-              GameStateConverter.fromProto(currentState)
-            ).results.map(ActionResultProtoConverter.toProto)
+              gameId = currentState.gameId,
+              currentRoundId = currentState.currentRoundId,
+              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, _),
+              .defensePhaseCommandsForProvince(currentStateProto, _),
             commandFactory = commandFactory,
-            applier = ActionResultTApplierImpl(ScalaRuntimeValidator)
-          ).execute(currentState, actionResultProtoApplier)
+            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(GameStateConverter.fromProto(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(
-          GameStateConverter.fromProto(currentState)
+          gameId = currentState.gameId,
+          currentRoundId = currentState.currentRoundId,
+          currentDate = currentState.currentDate.get,
+          battleCounter = currentState.battleCounter,
+          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(GameStateConverter.fromProto(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(
-              GameStateConverter.fromProto(currentState),
-              ActionResultTApplierImpl(ScalaRuntimeValidator)
+              currentState,
+              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(
-              GameStateConverter.fromProto(currentState),
-              actionResultTApplier = ActionResultTApplierImpl(ScalaRuntimeValidator)
-            ).randomResults(SeededRandom(currentState.randomSeed))
-              .newValue
-              .map(ActionResultProtoConverter.toProto)
+              currentState,
+              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"
     )
 }

src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplier.scala

@@ -9,8 +9,6 @@ case class ActionResultWithResultingState(
 )
 
 trait ActionResultApplier {
-  def xpForStatBump(stat: Int): Int
-
   def applyActionResults(
       startingState: GameState,
       results: Iterable[ActionResultT]

src/main/scala/net/eagle0/eagle/library/actions/applier/ActionResultApplierImpl.scala

@@ -56,8 +56,6 @@ class ActionResultApplierImpl(validator: Option[ScalaValidator]) extends ActionR
   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]
@@ -114,6 +112,7 @@ class ActionResultApplierImpl(validator: Option[ScalaValidator]) extends ActionR
     // 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)