Refocus command guidance on players

* Clarify diplomacy offer timing

* Clarify vassal command documentation

.bazelrc

@@ -14,6 +14,7 @@ common --worker_sandboxing
 common --local_test_jobs=64
 common --jobs=64
 
+# Keep these C++ standard flags in sync with tools/copts.bzl and scripts/shardok_cpp_config.sh.
 common --cxxopt="--std=c++23"
 common --cxxopt="-Wno-deprecated-non-prototype"
 common --per_file_copt=src/test/cpp/.*@-Wno-character-conversion
@@ -37,6 +38,8 @@ build:ubsan --strip=never
 build:ubsan --copt=-fno-omit-frame-pointer
 build:ubsan --copt=-Wno-macro-redefined
 build:ubsan --copt=-fsanitize=undefined
+# Protobuf's arena implementation trips UBSan alignment checks in external code on macOS.
+build:ubsan --copt=-fno-sanitize=alignment
 build:ubsan --linkopt=-fsanitize=undefined
 test:ubsan --test_env=UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1
 

.clang-tidy

@@ -2,25 +2,17 @@ Checks: >
   -*,
   bugprone-*,
   performance-*,
-  readability-*,
-  modernize-*,
-  cppcoreguidelines-*,
+  modernize-use-nullptr,
+  modernize-use-override,
+  modernize-use-auto,
+  modernize-use-nodiscard,
+  readability-braces-around-statements,
+  readability-qualified-auto,
+  readability-redundant-member-init,
+  cppcoreguidelines-pro-type-cstyle-cast,
   -bugprone-easily-swappable-parameters,
-  -cppcoreguidelines-avoid-magic-numbers,
-  -cppcoreguidelines-macro-usage,
-  -cppcoreguidelines-owning-memory,
-  -cppcoreguidelines-pro-bounds-array-to-pointer-decay,
-  -cppcoreguidelines-pro-bounds-constant-array-index,
-  -cppcoreguidelines-pro-bounds-pointer-arithmetic,
-  -cppcoreguidelines-pro-type-const-cast,
-  -cppcoreguidelines-pro-type-reinterpret-cast,
-  -cppcoreguidelines-pro-type-union-access,
-  -cppcoreguidelines-pro-type-vararg,
-  -modernize-use-trailing-return-type,
-  -readability-convert-member-functions-to-static,
-  -readability-function-cognitive-complexity,
-  -readability-identifier-length,
-  -readability-magic-numbers
+  -bugprone-branch-clone,
+  -bugprone-signed-char-misuse
 WarningsAsErrors: ''
 HeaderFilterRegex: 'src/(main|test)/cpp/net/eagle0/(shardok|common)/.*'
 FormatStyle: file

.github/workflows/bazel_test.yml

@@ -12,6 +12,10 @@ on:
       - '.bazelrc'
       - 'ci/github_actions/ensure_bazel_installed.sh'
       - 'ci/github_actions/summarize_bazel_bep.py'
+      - '.clang-tidy'
+      - 'scripts/run-clang-tidy.sh'
+      - 'scripts/check_shardok_clang_tidy.sh'
+      - 'scripts/sync_bazel_xcode.sh'
       - '.github/actions/setup-bazel/**'
       - '.github/workflows/bazel_test.yml'
       - '!src/main/csharp/**'
@@ -26,6 +30,10 @@ on:
       - '.bazelrc'
       - 'ci/github_actions/ensure_bazel_installed.sh'
       - 'ci/github_actions/summarize_bazel_bep.py'
+      - '.clang-tidy'
+      - 'scripts/run-clang-tidy.sh'
+      - 'scripts/check_shardok_clang_tidy.sh'
+      - 'scripts/sync_bazel_xcode.sh'
       - '.github/actions/setup-bazel/**'
       - '.github/workflows/bazel_test.yml'
       - '!src/main/csharp/**'
@@ -78,6 +86,8 @@ jobs:
         node-version: 'lts/*'
     - name: Check JavaScript syntax
       run: node --check src/main/go/net/eagle0/admin_server/static/map_editor.js
+    - name: Check Shardok clang-tidy gate
+      run: ./scripts/check_shardok_clang_tidy.sh
 
   test:
     runs-on: [self-hosted, bazel]
@@ -112,6 +122,8 @@ jobs:
         lfs: false
     - name: Setup Bazel
       uses: ./.github/actions/setup-bazel
+    - name: Sync Bazel Xcode config
+      run: ./scripts/sync_bazel_xcode.sh
     - name: Run tests
       run: bazel test --build_event_json_file=test.json //src/test/... //src/main/go/...
     - name: Summarize Bazel build metrics

.github/workflows/docker_build.yml

@@ -19,6 +19,7 @@ on:
       - 'src/main/resources/**'
       - 'ci/BUILD.bazel'
       - 'ci/github_actions/ensure_bazel_installed.sh'
+      - 'scripts/sync_bazel_xcode.sh'
       - '.github/actions/setup-bazel/**'
       - 'MODULE.bazel'
       - 'MODULE.bazel.lock'
@@ -41,6 +42,7 @@ on:
       - 'ci/BUILD.bazel'
       - 'ci/github_actions/ensure_bazel_installed.sh'
       - 'ci/github_actions/fetch_lfs.sh'
+      - 'scripts/sync_bazel_xcode.sh'
       - '.github/actions/setup-bazel/**'
       - 'go.mod'
       - 'go.sum'
@@ -125,6 +127,10 @@ jobs:
         if: steps.check-latest.outputs.skip != 'true'
         uses: ./.github/actions/setup-bazel
 
+      - name: Sync Bazel Xcode config
+        if: steps.check-latest.outputs.skip != 'true'
+        run: ./scripts/sync_bazel_xcode.sh
+
       - name: Fetch LFS files needed for admin server
         if: steps.check-latest.outputs.skip != 'true'
         env:

.github/workflows/eagle0pedia_build.yml

@@ -0,0 +1,86 @@
+name: Eagle0pedia Build
+
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - 'docs/eagle0pedia/**'
+      - 'ci/github_actions/ensure_bazel_installed.sh'
+      - '.github/actions/setup-bazel/**'
+      - '.github/workflows/eagle0pedia_build.yml'
+      - 'MODULE.bazel'
+      - 'MODULE.bazel.lock'
+      - '.bazelrc'
+  pull_request:
+    paths:
+      - 'docs/eagle0pedia/**'
+      - 'ci/github_actions/ensure_bazel_installed.sh'
+      - '.github/actions/setup-bazel/**'
+      - '.github/workflows/eagle0pedia_build.yml'
+      - 'MODULE.bazel'
+      - 'MODULE.bazel.lock'
+      - '.bazelrc'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  build:
+    runs-on: [self-hosted, bazel]
+    steps:
+      - name: Prepare workspace
+        run: |
+          chmod -R u+w eagle0pedia-dist 2>/dev/null || true
+          rm -rf eagle0pedia-dist
+
+      - name: Prepare non-LFS checkout
+        env:
+          GIT_CONFIG_GLOBAL: ${{ runner.temp }}/gitconfig-no-lfs
+          GIT_CONFIG_NOSYSTEM: "1"
+        run: |
+          git config --global --unset-all filter.lfs.process || true
+          git config --global filter.lfs.smudge "cat"
+          git config --global filter.lfs.clean "cat"
+          git config --global filter.lfs.required false
+          if [ -d ".git" ]; then
+            git config --local --unset-all filter.lfs.process || true
+            git config --local filter.lfs.smudge "cat"
+            git config --local filter.lfs.clean "cat"
+            git config --local filter.lfs.required false
+          fi
+          rm -f .git/hooks/post-checkout .git/hooks/post-merge .git/hooks/pre-push
+
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        env:
+          GIT_CONFIG_GLOBAL: ${{ runner.temp }}/gitconfig-no-lfs
+          GIT_CONFIG_NOSYSTEM: "1"
+        with:
+          persist-credentials: false
+          lfs: false
+
+      - name: Setup Bazel
+        uses: ./.github/actions/setup-bazel
+
+      - name: Build Eagle0pedia
+        run: bazel build //docs/eagle0pedia:site
+
+      - name: Stage static site artifact
+        run: |
+          rm -rf eagle0pedia-dist
+          mkdir -p eagle0pedia-dist
+          cp -R bazel-bin/docs/eagle0pedia/dist/. eagle0pedia-dist/
+          chmod -R u+w eagle0pedia-dist
+
+      - name: Upload static site artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: eagle0pedia-dist
+          path: eagle0pedia-dist/
+          if-no-files-found: error
+          retention-days: 3

.github/workflows/shardok_sanitizer_test.yml

@@ -0,0 +1,92 @@
+name: Shardok Sanitizer Test
+
+on:
+  push:
+    branches: ["main"]
+    paths:
+      - "src/main/cpp/net/eagle0/shardok/**"
+      - "src/test/cpp/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/common/**"
+      - "WORKSPACE"
+      - "MODULE.bazel"
+      - "MODULE.bazel.lock"
+      - "BUILD.bazel"
+      - ".bazelrc"
+      - ".github/actions/setup-bazel/**"
+      - ".github/workflows/shardok_sanitizer_test.yml"
+      - "ci/github_actions/ensure_bazel_installed.sh"
+      - "ci/github_actions/summarize_bazel_bep.py"
+  pull_request:
+    paths:
+      - "src/main/cpp/net/eagle0/shardok/**"
+      - "src/test/cpp/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/shardok/**"
+      - "src/main/protobuf/net/eagle0/common/**"
+      - "WORKSPACE"
+      - "MODULE.bazel"
+      - "MODULE.bazel.lock"
+      - "BUILD.bazel"
+      - ".bazelrc"
+      - ".github/actions/setup-bazel/**"
+      - ".github/workflows/shardok_sanitizer_test.yml"
+      - "ci/github_actions/ensure_bazel_installed.sh"
+      - "ci/github_actions/summarize_bazel_bep.py"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  shardok-sanitizer-test:
+    name: Shardok ${{ matrix.name }}
+    runs-on: [self-hosted, bazel]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: ASan
+            config: asan
+          - name: UBSan
+            config: ubsan
+
+    steps:
+      - name: Ensure Git LFS available for checkout
+        run: |
+          COMMON_PATHS=(/opt/homebrew/bin /usr/local/bin)
+          for path in "${COMMON_PATHS[@]}"; do
+            if [ -d "$path" ]; then
+              echo "$path" >> "$GITHUB_PATH"
+              export PATH="$path:$PATH"
+            fi
+          done
+
+          if command -v git-lfs >/dev/null 2>&1; then
+            git-lfs version
+            exit 0
+          fi
+
+          brew install git-lfs
+          git-lfs version
+      - name: Checkout repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+          lfs: false
+      - name: Setup Bazel
+        uses: ./.github/actions/setup-bazel
+      - name: Run Shardok sanitizer tests
+        run: bazel test --config=${{ matrix.config }} --build_event_json_file=${{ matrix.config }}.json //src/test/cpp/net/eagle0/shardok/...
+      - name: Summarize Bazel build metrics
+        if: always()
+        run: python3 ci/github_actions/summarize_bazel_bep.py ${{ matrix.config }}.json
+      - name: Archive sanitizer test results
+        if: always()
+        uses: actions/upload-artifact@v7
+        with:
+          name: shardok-${{ matrix.config }}.json
+          path: ${{ matrix.config }}.json
+          retention-days: 3

AGENTS.md

@@ -11,6 +11,11 @@
 **NEVER kill Unity without asking the user first.** The user might be actively using the Unity Editor. Do not kill,
 force-quit, terminate, or otherwise stop Unity processes unless the user explicitly approves that specific action.
 
+**NEVER change Unity's default/open scene as part of running checks.** Unity batchmode or editor validation may write
+scene-selection churn such as `ProjectSettings/EditorBuildSettings.asset`, `ProjectSettings/SceneTemplateSettings.json`,
+or scene files simply because a different scene was open or loaded. Treat those as unintended local environment changes:
+do not stage them, and restore them before committing unless the user explicitly asked to change scenes/build settings.
+
 ## CRITICAL GIT RULES (NEVER VIOLATE)
 
 **NEVER use `git -C`.** Just run `git` directly from the cwd — it finds the repo via `.git` discovery. Do not `cd` to the repo root either (see the no-`cd` bash rule above).

MODULE.bazel

@@ -29,6 +29,23 @@ bazel_dep(name = "rules_nodejs", version = "6.7.4")
 bazel_dep(name = "rules_pkg", version = "1.2.0")
 bazel_dep(name = "rules_shell", version = "0.8.0")
 
+multiple_version_override(
+    module_name = "aspect_rules_js",
+    versions = [
+        "2.3.8",
+        "3.2.2",
+    ],
+)
+
+npm = use_extension("@aspect_rules_js//npm:extensions.bzl", "npm")
+npm.npm_translate_lock(
+    name = "eagle0pedia_npm",
+    pnpm_lock = "//docs/eagle0pedia:pnpm-lock.yaml",
+    run_lifecycle_hooks = False,
+    update_pnpm_lock = False,
+)
+use_repo(npm, "eagle0pedia_npm")
+
 #
 # Language Support - Scala
 #
@@ -365,6 +382,7 @@ maven.install(
         "org.xerial:sqlite-jdbc:3.53.2.0",
 
         # Postgres for production history benchmarking and migration work
+        "com.zaxxer:HikariCP:6.3.3",
         "org.postgresql:postgresql:42.7.11",
     ],
     duplicate_version_warning = "error",

docker-compose.prod.yml

@@ -39,6 +39,13 @@ services:
       EAGLE_POSTGRES_USER: "${EAGLE_POSTGRES_USER:-}"
       EAGLE_POSTGRES_PASSWORD: "${EAGLE_POSTGRES_PASSWORD:-}"
       EAGLE_POSTGRES_SSLMODE: "${EAGLE_POSTGRES_SSLMODE:-require}"
+      EAGLE_POSTGRES_MAX_POOL_SIZE: "${EAGLE_POSTGRES_MAX_POOL_SIZE:-7}"
+      EAGLE_POSTGRES_MIN_IDLE: "${EAGLE_POSTGRES_MIN_IDLE:-0}"
+      EAGLE_POSTGRES_CONNECTION_TIMEOUT_MILLIS: "${EAGLE_POSTGRES_CONNECTION_TIMEOUT_MILLIS:-10000}"
+      EAGLE_POSTGRES_IDLE_TIMEOUT_MILLIS: "${EAGLE_POSTGRES_IDLE_TIMEOUT_MILLIS:-120000}"
+      EAGLE_POSTGRES_MAX_LIFETIME_MILLIS: "${EAGLE_POSTGRES_MAX_LIFETIME_MILLIS:-1500000}"
+      EAGLE_POSTGRES_KEEPALIVE_TIME_MILLIS: "${EAGLE_POSTGRES_KEEPALIVE_TIME_MILLIS:-300000}"
+      EAGLE_POSTGRES_LEAK_DETECTION_THRESHOLD_MILLIS: "${EAGLE_POSTGRES_LEAK_DETECTION_THRESHOLD_MILLIS:-60000}"
       # JWT public key for token validation (auth service handles signing)
       # Reads from /etc/eagle0/keys/public.pem via shared volume
       # Auth token for Shardok on Hetzner (required)
@@ -95,6 +102,13 @@ services:
       EAGLE_POSTGRES_USER: "${EAGLE_POSTGRES_USER:-}"
       EAGLE_POSTGRES_PASSWORD: "${EAGLE_POSTGRES_PASSWORD:-}"
       EAGLE_POSTGRES_SSLMODE: "${EAGLE_POSTGRES_SSLMODE:-require}"
+      EAGLE_POSTGRES_MAX_POOL_SIZE: "${EAGLE_POSTGRES_MAX_POOL_SIZE:-7}"
+      EAGLE_POSTGRES_MIN_IDLE: "${EAGLE_POSTGRES_MIN_IDLE:-0}"
+      EAGLE_POSTGRES_CONNECTION_TIMEOUT_MILLIS: "${EAGLE_POSTGRES_CONNECTION_TIMEOUT_MILLIS:-10000}"
+      EAGLE_POSTGRES_IDLE_TIMEOUT_MILLIS: "${EAGLE_POSTGRES_IDLE_TIMEOUT_MILLIS:-120000}"
+      EAGLE_POSTGRES_MAX_LIFETIME_MILLIS: "${EAGLE_POSTGRES_MAX_LIFETIME_MILLIS:-1500000}"
+      EAGLE_POSTGRES_KEEPALIVE_TIME_MILLIS: "${EAGLE_POSTGRES_KEEPALIVE_TIME_MILLIS:-300000}"
+      EAGLE_POSTGRES_LEAK_DETECTION_THRESHOLD_MILLIS: "${EAGLE_POSTGRES_LEAK_DETECTION_THRESHOLD_MILLIS:-60000}"
       # JWT public key for token validation (auth service handles signing)
       # Reads from /etc/eagle0/keys/public.pem via shared volume
       SHARDOK_AUTH_TOKEN: "${SHARDOK_AUTH_TOKEN:-}"

docs/LLM_MODEL_COMPARISON.md

@@ -71,7 +71,7 @@ LLM settings can be changed at runtime via the admin console:
 1. Navigate to Admin Console → Settings
 2. Change `LlmProvider` to select vendor (gemini, openai, claude)
 3. Change the corresponding model name setting:
-   - `GeminiModelName` (default: gemini-3.1-flash-lite-preview)
+   - `GeminiModelName` (default: gemini-3.1-flash-lite)
    - `OpenAiModelName` (default: gpt-4.1-mini)
    - `ClaudeModelName` (default: claude-3-5-haiku-20241022)
 

docs/TEXT_CLIENT_OPERATOR_GUIDE.md

@@ -0,0 +1,136 @@
+# Text Client Operator Guide
+
+This guide covers operating the Eagle text client against a running Eagle server. It does not cover game strategy.
+
+## Authentication And Startup
+
+The current bearer-token file is:
+
+```
+/private/tmp/eagle0-text-client-token.txt
+```
+
+If that file is absent or authentication fails, stop and ask the user for a current bearer token. Do not invent a token or use another user's credentials.
+
+Start the production client with:
+
+```bash
+bazel run //src/main/scala/net/eagle0/eagle/text_client:eagle_text_client -- --tls --host prod.eagle0.net --port 443 --bearer-token-file /private/tmp/eagle0-text-client-token.txt
+```
+
+At the `eagle0>` prompt, use `lobby` to list running games and available new-game leaders. To resume a game, use:
+
+```text
+stream <game-id>
+```
+
+Wait for `subscription: success=true` before posting a command.
+
+## Inspecting State
+
+Use these commands before acting:
+
+```text
+status
+state
+commands
+commands-json
+```
+
+`state` is the concise map and owned-province view. `state-json` prints the complete view. `commands-json` includes the exact fields, IDs, resource amounts, and command choices currently accepted by the server.
+
+Generated text is stored locally during the client process. Use `text <text-id>` for a text ID without spaces, such as `text hn_105`. Province leaders in `state` are resolved through this store when their names have been received.
+
+## Posting Eagle Commands
+
+Use the available-command data from `commands-json` to select a command, then post a matching selected command:
+
+```text
+post-json <province-id> <SelectedCommandType> <JSON>
+```
+
+For example:
+
+```text
+post-json 13 ImproveSelectedCommand {"improvementType":"ECONOMY","actingHeroId":105,"lockType":true}
+post-rest 13
+post-feast 13
+```
+
+The client has shortcuts for `post-rest`, `post-return`, `post-feast`, riot decisions, and battle aftermath. Other selected-command JSON schemas are defined in:
+
+```text
+src/main/protobuf/net/eagle0/eagle/api/selected_command.proto
+```
+
+Only post a selected command that is currently listed as available. A successful request prints `post-command: SUCCESS`; do not assume a command was accepted until that response or a later game update arrives.
+
+Some actions enter a temporary subcommand state. For example, trading is operated as:
+
+```text
+post-json <province-id> TravelSelectedCommand {}
+post-json <province-id> TradeSelectedCommand {"tradeType":"BUY_FOOD","amount":<amount>}
+post-return <province-id>
+```
+
+After each step, run `commands-json` again. The server will reject a nested command, such as `TradeSelectedCommand`, if its parent state has not been entered.
+
+## March Warnings
+
+Marches may produce a warning before being sent. Review it, then resubmit only when intentional:
+
+```text
+post-json --force <province-id> MarchSelectedCommand <JSON>
+```
+
+`MarchSelectedCommand.marchingUnits` contains combat units. Each selected battalion is paired with a distinct hero in the same combat-unit entry; do not submit battalion-only entries.
+
+## Shardok Battles
+
+When a battle is active, inspect it with:
+
+```text
+shardok-units
+shardok-commands
+```
+
+Post one of the currently listed command indices with:
+
+```text
+post-shardok <index>
+```
+
+Omit the optional roll value during normal play. The server then generates any
+roll required by the selected command. To override that roll for deterministic
+testing, append an integer value:
+
+```text
+post-shardok <index> <integer-roll>
+```
+
+`roll` is a placeholder in command usage, not a literal argument. Only an
+integer is accepted, and the override has an effect only for Shardok commands
+that support a client-supplied roll.
+
+For a specific active battle:
+
+```text
+post-shardok <shardok-game-id> <index>
+post-shardok <shardok-game-id> <index> <integer-roll>
+```
+
+Use `shardok-commands-json` or `shardok-units-json` when the concise output omits a needed field.
+
+## Reconnects And Shutdown
+
+The client automatically recreates a failed gRPC stream and re-subscribes to the active game. It retains its in-process `ClientTextStore`, so a reconnect should announce:
+
+```text
+Reconnecting to game <game-id> with saved text state.
+```
+
+Followed by a successful subscription without replaying the full generated-text catalog. Do not start a second client merely because a stream reports `GOAWAY`, `UNAVAILABLE`, or `RST_STREAM`; wait for the automatic reconnect and subscription acknowledgment.
+
+The text store is in memory. A newly launched process performs an initial text sync once, then retains byte offsets for reconnects during that process.
+
+Use `quit` to close the client cleanly. Use `drop <game-id>` only when intentionally abandoning that game.

docs/eagle0pedia/BUILD.bazel

@@ -0,0 +1,44 @@
+load("@aspect_rules_js//js:defs.bzl", "js_binary", "js_run_binary")
+load("@eagle0pedia_npm//:defs.bzl", "npm_link_all_packages")
+
+package(default_visibility = ["//visibility:public"])
+
+exports_files([
+    "package.json",
+    "pnpm-lock.yaml",
+])
+
+npm_link_all_packages()
+
+filegroup(
+    name = "site_sources",
+    srcs = glob([
+        "src/**",
+        "astro.config.mjs",
+        "package.json",
+        "tsconfig.json",
+    ]),
+)
+
+js_binary(
+    name = "astro",
+    data = [
+        ":node_modules",
+    ],
+    entry_point = "tools/astro-cli.mjs",
+)
+
+js_run_binary(
+    name = "site",
+    srcs = [
+        ":node_modules",
+        ":site_sources",
+    ],
+    args = ["build"],
+    chdir = package_name(),
+    env = {
+        "ASTRO_TELEMETRY_DISABLED": "1",
+    },
+    out_dirs = ["dist"],
+    tool = ":astro",
+)

docs/eagle0pedia/README.md

@@ -0,0 +1,48 @@
+# Eagle0pedia Site
+
+Eagle0pedia is a Starlight static site. CI validates it through Bazel, while
+DigitalOcean App Platform builds and hosts it directly as a static site.
+
+## Local Build
+
+```bash
+bazel build //docs/eagle0pedia:site
+```
+
+The generated site is written to:
+
+```text
+bazel-bin/docs/eagle0pedia/dist
+```
+
+## Deployment
+
+Eagle0pedia is hosted by DigitalOcean App Platform as a static site. Use these
+component settings:
+
+```text
+Resource type: Static Site
+Source directory: docs/eagle0pedia
+Build command: corepack enable && pnpm install --frozen-lockfile && pnpm build
+Output directory: dist
+HTTP route: /
+Domain: pedia.eagle0.net
+```
+
+The App Platform build uses the normal Starlight package scripts:
+
+```text
+npm run build
+```
+
+Set this App Platform environment variable:
+
+```text
+ASTRO_TELEMETRY_DISABLED=1
+```
+
+CI still validates the Bazel build:
+
+```text
+bazel build //docs/eagle0pedia:site
+```

docs/eagle0pedia/astro.config.mjs

@@ -0,0 +1,50 @@
+import { defineConfig } from "astro/config";
+import starlight from "@astrojs/starlight";
+
+export default defineConfig({
+  site: "https://pedia.eagle0.net",
+  integrations: [
+    starlight({
+      title: "Eagle0pedia",
+      description: "Reference guide for Eagle0 commands, systems, and game concepts.",
+      customCss: ["./src/styles/custom.css"],
+      editLink: {
+        baseUrl: "https://github.com/nolen777/eagle0/edit/main/docs/eagle0pedia/src/content/docs/",
+      },
+      sidebar: [
+        {
+          label: "Reference",
+          items: [
+            { label: "Eagle0pedia", slug: "" },
+            {
+              label: "Concepts",
+              items: [
+                { label: "Game Concepts", slug: "concepts" },
+                { label: "Eagle Round Flow", slug: "concepts/eagle-round-flow" },
+                { label: "From Eagle to Shardok", slug: "concepts/eagle-to-shardok" },
+                { label: "Shardok Battles", slug: "concepts/shardok-battles" },
+                {
+                  label: "Shardok Victory Conditions",
+                  slug: "concepts/shardok-victory-conditions",
+                },
+              ],
+            },
+            { label: "Eagle Commands", slug: "commands" },
+            { label: "Shardok Commands", slug: "shardok-commands" },
+            { label: "Heroes", slug: "heroes" },
+            { label: "Factions", slug: "factions" },
+            { label: "Provinces", slug: "provinces" },
+            { label: "Integration Notes", slug: "integration" },
+          ],
+        },
+      ],
+      social: [
+        {
+          icon: "github",
+          label: "GitHub",
+          href: "https://github.com/nolen777/eagle0",
+        },
+      ],
+    }),
+  ],
+});

docs/eagle0pedia/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "eagle0pedia",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "packageManager": "pnpm@9.15.9",
+  "scripts": {
+    "build": "astro build",
+    "dev": "astro dev",
+    "preview": "astro preview"
+  },
+  "dependencies": {
+    "@astrojs/starlight": "^0.36.0",
+    "astro": "^5.11.0",
+    "sharp": "^0.34.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": []
+  }
+}

docs/eagle0pedia/src/content/config.ts

@@ -0,0 +1,6 @@
+import { defineCollection } from "astro:content";
+import { docsSchema } from "@astrojs/starlight/schema";
+
+export const collections = {
+  docs: defineCollection({ schema: docsSchema() }),
+};

docs/eagle0pedia/src/content/docs/commands/index.md

@@ -0,0 +1,666 @@
+---
+title: Eagle Commands
+description: Strategic command reference for Eagle command panels.
+---
+
+Eagle commands are the strategic actions a faction can take from a province command panel. The panel shows the actions that are possible for the current province and situation.
+
+Most commands belong to the province currently acting this turn. Some are reaction commands, such as resolving diplomacy offers, handling captured heroes, or choosing a battle aftermath decision.
+
+## Why commands appear and disappear
+
+The command panel changes as the game changes. If an action is not currently possible, it is usually absent instead of appearing as a disabled button.
+
+Availability can change when:
+
+- another command spends gold, food, vigor, or the province's turn;
+- a hero, battalion, prisoner, event, or incoming army moves or changes state;
+- the game advances to another phase;
+- a profession or minimum stat is required; or
+- a target is no longer valid.
+
+If a command you expected is missing, check its **Available when** entry. The most common reasons are insufficient gold, food, or vigor; no valid target; the wrong hero profession; the hero being elsewhere; or the province having already spent its turn.
+
+An **eligible hero** is simply one of the heroes you can currently choose to perform that action. Eligibility can depend on location, vigor, profession, leadership, and the command's own restrictions.
+
+## Reading a command entry
+
+- **Hero requirements** identifies profession or hero restrictions. “None” means no particular profession, not that the command never needs an acting hero.
+- **Vigor cost** is paid by the selected acting hero when the command resolves as described.
+- **Available when** summarizes the state that makes the command appear.
+- **Effect** describes what the action does.
+- **Selection** lists what you must choose before confirming it.
+
+## Turns, reactions, and command states
+
+Most commands under **Normal Command Phase Commands** spend the acting province's turn. After using one, you normally cannot choose another ordinary action for that province this round. Entries explicitly identify exceptions such as Issue Orders.
+
+Diplomacy responses, attack and defense decisions, riots, and battle aftermath are prompted by events in their own phases. Resolving one of these decisions does not replace or grant another ordinary province turn.
+
+**Travel** enters a temporary command state. Traveling commands then become available, and the player may use multiple traveling commands in the same round. **Return** leaves that state and returns to the normal province command flow. Individual traveling actions can still spend resources or alter which later choices remain available.
+
+Before confirming any command, check the selected hero, destination, units, gold, and food. Treat confirmation as issuing the order rather than previewing it.
+
+<span class="command-reference-marker" aria-hidden="true"></span>
+
+<!--
+Source map for numeric command details:
+- Alms: src/main/resources/net/eagle0/eagle/settings.tsv fields almsSupportIncreasePerFood=0.01, almsPaladinSupportMultiplier=4, maxAlmsFood=1000; applied in src/main/scala/net/eagle0/eagle/library/actions/impl/command/AlmsCommand.scala and src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableAlmsCommandFactory.scala.
+- Feast: settings fields loyaltyGainFromFeast=10, vigorGainFromFeast=10, feastGoldCostPerHero=20; applied in src/main/scala/net/eagle0/eagle/library/actions/impl/command/FeastCommand.scala and src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableFeastCommandFactory.scala.
+- Hero Gift: settings fields loyaltyIncreasePerGold=0.25 and maxGiftGold=100; applied in src/main/scala/net/eagle0/eagle/library/actions/impl/command/HeroGiftCommand.scala and src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableHeroGiftCommandFactory.scala.
+- Rest: settings field restVigorGain=15; applied in src/main/scala/net/eagle0/eagle/library/actions/impl/command/RestCommand.scala.
+- Vigor costs: src/main/resources/net/eagle0/eagle/settings.tsv fields actionVigorCost=15, reconVigorCost=30, apprehendOutlawVigorCost=30, controlWeatherVigorDelta=-40, startEpidemicVigorDelta=-30, vigorGainFromFeast=10, restVigorGain=15.
+- Divine: divinable heroes are unaffiliated heroes with RecruitmentInfo.NotDivined; see src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableDivineCommandsFactory.scala and src/main/scala/net/eagle0/eagle/library/actions/impl/command/DivineCommand.scala.
+- Issue Orders: order availability comes from src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableIssueOrdersCommandFactory.scala; vassal order behavior comes from src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformVassalCommandsPhaseAction.scala, src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers/CommandChoiceHelpers.scala, and src/main/scala/net/eagle0/eagle/library/util/command_choice_helpers/ExpandCommandSelector.scala.
+- Send Supplies: shipment scheduling comes from src/main/scala/net/eagle0/eagle/library/actions/impl/command/SendSuppliesCommand.scala; arrival comes from src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformProvinceMoveResolutionAction.scala and src/main/scala/net/eagle0/eagle/library/actions/impl/action/ShipmentArrivedAction.scala; timing/loss settings are src/main/resources/net/eagle0/eagle/settings.tsv fields turnsToResolveShipment=1 and shipSuppliesLoss=0.1.
+- Battle Aftermath Decision: availability comes from src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableBattleAftermathDecisionCommandFactory.scala; selection comes from src/main/scala/net/eagle0/eagle/library/actions/impl/command/BattleAftermathDecisionCommand.scala; finalization comes from src/main/scala/net/eagle0/eagle/library/actions/impl/action/FinalizeAftermathAction.scala.
+- Manage Prisoners: availability comes from src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableManagePrisonersCommandFactory.scala; option effects come from src/main/scala/net/eagle0/eagle/library/actions/impl/command/ManagePrisonersCommand.scala; prisoner move/return timing comes from src/main/scala/net/eagle0/eagle/library/actions/impl/action/EndPlayerCommandsPhaseAction.scala; settings include prisonerEscapeChance=0.01.
+- Handle Captured Hero: availability comes from src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableHandleCapturedHeroCommandFactory.scala; option effects come from src/main/scala/net/eagle0/eagle/library/actions/impl/command/HandleCapturedHeroesCommand.scala; deferred aftermath effects come from src/main/scala/net/eagle0/eagle/library/actions/impl/action/EndBattleAftermathPhaseAction.scala; settings include startingLoyalty=60 and truceMonthsFromReturningLeader=12.
+-->
+
+## Normal Command Phase Commands
+
+Most command phase actions spend the acting province's turn.
+
+### Alms
+
+<b>Hero requirements:</b> None. [Paladins](/heroes/#paladin) get a bonus.
+
+<b>Vigor cost:</b> 15.
+
+<b>Available when:</b> the acting province has food to give and an eligible hero with enough vigor.
+
+<b>Effect:</b> Give up to 1000 food from the acting province as charity. The province gains 1 [support](/provinces/#support) per 100 food, capped by the province's maximum 100 support. Paladins multiply the support gain by 4, so a Paladin gives 4 support per 100 food. The acting hero spends vigor and gains charisma XP.
+
+<b>Selection:</b> choose an amount of food and the acting hero.
+
+### Apprehend Outlaw
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> 30.
+
+<b>Available when:</b> an [outlaw hero](/factions/#free-heroes) is present in the acting province and an eligible hero has enough vigor.
+
+<b>Effect:</b> Attempt to capture the outlaw. On success, the outlaw is removed from the province's unaffiliated heroes and re-added as a prisoner with a bias against the imprisoning faction. The acting hero spends vigor, and the game creates a deferred notification/story request.
+
+<b>Selection:</b> choose the outlaw, an optional battalion, and the acting hero.
+
+### Control Weather
+
+<b>Hero requirements:</b> [Mage](/heroes/#mage).
+
+<b>Vigor cost:</b> 40.
+
+<b>Available when:</b> a Mage has enough vigor and the acting province or an adjacent province has a valid weather change.
+
+<b>Effect:</b> Change weather in a target province. Available options can start or end blizzards and droughts. The target province receives a deferred weather change, and the acting hero records a weather backstory event, spends or gains the configured vigor delta, and gains wisdom XP.
+
+<b>Selection:</b> choose the weather control type, target province, and acting hero.
+
+### Diplomacy
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> 15 from the messenger hero.
+
+<b>Available when:</b> a diplomatic option is valid against another faction and an eligible messenger hero can be sent.
+
+<b>Effect:</b> Send a hero to another faction with a diplomatic proposal. The target faction receives the offer at the end of the current round, after any battles this round have taken place. Truce, invitation, alliance, break-alliance, and ransom options create [incoming diplomacy offers](/factions/#incoming-diplomacy-offers) for the target faction and story-generation requests. Most diplomacy options spend gold, remove the messenger hero from the acting province, and cost the messenger vigor.
+
+<b>Selection:</b> choose the diplomacy option, target faction, and sent hero.
+
+### Exile Vassal
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> this province has at least one [vassal](/heroes/#vassals).
+
+<b>Effect:</b> Remove the selected vassal from your faction.
+
+<b>Selection:</b> choose the hero to exile.
+
+### Feast
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None. This restores up to 10 vigor for each ruling-faction hero in the province.
+
+<b>Available when:</b> the acting province can pay the feast cost: 20 gold per ruling-faction hero in the province, multiplied by the province [price index](/provinces/#price-index).
+
+<b>Effect:</b> Hold a feast in the acting province. Every ruling-faction hero in the province gains up to 10 loyalty, capped at 100, and up to 10 vigor, capped by constitution. Faction leaders do not gain loyalty, but can still gain vigor. The province spends gold, the price index may change, and feast-spending quest counters can advance.
+
+<b>Selection:</b> no additional choices.
+
+### Hero Gift
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> the province has a non-leader hero with less than 100 LOY and gold available to give.
+
+<b>Effect:</b> Send up to 100 gold as a gift to the selected hero. Loyalty gain depends on the gold amount, the recipient province's price index, and the hero's current loyalty: the base gain is 0.25 loyalty per gold, divided by price index, capped by the remaining room to 100 LOY.
+
+<b>Selection:</b> choose the recipient hero and amount.
+
+### Improve
+
+<b>Hero requirements:</b> None. [Engineers](/heroes/#engineer) get a bonus.
+
+<b>Vigor cost:</b> 15.
+
+<b>Available when:</b> a hero has enough vigor and the province has an available improvement or devastation repair option.
+
+<b>Effect:</b> Improve a province using one of the available improvement types. [Economy, agriculture, and infrastructure](/provinces/#development-stats) rise toward 100; [devastation](/provinces/#devastation) repair reduces all three devastation tracks. The acting hero spends vigor and gains strength/agility XP, and the improvement can optionally be locked as the province's preferred type.
+
+<b>Selection:</b> choose the improvement type, acting hero, and whether to lock the type.
+
+### Issue Orders
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None. This does not take your turn.
+
+<b>Available when:</b> a faction leader is acting and your faction controls more than one province. This command does not take your turn.
+
+<b>Effect:</b> Set [standing orders](/provinces/#province-orders) for your provinces. Orders guide vassal-ruled provinces during the [Vassal Commands phase](/concepts/eagle-round-flow/#vassal-commands); provinces led directly by faction leaders are still commanded directly. Vassals may still handle urgent problems first, such as defense, riots, severe fatigue, low support, beast suppression, loyalty management, or other immediately available crisis commands.
+
+<b>Selection:</b> submit the new province orders and the new focus province, or clear the focus province.
+
+#### Order Meanings
+
+##### Entrust
+
+Use the vassal's judgment. If the province borders an enemy, the vassal tends to act like **Mobilize**. Otherwise, the vassal tends to act like **Develop**.
+
+##### Develop
+
+Build up the province. The vassal may send away surplus gold and food toward your focus province, if one is set, or otherwise toward the nearest faction leader. Then it prefers **Improve** actions that raise economy, agriculture, infrastructure, or repair devastation. If nothing useful is available, the province rests.
+
+##### Mobilize
+
+Prepare for war. The vassal may ship excess gold and food toward your focus province, if one is set, or otherwise toward the nearest faction leader. Then it may organize troops, arm troops, improve infrastructure when it limits training, train battalions, and fall back to improvement or rest.
+
+##### Expand
+
+Look for growth or attack opportunities. The vassal first tries to march into neutral provinces, usually leaving enough heroes behind to keep the origin province held. If expansion is not practical, it may spread heroes among your existing provinces, attack enemies when appropriate, improve the province, or rest.
+
+### March
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> 15 from each marching hero.
+
+<b>Available when:</b> the acting province has movable heroes, battalions, gold, or food and at least one valid destination.
+
+<b>Effect:</b> Move heroes, battalions, gold, and food from one province to another. The selected units and supplies leave the origin province immediately, each marching hero spends vigor and gains wisdom XP, and the destination receives an [incoming army](/provinces/#incoming-armies) scheduled for the next round.
+
+If the destination is already ruled by your faction when the army arrives, the heroes, battalions, gold, and food enter the province during the next round's Province Move Resolution phase, before riots, vassal commands, and player commands.
+
+If the destination is neutral or hostile, the army does not simply appear in the province at Province Move Resolution. It is set up as a hostile army later in that same next round, after player commands. A neutral province can then be taken in the Uncontested Conquest phase; a defended province can lead into attack, defense, battle request, and battle resolution phases. Until one of those outcomes resolves, the marching heroes are still in the moving army rather than ruling the destination.
+
+<!-- Sources:
+- March scheduling: src/main/scala/net/eagle0/eagle/library/actions/impl/command/MarchCommand.scala
+- Friendly arrival timing: src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformProvinceMoveResolutionAction.scala
+- Hostile setup and neutral conquest timing:
+  src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformHostileArmySetupAction.scala
+  src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformUncontestedConquestAction.scala
+- Phase order: src/main/scala/net/eagle0/eagle/model/state/RoundPhase.scala
+-->
+
+<b>Selection:</b> choose origin, destination, gold, food, and marching units.
+
+### Organize Troops
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> the acting province has battalions to manage, troops to reorganize, or gold to raise new troops.
+
+<b>Effect:</b> Create, resize, merge, transfer, or dismiss battalions in the acting province. New troops cost gold and enter with no training or armament, while transferred troops preserve weighted training and armament. Empty battalions are destroyed, new battalions get generated names and initial backstory requests, and the province price index may change from the gold spend.
+
+<b>Selection:</b> submit changed battalions and new battalions, including troop movements and new troop counts.
+
+### Recon
+
+<b>Hero requirements:</b> [Ranger](/heroes/#ranger).
+
+<b>Vigor cost:</b> 30.
+
+<b>Available when:</b> a Ranger has enough vigor and there is a valid target province to scout.
+
+<b>Effect:</b> Send a hero to scout another province.
+
+<b>Selection:</b> choose the acting hero and target province.
+
+### Rest
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None. This restores up to 15 vigor for each ruling-faction hero in the province.
+
+<b>Available when:</b> the acting province can spend its turn resting.
+
+<b>Effect:</b> Have the acting province rest for the turn. Faction heroes in the province regain up to 15 vigor, capped by constitution, and rest-related quest counters can advance.
+
+<b>Selection:</b> no additional choices.
+
+### Send Supplies
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> 15.
+
+<b>Available when:</b> the acting province has supplies to send, an eligible hero, and a valid destination province.
+
+<b>Effect:</b> Send gold and food from the acting province to another province. The origin province loses the full selected amount immediately, and the destination receives an [incoming shipment](/provinces/#incoming-shipments) scheduled for the next round.
+
+Shipments arrive during the next round's Province Move Resolution phase, before riots, hero departures, vassal commands, player commands, battles, and food consumption. That means food shipped this way is available to feed the destination province later in the same round it arrives. When the shipment arrives, 10% is lost in transit and the destination receives the remaining gold and food, rounded down.
+
+<b>Selection:</b> choose gold, food, acting hero, and destination province.
+
+### Start Epidemic
+
+<b>Hero requirements:</b> [Necromancer](/heroes/#necromancer).
+
+<b>Vigor cost:</b> 30.
+
+<b>Available when:</b> a Necromancer has enough vigor and the acting province or an adjacent province can receive an epidemic.
+
+<b>Effect:</b> Start an epidemic in the target province.
+
+<b>Selection:</b> choose the target province and acting hero.
+
+### Suppress Beasts
+
+<b>Hero requirements:</b> None. Heroes with any profession get a power bonus.
+
+<b>Vigor cost:</b> 15 on success, plus any vigor lost to casualties. If the hero is killed, the command fails.
+
+<b>Available when:</b> the acting province has a [beast event](/provinces/#province-events) and an eligible hero.
+
+<b>Effect:</b> Send a hero, optionally with a battalion, to suppress beasts in the acting province. The fight rolls beast power, applies casualties to the battalion and/or hero, removes the beast event on success or failure, and creates a story notification. Success can award gold, food, support, hero XP, and battalion backstory; failure can kill the hero and destroy the battalion.
+
+<b>Selection:</b> choose the hero and optional battalion.
+
+### Swear Kinship
+
+<b>Hero requirements:</b> The target hero must have at least 95 loyalty.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> the faction head is in the province, your faction has fewer than 5 faction leaders, and another hero in the province has at least 95 loyalty.
+
+<b>Effect:</b> Choose a hero for a kinship bond. A hero who swears kinship becomes a [faction leader](/heroes/#faction-leaders).
+
+<b>Selection:</b> choose the hero to swear kinship with.
+
+### Train
+
+<b>Hero requirements:</b> None. [Champions](/heroes/#champion) get a bonus.
+
+<b>Vigor cost:</b> 15.
+
+<b>Available when:</b> a hero has enough vigor and the province has at least one battalion with less than 100 TRN.
+
+<b>Effect:</b> Raise the TRN of all trainable battalions in the province. The more troops are present, the lower the amount raised. The acting hero spends vigor and gains charisma, strength, and agility XP.
+
+<b>Selection:</b> choose the acting hero.
+
+### Travel
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> 15.
+
+<b>Available when:</b> the acting province can enter the traveling command state.
+
+<b>Effect:</b> Unlock the traveling commands below. Once you are traveling, you can use as many traveling commands as you want in the same round before using Return to come back to camp.
+
+<b>Selection:</b> no additional choices.
+
+## Traveling Commands
+
+You must use Travel before these commands appear. Once you are traveling, you can use as many traveling commands as you want in one round before using Return to come back to camp.
+
+### Arm Troops
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling, the province has gold, and at least one battalion can raise ARM without exceeding effective infrastructure.
+
+<b>Effect:</b> Spend gold to raise armament on existing battalions. New armament must be higher than the battalion's current armament and cannot exceed the province's effective infrastructure. The province spends gold, the price index may change, and each armed battalion records a backstory event.
+
+<b>Selection:</b> choose the battalions to arm and how much armament each receives.
+
+### Decline Quest
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling and an [unaffiliated hero](/heroes/#unaffiliated-heroes) quest is available in the province.
+
+<b>Effect:</b> Decline one of the unaffiliated hero quests available in the acting province.
+
+<b>Selection:</b> choose the hero whose quest should be declined.
+
+### Divine
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling, the province has gold, and there are free heroes who are not yet ready to join your faction but might be won over.
+
+<b>Effect:</b> Spend gold to divine one or more [free heroes](/factions/#free-heroes). For each divined hero, you receive details about what could impress them enough to become recruitable. Fulfill that ask, and the hero can later appear under Recruit Heroes. Cost scales by the province price index, the province spends gold, and the price index may change.
+
+<b>Selection:</b> choose the heroes to divine.
+
+### Manage Prisoners
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling and the province has prisoner heroes with available management options.
+
+<b>Effect:</b> Choose what happens to ordinary prisoners in the province. These are heroes who are already in the prisoner state, not newly captured heroes still waiting for a battle aftermath decision.
+
+<b>Selection:</b> choose the prisoner and management option.
+
+#### Options
+
+##### Execute
+
+<b>Effect:</b> Kill the prisoner and remove them from the game.
+
+##### Exile
+
+<b>Available when:</b> the prisoner is not a faction leader.
+
+<b>Effect:</b> Turn the prisoner into an outlaw in the same province.
+
+##### Release
+
+<b>Available when:</b> the prisoner is not a faction leader.
+
+<b>Effect:</b> Release the prisoner as a traveler in the same province. Released prisoners are no longer in your custody, but they do not automatically join another faction.
+
+##### Move
+
+<b>Available when:</b> you control an adjacent province.
+
+<b>Effect:</b> Send the prisoner to one adjacent province ruled by your faction. The prisoner leaves the origin province now and arrives at the destination at the end of the Player Commands phase. There is a 1% chance the prisoner escapes during the move; if that happens, they become an outlaw in the destination province instead of remaining a prisoner.
+
+##### Return
+
+<b>Available when:</b> the prisoner is a faction leader and their faction still controls at least one province.
+
+<b>Effect:</b> Return the prisoner to their faction. They leave your custody now and rejoin their faction at the end of the Player Commands phase as a ruling hero in one of that faction's provinces.
+
+Ordinary prisoners cannot be returned this way. Faction leader prisoners cannot be released or exiled, but they can be executed, moved within your territory, or returned if their faction still exists.
+
+### Recruit Heroes
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling and unaffiliated heroes in the province are willing to join.
+
+<b>Effect:</b> Recruit available unaffiliated heroes in the acting province. Recruited heroes join the faction at starting loyalty, move from the province's unaffiliated hero list into its ruling faction heroes, and receive a recruitment backstory event.
+
+<b>Selection:</b> choose the heroes to recruit.
+
+### Return
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling.
+
+<b>Effect:</b> Return from the traveling command state to the normal strategic flow.
+
+<b>Selection:</b> no additional choices.
+
+### Trade
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> you are traveling and the province has enough gold or food for at least one trade.
+
+<b>Effect:</b> Buy or sell food using the acting province's gold and food stores. Food buy and sell prices are based on the province price index. Buying spends gold and adds food; selling removes food and adds gold. The price index may change after the trade.
+
+<b>Selection:</b> choose buy or sell and the amount of food.
+
+## Special and Conditional Commands
+
+These commands appear only when the game is resolving a special situation, response, or pending decision.
+
+### Attack Decision
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> an attack decision is pending.
+
+<b>Effect:</b> Choose how to respond to a pending attack opportunity or battle decision. The command shows involved armies, acting units, and the available attack decision types. See [Attack and Defense Decisions](/concepts/eagle-to-shardok/#attack-and-defense-decisions) for how this fits into battle creation.
+
+<b>Selection:</b> choose one available attack decision.
+
+### Defend
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> a province is under attack and can commit defenders.
+
+<b>Effect:</b> Respond to an incoming attack by committing a defending army. The selected defenders become the province's defending army. If flee provinces are available, one must be selected as the army's fallback destination. See [Attack and Defense Decisions](/concepts/eagle-to-shardok/#attack-and-defense-decisions) for what happens next.
+
+<b>Selection:</b> choose defending units and, when available, an optional flee province.
+
+### Handle Captured Hero
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> a newly captured hero needs a battle aftermath decision.
+
+<b>Effect:</b> Decide what happens to a hero captured during [battle aftermath](/concepts/eagle-to-shardok/#aftermath) or conquest. Captured heroes are not yet ordinary prisoners. If you imprison one, they become a normal prisoner and can later be handled with Manage Prisoners.
+
+<b>Selection:</b> choose the captured hero and the handling option.
+
+#### Options
+
+##### Recruit
+
+<b>Available when:</b> the captured hero is not a faction leader, has not already refused recruitment, and is not someone who will never join your faction.
+
+<b>Effect:</b> Try to persuade the captured hero to join you immediately. The chance depends on your faction head, your faction's prestige, and the captured hero. On success, the hero joins your faction in the captured province with 60 loyalty. On failure, the hero refuses; you cannot try to recruit that captured hero again from this aftermath decision and must choose another option.
+
+##### Imprison
+
+<b>Effect:</b> Keep the hero as a prisoner in the captured province. This converts them into an ordinary prisoner when the aftermath resolves.
+
+##### Exile
+
+<b>Available when:</b> the captured hero is not a faction leader whose faction still controls a province.
+
+<b>Effect:</b> Cast the hero out as an outlaw in the captured province when the aftermath resolves.
+
+##### Execute
+
+<b>Effect:</b> Kill the captured hero and remove them from the game when the aftermath resolves.
+
+##### Return
+
+<b>Available when:</b> the captured hero is a faction leader and their faction still controls at least one province.
+
+<b>Effect:</b> Return the captured faction leader to the closest province ruled by their old faction when the aftermath resolves. Returning a captured leader creates a 12-month truce between your faction and theirs.
+
+### Handle Riot
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> Depends on the option. Crack Down can cost vigor; Give and Do Nothing do not.
+
+<b>Available when:</b> a province has a riot.
+
+<b>Effect:</b> Respond to a [riot](/provinces/#province-events) in the acting province. The client presents this as one command with multiple response options. The [province leader](/provinces/#ruling-faction-and-ruling-hero)'s Charisma matters, even if a different hero is selected to crack down: leader Charisma improves gift success and makes forceful crackdowns face smaller riots.
+
+If you fail to stop the riot, or if the riot is still unresolved when the riot phase ends, the riot happens. The province loses 25 support, gains 25 economy devastation, gains 25 infrastructure devastation, and the riot event is removed.
+
+<!-- Sources:
+- Riot options: src/main/scala/net/eagle0/eagle/library/actions/impl/command/HandleRiotGiveCommand.scala
+  src/main/scala/net/eagle0/eagle/library/actions/impl/command/HandleRiotCrackDownCommand.scala
+  src/main/scala/net/eagle0/eagle/library/actions/impl/command/HandleRiotDoNothingCommand.scala
+- Riot consequences: src/main/scala/net/eagle0/eagle/library/actions/impl/command/HandleRiotUtils.scala
+- Riot settings: src/main/scala/net/eagle0/eagle/library/settings/BUILD.bazel
+-->
+
+#### Options
+
+##### Crack Down
+
+<b>Vigor cost:</b> 15 on success, plus any vigor lost to casualties. If the hero is killed, the command fails.
+
+<b>Effect:</b> Try to suppress the riot by force using a hero and optionally a battalion. The riot size is random from 100 to 1500, but the province leader's Charisma, not the selected acting hero's Charisma, reduces the roll before the size is calculated. Higher leader Charisma therefore makes the riot smaller and easier to defeat.
+
+Casualties are based on riot size against the power of the acting hero and any attached battalion. If a battalion is used, casualties hit the battalion first; the battalion can be destroyed, and excess casualties can injure or kill the acting hero. If no battalion is used, casualties hit the acting hero directly.
+
+Crack Down succeeds if the acting hero survives. On success, the riot event is removed and the acting hero spends 15 vigor, gains Strength and Agility XP, and may take additional vigor damage from casualties. If a battalion helped and survived, its size is reduced by its casualties. A successful crackdown does not directly reduce support, add devastation, or change loyalty; the cost is the violence itself.
+
+Crack Down fails if the acting hero is killed. A failed crackdown does not stop the riot; the riot will still occur and apply the normal riot damage.
+
+<b>Selection:</b> choose the acting hero and an optional battalion.
+
+##### Do Nothing
+
+<b>Vigor cost:</b> None.
+
+<b>Effect:</b> Let the riot proceed without intervention. The riot will occur, causing the normal riot damage: -25 support, +25 economy devastation, and +25 infrastructure devastation.
+
+<b>Selection:</b> no additional choices.
+
+##### Give
+
+<b>Vigor cost:</b> None.
+
+<b>Effect:</b> Offer either food or gold to address the riot. You cannot combine food and gold in the same response. The maximum useful gift is 1000 food or 500 gold, and the selected amount is spent whether the attempt succeeds or fails.
+
+Gift success is probabilistic. The chance is based on the province leader's Charisma plus the fraction of the maximum gift you gave: larger gifts help, and more leader Charisma helps. A partial gift can fail. On success, the riot event is removed. On failure, the gift is still spent and the riot will still occur.
+
+<b>Selection:</b> choose a food amount or a gold amount.
+
+### Please Recruit Me
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> unaffiliated heroes ask to join.
+
+<b>Effect:</b> Respond to unaffiliated heroes who are asking to join a province.
+
+<b>Selection:</b> choose the province, hero, and whether to accept.
+
+### Resolve Alliance Offer
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> another faction offers an alliance.
+
+<b>Effect:</b> Accept or reject an [incoming alliance offer](/factions/#incoming-diplomacy-offers).
+
+<b>Selection:</b> choose the originating faction and the resolution.
+
+### Resolve Break Alliance
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> another faction tries to break an alliance.
+
+<b>Effect:</b> Respond to a faction attempting to break an alliance.
+
+<b>Selection:</b> choose the originating faction and the resolution.
+
+### Resolve Invitation
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> another faction sends an invitation.
+
+<b>Effect:</b> Accept or reject an invitation from another faction.
+
+<b>Selection:</b> choose the originating faction and the resolution.
+
+### Resolve Ransom Offer
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> another faction makes a ransom offer.
+
+<b>Effect:</b> Accept or reject an incoming ransom offer.
+
+<b>Selection:</b> choose the offering faction, the ransom offer, and the resolution.
+
+### Resolve Truce Offer
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> another faction offers a truce.
+
+<b>Effect:</b> Accept or reject an incoming truce offer.
+
+<b>Selection:</b> choose the originating faction and the resolution.
+
+### Resolve Tribute
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> another faction demands tribute.
+
+<b>Effect:</b> Decide whether to pay demanded tribute. The command shows the demanding factions, requested tribute, their rough strength, and the acting province's available food and gold.
+
+<b>Selection:</b> choose the demanding faction and whether tribute is paid.
+
+### Battle Aftermath Decision
+
+<b>Hero requirements:</b> None.
+
+<b>Vigor cost:</b> None.
+
+<b>Available when:</b> multiple allied attacking factions won the same province and Eagle needs to decide which claimant keeps it.
+
+<b>Effect:</b> Decide what your surviving claimant army does during [battle aftermath](/concepts/eagle-to-shardok/#aftermath) after a shared victory. If no ally has claimed the province yet, you may choose **Keep Province** and become the conqueror. If an ally has already claimed it, you must withdraw.
+
+Keeping the province finalizes conquest: your surviving non-fled heroes become the new ruling heroes, surviving battalions become the province battalions, support is reset to 0, province orders reset to **Entrust**, and non-fled defenders or former ruling heroes can become prisoners.
+
+Withdrawing sends your surviving units to an adjacent province as a moving army. You may take up to the gold and food your claimant army brought into the battle. The withdrawal army arrives next round and does not use the normal Send Supplies transit loss.
+
+<b>Selection:</b> choose whether to keep the province or withdraw. If withdrawing, choose destination province and supplies to take.

docs/eagle0pedia/src/content/docs/concepts/eagle-round-flow/index.md

@@ -0,0 +1,137 @@
+---
+title: Eagle Round Flow
+description: How Eagle strategic rounds advance, including simultaneous player action.
+---
+
+<!--
+Source map:
+- Phase enum: src/main/protobuf/net/eagle0/eagle/common/round_phase.proto.
+- Phase advancement: src/main/scala/net/eagle0/eagle/library/RoundPhaseAdvancer.scala.
+- Command availability by phase: src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableCommandsFactory.scala.
+- Result visibility/filtering: src/main/scala/net/eagle0/eagle/library/ActionResultFilter.scala and src/main/scala/net/eagle0/eagle/library/util/view_filters/.
+-->
+
+Eagle is a simultaneous-turn strategy game. During a phase, every faction gets the chance to act in parallel. The game does not fully resolve the phase just because one player chooses a command; it waits until every required player choice has been made, then advances the phase and reveals the results each faction is allowed to know.
+
+That means two things matter:
+
+- Your orders are not a private single-player timeline. Other factions may be choosing their own commands at the same time.
+- You do not automatically see every action in the world. You see your faction's results, your allies' visible results, and information your faction has earned through scouting, battle revelations, diplomacy, or province control.
+
+## Round Shape
+
+Most rounds follow this broad rhythm:
+
+1. Upkeep and automatic world changes happen.
+2. Vassals and players issue strategic commands.
+3. Marching armies arrive, attacks are decided, and battles are requested.
+4. Shardok battles resolve outside the strategic map.
+5. Eagle applies battle results, aftermath choices, diplomacy, recon, and end-of-round changes.
+
+Some phases are player-facing. Others are bookkeeping phases that advance automatically unless a special decision is needed.
+
+## Automatic Upkeep
+
+These phases usually advance without direct player input:
+
+### New Round
+
+The game starts a new strategic round. Provinces, heroes, factions, and long-running state are updated for the new date.
+
+### Prisoner Exchange
+
+The game resolves automatic prisoner exchange state.
+
+### Province Events
+
+Province events such as local problems or opportunities are processed.
+
+### Forced Turn Back
+
+Armies that must turn back do so before normal movement resolution.
+
+### Province Move Resolution
+
+Moving armies arrive at their destinations, supplies move, and incoming hostile groups are created where armies meet resistance.
+
+### Hero Departures
+
+Heroes who are ready to leave unaffiliated states or temporary situations may depart.
+
+### Unaffiliated Hero Actions
+
+Unaffiliated heroes may move, appear, escape, or otherwise act without belonging to a faction.
+
+### Hostile Army Setup
+
+The game prepares hostile army groups before conquest or battle decisions.
+
+### Uncontested Conquest
+
+If an attacker reaches a province with no defending force, the conquest can resolve without a Shardok battle.
+
+### Truce Turn Back
+
+Armies affected by truces may turn back instead of fighting.
+
+### Battle Request
+
+Eagle creates Shardok battles for provinces where attackers and defenders must fight.
+
+### Food Consumption
+
+Armies consume food before or around battle handling.
+
+### Battle Resolution
+
+Eagle waits for outstanding Shardok battles to report results. If there are none, the phase advances automatically.
+
+### Recon Resolution
+
+Recon results are applied after the relevant strategic activity has completed.
+
+## Player Decision Phases
+
+These phases can pause until required players have submitted decisions.
+
+### Handle Riot
+
+If your province has a riot, you may need to decide how to respond before the round can continue.
+
+### Please Recruit Me
+
+Some unaffiliated heroes may ask to join a faction. The phase waits while available recruitment decisions remain.
+
+### Vassal Commands
+
+Vassals choose province actions for provinces they rule. Vassals lead provinces and make their own choices, so these commands can happen before the direct player command phase.
+
+### Player Commands
+
+This is the main strategic command phase. Each player acts for provinces and heroes they can command directly. Every player is acting within the same phase, so your command is submitted into a shared strategic moment rather than immediately revealing a global timeline.
+
+See [Eagle commands](/commands/) for the command reference.
+
+### Attack Decision
+
+When an army reaches a hostile province, the attacking side may need to choose whether to attack.
+
+### Defense Decision
+
+The defending side may need to decide how to respond to an incoming attack.
+
+### Battle Aftermath
+
+After Shardok results return to Eagle, winners may need to decide what happens to conquered provinces, captured heroes, or multiple allied claimants.
+
+### Diplomacy Resolution
+
+Diplomatic offers are resolved after players choose how to answer them. Offers can be accepted, rejected, invalidated, or lead to consequences such as imprisonment.
+
+## Simultaneous Information
+
+The important habit is to think in phases, not in a fully visible turn order.
+
+If two factions both issue orders during Player Commands, those orders belong to the same command phase. When the phase ends, each faction receives the filtered results it is allowed to observe. Your own actions are visible to you. Allied and nearby events may be visible depending on game state. Enemy actions may be hidden until scouts, battles, diplomacy, or later consequences reveal them.
+
+This is why Eagle often feels less like "I move, then you move" and more like issuing orders into a living world, then discovering what happened.

docs/eagle0pedia/src/content/docs/concepts/eagle-to-shardok/index.md

@@ -0,0 +1,133 @@
+---
+title: From Eagle to Shardok
+description: How strategic Eagle armies become tactical Shardok battles.
+---
+
+<!--
+Source map:
+- Movement resolution: src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformProvinceMoveResolutionAction.scala.
+- Battle setup phase: src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformHostileArmySetupAction.scala.
+- Uncontested conquest: src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformUncontestedConquestAction.scala.
+- Battle request creation: src/main/scala/net/eagle0/eagle/library/actions/impl/action/RequestBattlesAction.scala.
+- Tactical battle resolution back into Eagle: src/main/scala/net/eagle0/eagle/library/actions/impl/action/ResolveBattleAction.scala.
+- Province held/conquered outcomes: src/main/scala/net/eagle0/eagle/library/actions/impl/action/ProvinceHeldAction.scala and src/main/scala/net/eagle0/eagle/library/actions/impl/action/ProvinceConqueredAction.scala.
+- Multi-winner aftermath: src/main/scala/net/eagle0/eagle/library/actions/impl/action/MultiVictorBattleSetupAction.scala, src/main/scala/net/eagle0/eagle/library/actions/impl/command/BattleAftermathDecisionCommand.scala, and src/main/scala/net/eagle0/eagle/library/actions/impl/action/FinalizeAftermathAction.scala.
+- Battle aftermath decisions: src/main/scala/net/eagle0/eagle/library/actions/impl/action/FinalizeAftermathAction.scala and AutoResolveBattleAftermathAction.scala.
+-->
+
+Eagle is the strategic layer. Shardok is the tactical layer. The two connect when armies meet in a province and Eagle needs a battlefield result instead of a simple strategic update.
+
+## Strategic Movement
+
+In Eagle, armies move through the March command. A moving army has an origin province, destination province, arrival round, heroes, battalions, and supplies.
+
+Because Eagle is simultaneous, multiple factions can send armies during the same strategic phase. Those armies arrive later during movement resolution, after every relevant player has had the chance to submit orders for the phase.
+
+## Arrival
+
+When an army reaches its destination, the first question is whether it is friendly to the province's current ruler.
+
+Friendly armies arrive during Province Move Resolution. Their heroes, battalions, gold, and food enter the destination province at that point.
+
+Hostile armies do not immediately enter the province. They are converted into hostile army groups later in the round, after player commands, with one group per attacking faction. Each group keeps the armies, units, supplies, and approach direction from the province it marched from.
+
+After hostile setup, Eagle checks for cases that do not need a tactical battle:
+
+- If a hostile army reaches an unruled province, the largest army group takes it during Uncontested Conquest. Ties are broken by troop power and then a deterministic random tie-breaker.
+- If a single attacking army is attacking and there is no defending army, Eagle can resolve the attack directly as a conquest.
+- If diplomacy or truces apply, armies may turn back before fighting.
+
+Otherwise, the player may see attack or defense decision phases before a battle is requested.
+
+## Attack and Defense Decisions
+
+Hostile army groups first wait for an attack decision. An attacking faction can choose whether to press the attack when the game asks for that decision.
+
+If an attack proceeds against a ruled province, the defender may need to choose a defending army. The chosen defenders become the province's defending army. If a fallback province is available, the defender may also need to choose where the army should flee or retreat if Shardok produces that outcome.
+
+## Battle Creation
+
+When Eagle creates a Shardok battle, it sends:
+
+- The province's Shardok map.
+- The attacking armies.
+- The defending army, if any.
+- Each side's food for the battle.
+- Victory conditions for each player.
+- The battle type and battle id.
+
+Attackers in a normal province assault are trying to take the province. Defenders are trying to hold it or survive long enough for the attacker to fail.
+
+The battle food sent to Shardok is limited. Attackers bring up to one month of food consumption from their carried supplies. Defenders bring up to one month of food consumption from the province's food, and that food is removed from the province when the battle is created.
+
+## Tactical Resolution
+
+The battle then runs in Shardok. Players place units, move, attack, use profession commands, spend Action Points, and try to satisfy their victory conditions.
+
+Eagle waits in the battle resolution phase until outstanding Shardok battles report back.
+
+See [Shardok battles](/concepts/shardok-battles/) for the tactical overview and [Shardok victory conditions](/concepts/shardok-victory-conditions/) for battle-ending rules.
+
+## Returning To Eagle
+
+When Shardok reports a result, Eagle applies battle consequences before deciding who owns the province.
+
+The battle result can change:
+
+- Hero locations and status.
+- Battalion size and survival.
+- Captured heroes and prisoners.
+- Supplies brought by attacking armies.
+- Province devastation.
+- Quest progress and battle history.
+- Prestige. Winners gain battle prestige; losers lose battle prestige.
+
+Battles add devastation to the battle province. Surviving units may return, flee, become outlaws, be secured, or be captured depending on the tactical result.
+
+Attackers' remaining gold and food are added to the battle province as part of battle resolution. If the defender holds the province, those supplies become part of the defended province. If an attacker later conquers it, the province changes hands with the supplies already present.
+
+## If The Defender Wins
+
+If the defending side wins, the province remains with its current ruler.
+
+Attackers who did not flee, become outlaws, or get otherwise secured may be captured by the defending faction. Captured attacker battalions can be destroyed. The defender receives a Province Held result and any captured heroes become prisoners in the province.
+
+## If One Attacker Wins
+
+If exactly one attacking faction wins, that faction conquers the province directly.
+
+Conquest does several things at once:
+
+- Sets the conquering faction as the province's ruler.
+- Removes the old ruling-faction heroes from the province.
+- Adds the surviving non-fled conquering heroes as the new ruling-faction heroes.
+- Replaces the province battalions with the surviving conquering battalions.
+- Clears the defending army.
+- Sets province support to 0.
+- Resets province orders to **Entrust**.
+- Captures non-fled defenders and former ruling heroes as prisoners.
+- Clears the old owner's focus province if this province was their focus.
+- Clears recon on the province for all factions.
+
+Prisoners already held in the conquered province can also be freed. Prisoners from the conquering faction join the new rulers at freed-prisoner loyalty. Prisoners from allied factions are sent toward the closest allied province when possible; if no allied province exists, they can become outlaws.
+
+## If Multiple Allied Attackers Win
+
+If multiple attacking factions win together, Eagle cannot automatically know who should keep the province. It creates a pending conquest decision for the surviving attacking claimants.
+
+During Battle Aftermath, each claimant may be asked to choose:
+
+- **Keep Province:** claim the province. Only one claimant can keep it.
+- **Withdraw:** leave for an adjacent province, taking up to the gold and food that claimant brought into the battle.
+
+If an ally has already claimed the province, the remaining claimants must withdraw. If only one undecided claimant remains and nobody has claimed the province, Eagle auto-resolves that claimant as keeping it.
+
+When aftermath finalizes, the keeper conquers the province through the same conquest rules as a single attacking winner. Withdrawing claimants become incoming armies to their chosen adjacent provinces, arriving next round with the gold and food they chose to take. These aftermath withdrawals do not apply shipment transit loss.
+
+## Aftermath
+
+Some battle results need another Eagle decision before the round can continue. This happens mainly when multiple allied attackers win the same province or when captured heroes create follow-up handling decisions.
+
+Battle Aftermath happens after tactical results return but before the strategic round fully moves on. It is not a second Shardok battle; it is Eagle deciding ownership, withdrawals, supplies, and captured-hero consequences from the battle that already ended.
+
+Captured heroes can create separate follow-up decisions after this. Those decisions determine what the capturing faction does with the hero now that the battle result has placed them in custody.

docs/eagle0pedia/src/content/docs/concepts/index.md

@@ -0,0 +1,16 @@
+---
+title: Game Concepts
+description: Player-facing explanations of Eagle and Shardok systems.
+---
+
+These pages explain how Eagle0's major systems fit together. Use them when you want the big picture behind the command reference.
+
+## Eagle
+
+- [Eagle round flow](eagle-round-flow/) explains how a strategic round advances, why actions are simultaneous, and when players see results.
+- [From Eagle to Shardok](eagle-to-shardok/) explains how strategic movement turns into tactical battles and how battle results return to Eagle.
+
+## Shardok
+
+- [Shardok battles](shardok-battles/) explains tactical setup, turns, units, morale, vigor, terrain, and battle aftermath.
+- [Shardok victory conditions](shardok-victory-conditions/) explains how tactical battles end.

docs/eagle0pedia/src/content/docs/concepts/shardok-battles/index.md

@@ -0,0 +1,76 @@
+---
+title: Shardok Battles
+description: How tactical Shardok battles work at a high level.
+---
+
+<!--
+Source map:
+- Shardok battle model: src/main/scala/net/eagle0/eagle/model/state/shardok_battle/ShardokBattle.scala.
+- Battle creation from Eagle: src/main/scala/net/eagle0/eagle/library/actions/impl/action/RequestBattlesAction.scala.
+- Battle resolution back into Eagle: src/main/scala/net/eagle0/eagle/library/actions/impl/action/ResolveBattleAction.scala.
+- Tactical command availability: src/main/cpp/net/eagle0/shardok/library/AvailableCommandsFactory.cpp and command_factories/.
+- Victory checks: src/main/cpp/net/eagle0/shardok/library/actions/UpdateGameStatusAction.cpp.
+-->
+
+Shardok is the tactical battle layer. Eagle decides that a battle should happen, sends armies into Shardok, and later receives the result back.
+
+## Setup
+
+At the start of a battle, each side places its units onto valid setup hexes. Some battles include reserve or reinforcement units that enter later. Rangers on stealth-capable units may be able to deploy hidden.
+
+The map comes from the province where the battle occurs. A province's Shardok map defines terrain, castles, cities, rivers, bridges, water, and critical tiles.
+
+## Units
+
+A Shardok unit usually represents a hero attached to a battalion. The hero brings stats, vigor, profession abilities, and special command access. The battalion brings troop count, type, morale, training, armament, movement costs, damage profile, and battlefield limits.
+
+Some commands require a profession. Some also require the attached battalion type to support that role. For example, many spell commands require a unit that can cast, while Ranger stealth depends on a stealth-capable battalion.
+
+See [Heroes](/heroes/) for professions and [Shardok commands](/shardok-commands/) for command requirements.
+
+## Action Points
+
+Units act using Action Points. Moving through terrain spends AP based on the terrain and battalion type. Many major actions require a fixed AP minimum and then consume all remaining AP. The [Shardok command reference](/shardok-commands/) lists each command's AP cost and requirements.
+
+Unless a command says otherwise, a unit with morale must have at least 10 morale, and a unit with an attached hero must have at least 10 vigor.
+
+## Turns And Rounds
+
+Shardok advances tactically while units move, attack, cast, hide, scout, flee, and reinforce. When a side ends its turn, control passes according to the tactical state. At the end of a tactical round, Shardok checks end-of-round victory conditions such as holding critical tiles or surviving to the round limit.
+
+Some [victory conditions](/concepts/shardok-victory-conditions/), such as last player standing, can end the battle as soon as only one eligible side remains. Others wait until the end of a round so the opposing side has a chance to respond.
+
+## Terrain
+
+Terrain matters constantly:
+
+- It changes movement costs.
+- It affects damage and resistance.
+- It can block line of fire.
+- Castles and cities can become critical objectives.
+- Water, bridges, ice, fire, and mountains create command-specific constraints.
+
+Shardok is not just a troop-count comparison. Position, terrain, hidden information, and command timing matter.
+
+## Hidden Units
+
+Hidden units are not fully visible to enemies. Ranger abilities, scouting, terrain, movement, and proximity can reveal or preserve hidden information.
+
+A hidden unit can matter even at battle end. If a losing hidden unit has a capable hero and can flee, it may escape rather than being resolved like an ordinary visible loser.
+
+## Fleeing, Retreating, And Outlaws
+
+Units can leave a battle through flee or retreat mechanics when those commands are available. A hero may also become an outlaw through battle consequences. Eagle receives these statuses when Shardok reports the final battle result.
+
+## Battle Results
+
+When the battle ends, Shardok reports each player's surviving units, destroyed battalions, fled units, captured or secured units, and victory or loss condition.
+
+Eagle then applies the result:
+
+- Defenders who win hold the province.
+- A single attacking winner can conquer the province.
+- Multiple allied attacking winners may trigger battle aftermath decisions.
+- Captured heroes and prisoners can create follow-up decisions.
+- Battle damage can devastate province economy, agriculture, and infrastructure.
+- Winning battles can advance quests.

docs/eagle0pedia/src/content/docs/concepts/shardok-victory-conditions/index.md

@@ -0,0 +1,58 @@
+---
+title: Shardok Victory Conditions
+description: How tactical battles decide winners and losers.
+---
+
+<!--
+Source map:
+- Victory condition enum: src/main/protobuf/net/eagle0/common/victory_condition.proto.
+- Shardok victory checks: src/main/cpp/net/eagle0/shardok/library/actions/UpdateGameStatusAction.cpp.
+- Eagle assignment of battle victory conditions: src/main/scala/net/eagle0/eagle/library/actions/impl/action/RequestBattlesAction.scala.
+-->
+
+Shardok battles end when one of the battle's victory conditions is satisfied. Each player has a set of conditions that apply to them.
+
+In a normal Eagle province assault, attackers usually get **Hold Critical Tiles**, **Last Player Standing**, and **Last Alliance Standing**. The defender usually gets **Last Player Standing** and **Win After Max Rounds**.
+
+## Last Player Standing
+
+A player wins if they are the only surviving player and they have this victory condition.
+
+A player counts as surviving when they still have a visible normal unit with troops, or a visible normal unit with a living hero. Hidden units do not keep a player alive for this check, though some hidden losing units may be able to flee when the battle ends.
+
+## Last Alliance Standing
+
+Multiple players can win together if all surviving players are mutually allied and all have this victory condition.
+
+This is the tactical version of "the only forces left on the field are allies."
+
+## Win After Max Rounds
+
+A player wins if the battle lasts past the maximum number of Shardok rounds and they have this victory condition.
+
+In normal province assaults, this is usually the defender's clock. The attacker has to force a result before time runs out.
+
+## Hold Critical Tiles
+
+A player wins by controlling every critical tile on the map. Critical tiles are usually castles or other objective tiles.
+
+To count, each critical tile must be occupied by a unit belonging to the winning player, and the occupying unit must have an attached hero.
+
+Allied attackers can also win this way together if allied players collectively occupy all critical tiles, all occupying players have the condition, and the occupants are mutually allied.
+
+This condition is checked at the end of a tactical round, not immediately after every move, so the defender has a chance to retake objectives before the round closes.
+
+## Most Troops Standing
+
+This condition exists in the battle model, but normal Eagle province assaults do not currently assign it to attackers or defenders.
+
+If a battle type uses it, the winner is the player with the most troops standing when the battle reaches the relevant ending check.
+
+## What Happens After Victory
+
+Shardok reports each player as victorious or defeated, including which condition ended the battle. Eagle then turns that tactical result into strategic consequences:
+
+- A defending winner holds the province.
+- A single attacking winner conquers the province.
+- Multiple allied attacking winners may need to decide who keeps the province.
+- Captured heroes, destroyed battalions, fled units, outlaws, and secured prisoners are applied to the Eagle game state.

docs/eagle0pedia/src/content/docs/factions/index.md

@@ -0,0 +1,104 @@
+---
+title: Factions
+description: Reference for Eagle factions, leaders, prestige, diplomacy, and province focus.
+---
+
+Factions are the political actors in Eagle. They control provinces, command heroes and battalions, negotiate diplomacy, and compete for victory.
+
+<!-- Sources:
+- FactionView shape: src/main/protobuf/net/eagle0/eagle/views/faction_view.proto
+- Relationship levels: src/main/protobuf/net/eagle0/eagle/views/faction_relationship_view.proto
+- Trust storage: src/main/scala/net/eagle0/eagle/model/state/faction/FactionRelationship.scala
+- Swear Kinship availability: src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableSwearBrotherhoodCommandFactory.scala
+- Swear Kinship effect: src/main/scala/net/eagle0/eagle/library/actions/impl/command/SwearBrotherhoodCommand.scala
+- Leadership and destruction: src/main/scala/net/eagle0/eagle/library/actions/impl/action/CheckForFactionChangesAction.scala
+- Free hero states and recruitment info: src/main/scala/net/eagle0/eagle/model/state/unaffiliated_hero/UnaffiliatedHeroT.scala
+- Recruitment availability and odds: src/main/scala/net/eagle0/eagle/library/actions/availability/AvailableRecruitHeroesCommandFactory.scala
+  and src/main/scala/net/eagle0/eagle/library/util/recruitment_odds/RecruitmentOdds.scala
+- Prestige calculation: src/main/scala/net/eagle0/eagle/library/util/faction_utils/FactionUtils.scala
+- Truce, alliance, break-alliance, ransom, and imprisonment effects:
+  src/main/scala/net/eagle0/eagle/library/actions/impl/action/diplomacy_helpers/
+- Trust constants: src/main/scala/net/eagle0/eagle/library/settings/BUILD.bazel
+-->
+
+## Faction Head
+
+The faction head is the hero who represents the faction. In a normal game, this is usually your starting leader: the hero whose ideals, title, and story define what your faction is about.
+
+If the faction head is killed, another faction leader can take over as faction head. The faction may also be renamed around the new head if that hero has a faction name of their own.
+
+## Leaders
+
+[Faction leaders](/heroes/#faction-leaders) are the heroes you can command directly. They are different from [vassals](/heroes/#vassals), who rule provinces for you and make their own choices.
+
+You can gain more faction leaders with [**Swear Kinship**](/commands/#swear-kinship). The command is available when your faction head is in the province, your faction has fewer than 5 leaders, and another hero in the province has at least 95 loyalty. The new kinship hero becomes a faction leader.
+
+Faction leaders matter for succession. If the faction head dies, the next available faction leader becomes faction head. If no surviving leader is available to take over immediately, the strongest remaining vassal can rise to become a new faction leader and faction head.
+
+## Prestige
+
+Prestige is a high-level measure of faction stature. It is also the main faction-wide factor in whether free heroes are willing to join you.
+
+You gain prestige by:
+
+- Controlling more provinces whose support is high enough for taxes. Each supported province is worth 10 prestige.
+- Winning battles.
+- Defeating beasts.
+
+Prestige is not the only recruitment factor. The faction head's charisma, the free hero's power and ambition, the hero's current state, and any personal bias toward or against your faction also matter. But when you want more heroes to take you seriously, prestige is the big strategic lever.
+
+## Free Heroes
+
+Free heroes are heroes in a province who do not currently belong to your faction's command structure. The Free Hero panel tells you what state they are in and whether they can be recruited, divined, or managed another way.
+
+The common states are:
+
+- **Resident:** A hero living in the province. Residents may be willing to join outright. If they are not ready, they may be divinable: use [**Divine**](/commands/#divine) to learn what would impress them, then fulfill that ask to make them recruitable.
+- **Traveler:** A hero passing through. You do not know whether a traveler would join you until a faction leader travels there and talks to them. Travelers are harder to recruit than residents, but they might still join if your prestige and other recruitment factors are strong enough. They are also likely to leave the province soon, so they are more time-sensitive than residents.
+- **Prisoner:** A captured hero. Prisoners start with a strong bias against the faction holding them, but desperation can build over time. Eventually a prisoner may become willing to join, especially if your prestige is high enough.
+- **Outlaw:** A hostile free hero in the province. Outlaws are not ordinary recruits and will not simply join from the Free Hero panel; you generally deal with them through commands such as [**Apprehend Outlaw**](/commands/#apprehend-outlaw).
+
+Some free heroes are effectively unavailable until circumstances change. For example, a province without one of your faction leaders cannot recruit from the Free Hero panel, and a hero may refuse forever if they have a permanent reason not to join your faction.
+
+## Relationships
+
+Faction relationships have a visible diplomatic state and an internal trust value.
+
+The visible relationship states are:
+
+- **Hostile:** The default enemy state. Hostile factions can fight each other.
+- **Truce:** A temporary peace. Truce offers set a reset date; when that date passes, the relationship returns to hostile. A truce or alliance also causes hostile armies between those factions to turn back during the truce turn-back phase.
+- **Alliance:** A stronger cooperative relationship. Alliances do not have a reset date. They last until they are broken.
+
+Trust is a hidden number used by AI diplomacy. Higher trust makes a faction more willing to accept diplomatic offers. Trust changes in a few ways:
+
+- Trust rises by 1 each new round between every pair of factions.
+- Accepting a ransom offer raises the offering faction's trust in the faction that accepted it by 25.
+- Rejecting a ransom offer lowers the offering faction's trust in the rejecting faction by 25.
+- Imprisoning another faction's ambassador is a major trust hit: the ambassador's faction loses 150 trust toward the imprisoning faction.
+- Other factions also notice ambassador imprisonment: each neutral faction loses 40 trust toward the imprisoning faction.
+
+## Incoming Diplomacy Offers
+
+Incoming offers are unresolved diplomatic proposals from other factions. They become [special and conditional commands](/commands/#special-and-conditional-commands) such as resolving truce offers, alliance offers, invitations, ransom offers, or alliance breaks.
+
+## Focus Province
+
+A faction can have a focus province. The focus province helps direct [province orders](/provinces/#province-orders) and AI attention toward a particular province.
+
+## Faction Destruction
+
+A faction is destroyed if either of these is true:
+
+- It has no ruled provinces and no moving armies.
+- It has no faction leaders left.
+
+The leader case has one extra succession step. If a faction loses its available leaders but still has provinces or armies, the game first looks for the strongest surviving vassal and promotes that hero to faction leader and faction head. If no vassal can rise, the faction has no faction leaders left and is destroyed.
+
+When a faction is destroyed:
+
+- Its provinces lose their ruling faction.
+- Its incoming armies are removed, and their supplies are left in the province.
+- Its heroes lose their faction assignment.
+- Other factions lose relationships and incoming offers involving the destroyed faction.
+- If only one faction remains, the game ends and that faction wins. If no factions remain, the game ends with no winner.

docs/eagle0pedia/src/content/docs/heroes/index.md

@@ -0,0 +1,216 @@
+---
+title: Heroes
+description: Reference for Eagle heroes, stats, professions, and battlefield roles.
+---
+
+Heroes are named characters who lead factions, rule provinces, command troops, perform strategic commands, and appear as units in Shardok battles.
+
+The player-facing hero model is `HeroView`. It includes identity, faction membership, profession, core stats, personality stats, vigor, loyalty, abilities, portrait path, and backstory text.
+
+## Core Stats
+
+- **Strength** affects physical power and contributes to combat-oriented commands.
+- **Agility** affects mobility, scouting-style competence, and some profession eligibility.
+- **Constitution** sets a hero's endurance profile and is closely tied to vigor.
+- **Charisma** affects leadership, loyalty, diplomacy-flavored actions, and some profession eligibility.
+- **Wisdom** affects knowledge, magic-flavored actions, and some profession eligibility.
+
+Stats can also have XP values. Strategic commands often spend vigor and grant XP in the stats connected to that action.
+
+## Personality Stats
+
+- **Integrity** represents trustworthiness and moral reliability.
+- **Ambition** represents appetite for power or advancement.
+- **Gregariousness** represents sociability and ease with other heroes.
+- **Bravery** represents willingness to face danger.
+
+These values help drive hero flavor, AI decisions, and story generation.
+
+## Vigor
+
+Vigor is a hero's current energy. Many commands require an acting hero and spend vigor. Resting restores vigor up to the hero's constitution.
+
+## Loyalty
+
+Loyalty measures a hero's attachment to their faction. Feasts, events, captures, faction bias, and story consequences can move loyalty over time.
+
+## Professions
+
+Professions give heroes special command access, bonuses, and tactical identity. Some effects are Eagle strategic effects, while others apply only when the hero is attached to a Shardok battle unit.
+
+Several Shardok profession commands also depend on the attached battalion type. For example, many magic commands require a battalion type that allows casting, and stealth commands require a battalion type that allows stealth.
+
+### Mage
+
+Eagle effects:
+
+- Unlocks **Control Weather** for a mage in the acting province with enough vigor.
+- Can start or end blizzards and droughts in the acting province or a neighboring province.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+- Makes the hero naturally capable of starting fires.
+
+Shardok effects:
+
+- Unlocks **Lightning Bolt** when attached to a casting-capable unit.
+- Unlocks the multi-round **Meteor** command chain: start, target, cast, and cancel.
+- Unlocks **Freeze Water** on adjacent water when attached to a casting-capable unit.
+- Improves **Start Fire** odds when the unit can start fires.
+- Changes hero melee damage from physical damage to magical damage: lightning, cold, fire, and aether essence.
+- Can influence AI water-crossing evaluation because Mage can freeze water.
+
+Profession gain:
+
+- Wisdom is the qualifying stat for Mage.
+
+### Necromancer
+
+Eagle effects:
+
+- Unlocks **Start Epidemic** for a necromancer in the acting province with enough vigor.
+- Epidemics can target the acting province or neighboring provinces, excluding friendly provinces that already have an epidemic.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+
+Shardok effects:
+
+- Unlocks **Raise Dead** when attached to a casting-capable unit and not already controlling a unit.
+- Unlocks **Fear** against eligible enemy units when attached to a casting-capable unit.
+- Raised dead and fear use the hero's charisma and wisdom in their odds.
+
+Profession gain:
+
+- Charisma is one qualifying stat for Necromancer.
+
+### Engineer
+
+Eagle effects:
+
+- Is recommended first for **Improve** when an engineer is available.
+- Adds the configured engineer bonus to province improvements and devastation repair.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+
+Shardok effects:
+
+- Unlocks **Build Bridge** from non-water terrain onto adjacent water.
+- Unlocks **Repair** for damaged bridges and castles.
+- Unlocks **Blow Bridge** while standing on a bridge.
+- Unlocks **Reduce** from a castle or fortified position against enemy units or castles.
+- Unlocks **Fortify** on fortifiable terrain.
+- Can influence AI water-crossing evaluation because engineers can create and destroy bridge access.
+
+Profession gain:
+
+- Agility is one qualifying stat for Engineer.
+
+### Paladin
+
+Eagle effects:
+
+- Improves **Alms** by multiplying the support gained per food given.
+- Is sorted first in the **Alms** hero list when eligible.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+
+Shardok effects:
+
+- Unlocks **Holy Wave** when the paladin has enough action points.
+
+Profession gain:
+
+- Charisma is one qualifying stat for Paladin.
+
+### Ranger
+
+Eagle effects:
+
+- Unlocks **Recon** for a ranger in the acting province with enough vigor.
+- Recon can target provinces not ruled by the acting faction, as long as that faction does not already have a pending recon there.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+
+Shardok effects:
+
+- Unlocks **Scout** when attached to a stealth-capable unit.
+- Unlocks **Hide** when attached to a stealth-capable unit, outside enemy zone of control, and with multiple hideable positions.
+- Allows defending rangers with stealth-capable units to use hidden placement during setup.
+- Gives a bonus to **Brave Water** odds when the unit can brave water.
+- Reveals adjacent hidden enemies while moving.
+- Prevents adjacent enemies from hiding or remaining hidden when the ranger has enough knowledge to be identified.
+
+Profession gain:
+
+- Agility is one qualifying stat for Ranger.
+
+### Champion
+
+Eagle effects:
+
+- Is recommended first for **Train** when a champion is available.
+- Adds the configured champion bonus to training gained by trainable battalions.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+
+Shardok effects:
+
+- Unlocks **Challenge Duel** against adjacent enemy heroes outside castles.
+- The target must have an attached hero and must either have enough known vigor to accept or be insufficiently known to rule that out.
+
+Profession gain:
+
+- Strength is the qualifying stat for Champion.
+
+### Warden
+
+Eagle effects:
+
+- Improves prisoner recruitment over time. At new round processing, prisoners in a province with a ruling-faction Warden gain additional faction bias toward that province's ruler.
+- Counts as a profession for general hero power and riot-crackdown hero power.
+
+Shardok effects:
+
+- Unlocks **Evacuate Prisoners** when the warden's unit can flee, has enough action points, and hostile captured hero units are present.
+
+Profession gain:
+
+- Constitution is the qualifying stat for Warden.
+
+### NoProfession
+
+Heroes with no profession have no profession-specific command unlocks. They can still lead, fight, train, improve, march, use many normal strategic commands, and gain a profession later.
+
+## Profession Gain
+
+Only heroes with **NoProfession** can gain a profession. At the end of a round, heroes with enough XP can gain stats. If a no-profession hero gains one or more stats, the game checks for profession gain:
+
+- The hero gets one profession-gain roll for each stat that increased.
+- Eligible professions are based on all post-gain stats at or above the configured prime-stat threshold.
+- Strength qualifies **Champion**.
+- Agility qualifies **Engineer** and **Ranger**.
+- Wisdom qualifies **Mage**.
+- Charisma qualifies **Necromancer** and **Paladin**.
+- Constitution qualifies **Warden**.
+
+## Faction Leaders
+
+Every faction starts with a **faction head**. The faction head is the hero who defines what the faction represents: its political identity, its public story, and the starting point for its leadership.
+
+Factions can gain additional faction leaders through **Swear Kinship** with another hero. The candidate must already belong to the faction, must have at least 95 loyalty, and must be in a province with the faction head. When the command succeeds, that hero becomes one of the faction's leaders.
+
+Faction leaders are directly commandable. Vassals, by contrast, lead provinces and make their own choices when their province acts. Promoting a loyal vassal into leadership gives the player more direct control over that hero.
+
+Faction leaders also provide succession. If the faction head is killed, another available faction leader can take over as the new faction head.
+
+## Vassals
+
+A **vassal** is a hero who belongs to your faction and rules one of its provinces, but is not a faction leader. You cannot command vassals directly. Instead, their provinces act during the Vassal Commands phase, when each vassal chooses an action based on the province's standing orders and immediate needs.
+
+Vassals can be given standing orders with **Issue Orders**, promoted to faction leaders with **Swear Kinship**, or removed from the faction with **Exile Vassal**.
+
+## Unaffiliated Heroes
+
+Unaffiliated heroes can appear in provinces before joining a faction. Their province entry includes name, profession, status, leader flag, and recruitment information.
+
+Common interactions include recruiting them, divining more information about them, declining their quests, or responding when they ask to join.
+
+## Battle Capabilities
+
+Hero views expose whether a hero is archery-capable or start-fire-capable. Those capabilities affect Shardok command availability when the hero is represented in battle.
+
+- **Archery-capable**: the hero needs at least 75 agility.
+- **Start-fire-capable**: the hero is always capable if they are a Mage. Otherwise, they need at least 70 agility and at least 70 wisdom.

docs/eagle0pedia/src/content/docs/index.md

@@ -0,0 +1,23 @@
+---
+title: Eagle0pedia
+description: Reference companion for Eagle0 commands, systems, and game concepts.
+---
+
+Eagle0pedia is the in-game reference companion for Eagle0. The tutorial answers "what should I do next?"; these pages answer "what does this mean?"
+
+Eagle0 is a strategy game about factions, heroes, provinces, armies, diplomacy, and tactical battles. The broad strategic layer is **Eagle**: provinces produce food and gold, heroes lead factions or rule as vassals, armies march across the map, and diplomacy shapes the war. When armies clash, battles are resolved in **Shardok**, the tactical hex-based combat system.
+
+Use these pages when you want a quick reference for commands, hero professions, faction leadership, province stats, or tactical battle options.
+
+## Sections
+
+- [Game concepts](concepts/) explains the flow of Eagle rounds, the handoff from Eagle to Shardok, tactical battles, and victory conditions.
+- [Eagle round flow](concepts/eagle-round-flow/) explains strategic phases and simultaneous player action.
+- [From Eagle to Shardok](concepts/eagle-to-shardok/) explains how strategic armies become tactical battles.
+- [Shardok battles](concepts/shardok-battles/) explains tactical battle structure, units, terrain, and aftermath.
+- [Shardok victory conditions](concepts/shardok-victory-conditions/) explains how tactical battles end.
+- [Eagle commands](commands/) explains the strategic commands available from province command panels.
+- [Shardok commands](shardok-commands/) explains tactical battle commands and profession-gated battlefield actions.
+- [Heroes](heroes/) covers stats, vigor, loyalty, professions, faction leaders, and battle capabilities.
+- [Factions](factions/) covers faction heads, leaders, prestige, diplomacy, and focus provinces.
+- [Provinces](provinces/) covers province stats, supplies, orders, armies, maps, castles, and unaffiliated heroes.

docs/eagle0pedia/src/content/docs/integration/index.md

@@ -0,0 +1,19 @@
+---
+title: Integration Notes
+description: Technical notes for Eagle0pedia links, deployment, and review.
+---
+
+Eagle0pedia lives close to the game data and can be reviewed with code changes before being deployed to `pedia.eagle0.net`.
+
+## Link Targets
+
+Unity info buttons should link to stable concept URLs. For the command panel, start with anchors on the command reference page:
+
+- `https://pedia.eagle0.net/commands/#train`
+- `https://pedia.eagle0.net/commands/#march`
+- `https://pedia.eagle0.net/commands/#diplomacy`
+- `https://pedia.eagle0.net/shardok-commands/#melee`
+- `https://pedia.eagle0.net/heroes/#professions`
+- `https://pedia.eagle0.net/provinces/#province-stats`
+
+When individual command pages are split out, keep redirects or aliases for these anchors so older clients still land somewhere useful.

docs/eagle0pedia/src/content/docs/provinces/index.md

@@ -0,0 +1,229 @@
+---
+title: Provinces
+description: Reference for Eagle provinces, resources, infrastructure, orders, and tactical maps.
+---
+
+Provinces are the strategic map locations in Eagle. They hold resources, heroes, battalions, province orders, incoming armies, local events, and the Shardok map used when battles occur there.
+
+The player-facing province model is `ProvinceView`. Public information includes id, name, ruling faction, known events, known incoming armies, and an `as_of` date. When you have full information, `FullProvinceInfo` adds the detailed local state: gold, food, caps, support, food consumption, battalions, heroes, orders, incoming shipments, and local events.
+
+<!--
+Source map:
+- Province view fields: src/main/protobuf/net/eagle0/eagle/views/province_view.proto and src/main/scala/net/eagle0/eagle/library/util/view_filters/ProvinceViewFilter.scala.
+- Province utilities: src/main/scala/net/eagle0/eagle/library/util/province/ProvinceUtils.scala.
+- New year production and yearly degradation: src/main/scala/net/eagle0/eagle/library/actions/impl/action/NewYearAction.scala.
+- New round caps, price-index drift, empty-province devastation repair, and hero-cap loyalty pressure: src/main/scala/net/eagle0/eagle/library/actions/impl/action/NewRoundAction.scala.
+- Food consumption and starvation: src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformFoodConsumptionPhaseAction.scala.
+- Shipment arrival: src/main/scala/net/eagle0/eagle/library/actions/impl/action/ShipmentArrivedAction.scala and src/main/scala/net/eagle0/eagle/library/actions/impl/action/PerformProvinceMoveResolutionAction.scala.
+- Price index: src/main/scala/net/eagle0/eagle/library/util/PriceIndexUtils.scala.
+- Settings: src/main/resources/net/eagle0/eagle/settings.tsv.
+-->
+
+## Strategic Role
+
+A province is both a resource base and a staging point. It can:
+
+- Produce gold and food at the new year.
+- Store gold and food between commands.
+- Feed stationed battalions each round.
+- Hold heroes, battalions, prisoners, unaffiliated heroes, and events.
+- Launch March, Send Supplies, Train, Improve, Arm Troops, Trade, and other province commands.
+- Become a Shardok battlefield when hostile armies meet there.
+
+The important strategic question is usually not just "how high are the stats?" It is "can this province keep support above 40, feed its troops, store enough supplies, and stage the actions I need before another faction interferes?"
+
+## Development Stats
+
+The three main development stats are **economy**, **agriculture**, and **infrastructure**.
+
+- **Economy** drives annual gold production. A supported province produces 35 gold per effective economy at the new year.
+- **Agriculture** drives annual food production. A supported province produces 50 food per effective agriculture at the new year.
+- **Infrastructure** increases gold and food storage caps, affects improvement quality, and caps how far battalions can be armed.
+
+Each stat has a matching devastation track. The effective value is the stat minus its devastation, never below 0. For example, 80 agriculture with 25 agriculture devastation behaves like 55 effective agriculture for production and other effective-stat checks.
+
+Improve can raise economy, agriculture, or infrastructure. It can also repair devastation across all three devastation tracks. Engineers get a bonus when improving.
+
+## Support
+
+Support is local backing for the ruling faction. It ranges from 0 to 100 and is one of the most important province numbers.
+
+A province needs at least **40 support** to provide annual gold and food production. If support is below 40, the province does not produce taxes at the new year. That also matters for prestige: supported provinces are worth prestige to the ruling faction.
+
+Support changes through several commands and events:
+
+- **Alms** spends food to raise support.
+- **Improve** raises support as a side effect.
+- **Riot** damage reduces support by 25 if the riot is not stopped.
+- **Suppress Beasts** can raise support on success.
+- Province events can raise or lower support.
+
+Support also affects risk. Low support makes the province less useful economically and affects riot timing.
+
+## Gold
+
+Gold pays for many strategic actions. Feast, Organize Troops, Arm Troops, Divine, Hero Gift, diplomacy, Trade buys, and some other commands spend gold.
+
+At the new year, supported provinces gain annual gold equal to:
+
+`effective economy * 35`
+
+Gold is stored in the province until spent, traded, shipped, marched away, captured through conquest, or lost because the province is over its storage cap.
+
+Feast costs gold, not food: 20 gold per ruling-faction hero in the province, multiplied by the province price index.
+
+## Food
+
+Food supports armies and can also be spent strategically.
+
+At the new year, supported provinces gain annual food equal to:
+
+`effective agriculture * 50`
+
+Food is consumed during the Food Consumption phase by battalions stationed in the province and by moving armies. The province view exposes monthly food consumption so you can judge how long the province can feed its current troops.
+
+Food is also used by:
+
+- **Alms**, which spends food to raise support.
+- **Trade**, which buys or sells food for gold.
+- **Send Supplies**, which can ship food to another province.
+- **March**, which can carry food with moving armies.
+- Riot gifts, if you choose to give food.
+
+## Food Consumption and Starvation
+
+Food consumption happens during the Food Consumption phase, after Province Move Resolution, player commands, hostile army setup, and battle requests, but before Battle Resolution.
+
+This timing matters:
+
+- A Send Supplies shipment that arrives during Province Move Resolution is available before the destination province consumes food later that same round.
+- A friendly marching army that arrives during Province Move Resolution can also bring food before that round's food consumption.
+- Moving armies consume food from their own carried supplies while they are still incoming.
+
+If a province cannot feed its battalions, it spends all remaining province food and the battalions are reduced. The maximum battalion reduction from a food shortage is 20% in a single food-consumption event.
+
+The same starvation rule applies to moving armies: if the army's carried food is not enough, the moving battalions are reduced and the army's food drops to 0.
+
+Low-food warnings look ahead to incoming food, upcoming taxes, support, and expected production. If the province has enough food arriving before the next consumption, the warning can account for that.
+
+## Storage Caps
+
+Provinces have separate gold and food caps. These caps are based on effective development and infrastructure:
+
+- Gold cap uses effective economy plus effective infrastructure.
+- Food cap uses effective agriculture plus effective infrastructure.
+- Both start from a base storage limit of 5000.
+- Each point of relevant development or infrastructure adds 50 storage.
+- A faction's focus province gets 1.5x storage.
+
+Being over cap is not an immediate hard cutoff. During New Round processing, the province loses 20% of the amount above each cap, rounded up. Excess supplies therefore decay over time unless you spend them, ship them, trade them, or move them.
+
+## Price Index
+
+Price index is local price pressure. It changes costs and trade prices in the province.
+
+The normal range is 0.75 to 1.5. A price index above 1 makes local purchases more expensive; below 1 makes them cheaper.
+
+Gold spending can push the price index upward. Selling food counts as negative gold spending and can push it downward. Each gold spent changes the index by 0.0001, clamped to the normal range.
+
+The price index also drifts each new round toward a local steady state based on development and devastation. It moves 10% of the distance toward that steady state per round.
+
+Commands affected by price index include:
+
+- **Feast** gold cost.
+- **Organize Troops** troop costs.
+- **Arm Troops** armament costs.
+- **Trade** buy and sell prices.
+- **Divine** cost.
+- **Hero Gift** loyalty gained per gold.
+
+## Devastation
+
+Devastation is damage to province systems. Economy, agriculture, and infrastructure each have their own devastation value.
+
+Devastation reduces the corresponding effective stat. That means:
+
+- Economy devastation reduces gold production and gold storage.
+- Agriculture devastation reduces food production and food storage.
+- Infrastructure devastation reduces storage, armament ceiling, and infrastructure-dependent checks.
+
+Battles and province events can add devastation. Riots add economy and infrastructure devastation. Blizzards, droughts, floods, epidemics, and battle results can damage different province systems.
+
+Improve with the Devastation option repairs all three devastation tracks. Empty provinces also recover devastation slowly during new round processing.
+
+## Infrastructure and Troops
+
+Infrastructure matters militarily because it caps armament. Arm Troops cannot raise a battalion's ARM above the province's effective infrastructure.
+
+Economy and agriculture also affect which battalion types can be raised in the province. Battalion type availability checks the province's effective economy and effective agriculture against the battalion type's minimums.
+
+Training is handled by [**Train**](/commands/#train). Armament is handled by [**Arm Troops**](/commands/#arm-troops). Organizing troop counts, creating battalions, resizing battalions, and dismissing battalions are handled by [**Organize Troops**](/commands/#organize-troops).
+
+## Heroes and Hero Cap
+
+A province has a hero cap. The default map data sets hero cap from castle count: each castle gives 5 hero capacity.
+
+Going over the cap is allowed, but it creates loyalty pressure. During new round processing, if the province has too many established ruling-faction heroes, those heroes lose loyalty. Newly joined heroes are exempt for their first few rounds.
+
+This is why moving heroes around is not just about command access. Keeping too many heroes stacked in one province can create long-term loyalty damage.
+
+## Ruling Faction and Ruling Hero
+
+A province can have a ruling faction and a ruling hero. The ruling hero is the local leader for the province.
+
+If a faction leader rules the province, the player can command that leader directly. If a [vassal](/heroes/#vassals) rules it, the province acts through vassal behavior during the [Vassal Commands phase](/concepts/eagle-round-flow/#vassal-commands) unless another special phase interrupts it.
+
+Province leadership also matters for riots. The province leader's Charisma affects riot size and gift success, even if another hero is selected to crack down.
+
+## Province Orders
+
+Province orders are standing instructions for vassal-led provinces. The [**Issue Orders**](/commands/#issue-orders) command changes them and can also set or clear the faction focus province.
+
+The main orders are:
+
+- **Entrust:** let the vassal judge the situation.
+- **Develop:** build up and improve the province.
+- **Mobilize:** prepare military strength and supplies.
+- **Expand:** look for growth, movement, and attack opportunities.
+
+The focus province also affects logistics. Vassals may ship excess gold and food toward the focus province if one is set, or toward the nearest faction leader if not.
+
+## Incoming Armies
+
+Incoming armies represent forces that are moving toward the province but have not arrived or resolved yet.
+
+Friendly incoming armies arrive during [Province Move Resolution](/concepts/eagle-round-flow/#province-move-resolution) if the destination is already ruled by their faction. Hostile arrivals do not simply enter the province; they can become hostile army groups and later trigger conquest, attack decisions, defense decisions, battle requests, and [Shardok battles](/concepts/eagle-to-shardok/).
+
+Incoming armies can carry gold and food. If supplies arrive with a friendly movement, transit loss can reduce the amount received.
+
+## Incoming Shipments
+
+Incoming shipments are supplies sent by [**Send Supplies**](/commands/#send-supplies).
+
+The origin province loses the selected gold and food immediately. The destination receives an incoming shipment scheduled for the next round. During the next round's Province Move Resolution phase, the shipment arrives before food consumption. 10% is lost in transit, rounded down after loss.
+
+Because shipments arrive before food consumption, shipping food can prevent starvation in the destination province during the arrival round.
+
+## Province Events
+
+Province events are temporary or local conditions that affect the province.
+
+Important event types include:
+
+- **Riot:** requires a decision if it reaches Handle Riot. If not stopped, it causes support loss and devastation.
+- **Beasts:** can damage support over time and can be suppressed for rewards and prestige.
+- **Blizzard:** damages province systems and affects supplies.
+- **Drought:** damages agriculture.
+- **Flood:** damages infrastructure and agriculture.
+- **Epidemic:** damages economy, battalions, and hero vigor, and can spread or end over time.
+- **Festival:** improves support and prestige while active.
+
+Some events can be created or changed by commands. Mages can use [**Control Weather**](/commands/#control-weather) to start or end blizzards and droughts. Necromancers can use [**Start Epidemic**](/commands/#start-epidemic).
+
+## Tactical Map and Castles
+
+Each province has a `hex_map_name`. When a battle occurs there, Eagle uses that name to choose the Shardok tactical map.
+
+`castle_count` records the province's fortification count. Castles matter for hero capacity, defensive setup, tactical objectives, and some battle behavior.
+
+The source map data in `province_map.tsv` defines province ids, names, neighbor ids, neighbor positions, tactical map names, neighbor names, and castle counts.

docs/eagle0pedia/src/content/docs/shardok-commands/index.md

@@ -0,0 +1,422 @@
+---
+title: Shardok Commands
+description: Tactical command reference for Shardok battles.
+---
+
+<span class="command-reference-marker" aria-hidden="true"></span>
+<span class="command-reference-five-row-marker" aria-hidden="true"></span>
+
+<!--
+Source map for Shardok command requirements/costs:
+- Shared morale/vigor filters: src/main/resources/net/eagle0/shardok/settings.tsv fields minimumMoraleToAct=10 and minimumVigorToAct=10; applied in src/main/cpp/net/eagle0/shardok/library/AvailableCommandsFactory.cpp.
+- Fixed AP setting values: src/main/resources/net/eagle0/shardok/settings.tsv. Most command factories call SettingsGetter::ActionCostFor(...) in src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.cpp, which returns ActionCost::usesAll; see src/main/cpp/net/eagle0/shardok/library/ActionCost.hpp and src/main/cpp/net/eagle0/shardok/library/unit/Unit.cpp.
+- Melee: meleeActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/melee_command_factory/MeleeCommandFactory.cpp.
+- Archery: archeryActionPointCost=5 and longbowWindBonusRangeMinSpeed=20; hero archery threshold is agility >= 75 in src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleSimulator.cpp; normal targets come from TwoAwayTilesUnblockedByMountains in src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.cpp; longbow castle-adjacent and wind-assisted range-3 exceptions are in src/main/cpp/net/eagle0/shardok/library/command_factories/archery_command_factory/ArcheryCommandFactory.cpp; volley spend is in src/main/cpp/net/eagle0/shardok/library/commands/ArcheryCommand.cpp.
+- Charge: terrain-entry cost from BattalionType::GetCostToEnterTerrain(...); allowsMoveAfterCharge is true for Light Cavalry and Heavy Cavalry in src/main/resources/net/eagle0/shardok/battalionTypes.tsv; stun settings are baseStunChanceOnCharge and trainingDifferenceMultiplierForStunChanceOnCharge in the same file; src/main/cpp/net/eagle0/shardok/library/command_factories/ChargeCommandFactory.cpp.
+- Move: per-hex terrain-entry costs, plus extraCostForZocMovement=1; src/main/cpp/net/eagle0/shardok/library/command_factories/MoveCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/MoveCommand.cpp.
+- Lightning Bolt: lightningActionPointCost=5 and lightningRange=3; src/main/cpp/net/eagle0/shardok/library/command_factories/LightningBoltCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/LightningBoltCommand.cpp.
+- Meteor: meteorStartActionPointCost=5, meteorTargetActionPointCost=0, meteorCancelActionPointCost=0, meteorCastActionPointCost=1, meteorCastVigorCost=20, and meteorRange=3; src/main/cpp/net/eagle0/shardok/library/command_factories/MeteorStartCommandFactory.cpp, MeteorTargetCommandFactory.cpp, src/main/cpp/net/eagle0/shardok/library/util/MeteorRangeCoords.cpp, src/main/cpp/net/eagle0/shardok/library/commands/MeteorStartCommand.cpp, MeteorTargetCommand.cpp, MeteorCancelCommand.cpp, and src/main/cpp/net/eagle0/shardok/library/actions/MeteorCastAction.cpp.
+- Start Fire: startFireActionPointCost=5; hero start-fire thresholds are Mage or agility >= 70 and wisdom >= 70 in src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleSimulator.cpp; src/main/cpp/net/eagle0/shardok/library/command_factories/StartFireCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/StartFireCommand.cpp.
+- Extinguish Fire: extinguishActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/ExtinguishFireCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/ExtinguishFireCommand.cpp.
+- Freeze Water: freezeWaterActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/FreezeWaterCommandFactory.cpp.
+- Build Bridge: buildBridgeActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/BuildBridgeCommandFactory.cpp.
+- Blow Bridge: blowBridgeActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/BlowBridgeCommandFactory.cpp.
+- Placement: no AP cost in setup commands; src/main/cpp/net/eagle0/shardok/library/actions/PlaceUnitCommand.cpp and PlaceHiddenUnitCommand.cpp.
+- Scout: scoutActionPointCost=5 and scoutRange=4; src/main/cpp/net/eagle0/shardok/library/command_factories/ScoutCommandFactory.cpp.
+- Raise Dead: raiseDeadActionPointCost=5 and raiseDeadRange=2; src/main/cpp/net/eagle0/shardok/library/command_factories/RaiseDeadCommandFactory.cpp.
+- Dismiss Unit: requires remainingActionPoints > 0 in src/main/cpp/net/eagle0/shardok/library/command_factories/ControlCommandFactory.cpp; execution zeroes both units in src/main/cpp/net/eagle0/shardok/library/commands/DismissUnitCommand.cpp.
+- Holy Wave: holyWaveActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/HolyWaveCommandFactory.cpp.
+- Stop and Rest: stop posts no AP cost; rest zeroes AP in src/main/cpp/net/eagle0/shardok/library/commands/UnitRestCommand.cpp; stop implementation in UnitStopCommand.cpp.
+- Challenge Duel: challengeDuelActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/ChallengeDuelCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/challenge_duel_command/ChallengeDuelCommand.cpp.
+- Fear: fearActionPointCost=5 and fearRange=3; src/main/cpp/net/eagle0/shardok/library/command_factories/FearCommandFactory.cpp.
+- Repair: repairActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/RepairCommandFactory.cpp.
+- Reduce: reduceActionPointCost=5 and reduceRange=3; src/main/cpp/net/eagle0/shardok/library/command_factories/ReduceCommandFactory.cpp.
+- Flee and Retreat: fleeActionPointCost=5 and retreatActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/FleeCommandFactory.cpp and RetreatCommandFactory.cpp.
+- Control: requires remainingActionPoints > 0 in ControlCommandFactory.cpp; execution zeroes acting unit in src/main/cpp/net/eagle0/shardok/library/commands/ControlCommand.cpp.
+- Reinforce: reinforceActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/ReinforceCommandFactory.cpp.
+- Brave Water: braveWaterActionPointCost=8; src/main/cpp/net/eagle0/shardok/library/command_factories/BraveWaterCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/BraveWaterCommand.cpp.
+- Release Unit: requires remainingActionPoints > 0 in ControlCommandFactory.cpp; execution zeroes both units in src/main/cpp/net/eagle0/shardok/library/commands/ReleaseUnitCommand.cpp.
+- End Turn and Setup: no command AP cost; end turn zeroes player unit AP in src/main/cpp/net/eagle0/shardok/library/commands/EndTurnCommand.cpp; setup end in src/main/cpp/net/eagle0/shardok/library/actions/EndPlayerSetupCommand.cpp.
+- Hide: hideActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/HideCommandFactory.cpp.
+- Fortify: fortifyActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/FortifyCommandFactory.cpp.
+- Become Outlaw: uses fleeActionPointCost=5 through src/main/cpp/net/eagle0/shardok/library/command_factories/FleeCommandFactory.cpp and src/main/cpp/net/eagle0/shardok/library/commands/BecomeOutlawCommand.cpp.
+- Evacuate Prisoners: evacuatePrisonersActionPointCost=5; src/main/cpp/net/eagle0/shardok/library/command_factories/EvacuatePrisonersCommandFactory.cpp.
+-->
+
+## Shared Requirements
+
+Unless noted otherwise: **10 morale**, **10 hero vigor**, and the listed **Action Point cost**.
+
+## Tactical Commands
+
+### Melee
+
+<b>Unit requirements:</b> any unit.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> an enemy target is adjacent and the acting unit can still act.
+
+<b>Effect:</b> Attack the target in close combat. The UI may show combat odds before you choose the attack.
+
+<b>Selection:</b> choose the attacking unit and adjacent target.
+
+### Archery
+
+<b>Unit requirements:</b> Longbowmen, or a unit with an attached hero who has at least 75 AGI. The unit must have at least one volley remaining.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a known enemy is exactly 2 hexes away, and the line between the attacker and target is not blocked by mountains.
+
+<b>Effect:</b> Make a ranged attack without requiring adjacency, spending one volley. Longbowmen can also fire at adjacent hexes while standing in a castle, and can fire 3 hexes when the wind is at least 20 mph and blowing toward the target.
+
+<b>Selection:</b> choose the firing unit and target unit or hex.
+
+### Charge
+
+<b>Unit requirements:</b> any unit.
+
+<b>Action Point cost:</b> the cost to enter the target's terrain. Knights and Dragoons spend only that terrain cost and may be able to move again afterward; other units spend all remaining AP.
+
+<b>Available when:</b> a valid path reaches a target that can be attacked at the end of the move.
+
+<b>Effect:</b> Move into an attack as one action. Charge attacks have a chance to stun the target unit.
+
+<b>Selection:</b> choose the charging unit, path, and target.
+
+### Move
+
+<b>Unit requirements:</b> any unit.
+
+<b>Action Point cost:</b> the terrain cost for each hex in the path, plus 1 extra AP for steps that start in enemy zone of control.
+
+<b>Available when:</b> one or more reachable destination hexes are valid for the acting unit.
+
+<b>Effect:</b> Move the unit along the chosen path to a reachable hex, paying terrain costs as it goes. Hidden units may reveal themselves if they move into exposed terrain or near an enemy Ranger.
+
+<b>Selection:</b> choose the unit and destination path.
+
+### Lightning Bolt
+
+<b>Unit requirements:</b> [Mage](/heroes/#mage) attached to Light Infantry, Light Cavalry, or Longbowmen. Heavy units and Undead cannot cast.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a known enemy is within 3 hexes of the caster.
+
+<b>Effect:</b> Cast a lightning attack at the target. The descriptor may include odds or roll information when the client can display expected results.
+
+<b>Selection:</b> choose the casting unit and target.
+
+### Meteor
+
+<b>Unit requirements:</b> [Mage](/heroes/#mage) attached to Light Infantry, Light Cavalry, or Longbowmen, with enough vigor to start the spell. Heavy units and Undead cannot cast.
+
+<b>Action Point cost:</b> start costs 5 AP and consumes all remaining AP; target and cancel cost 0 AP; the automatic cast step is configured as 1 AP but resolves by setting the caster to 0 AP.
+
+<b>Available when:</b> the caster can begin the spell, choose or change a target within 3 hexes, cast the pending meteor, or cancel the pending meteor.
+
+<b>Effect:</b> Begin a delayed meteor spell, choose where it will land, then resolve the strike when the cast step becomes available. You can cancel while the meteor is still pending.
+
+<b>Selection:</b> choose the caster, spell target, or cancel option depending on the current meteor step.
+
+### Start Fire
+
+<b>Unit requirements:</b> a unit with an attached [Mage](/heroes/#mage), or an attached hero with at least 70 AGI and 70 WIS. Mages improve the odds.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a target hex can be set on fire.
+
+<b>Effect:</b> Attempt to start a fire on the target hex.
+
+<b>Selection:</b> choose the acting unit and target hex.
+
+### Extinguish Fire
+
+<b>Unit requirements:</b> any unit with an attached hero.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a target hex contains fire that can be reduced or removed.
+
+<b>Effect:</b> Remove or reduce fire on the target hex.
+
+<b>Selection:</b> choose the acting unit and burning target hex.
+
+### Freeze Water
+
+<b>Unit requirements:</b> [Mage](/heroes/#mage) attached to Light Infantry, Light Cavalry, or Longbowmen. Heavy units and Undead cannot cast.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a valid water hex can be frozen.
+
+<b>Effect:</b> Turn water into traversable frozen terrain where the command is valid.
+
+<b>Selection:</b> choose the caster and water hex.
+
+### Build Bridge
+
+<b>Unit requirements:</b> [Engineer](/heroes/#engineer).
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the engineer has a valid water or gap target where a bridge can be built.
+
+<b>Effect:</b> Create a bridge across the target.
+
+<b>Selection:</b> choose the engineer unit and bridge target.
+
+### Blow Bridge
+
+<b>Unit requirements:</b> [Engineer](/heroes/#engineer) standing on a bridge.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the bridge can be destroyed.
+
+<b>Effect:</b> Destroy the existing bridge target.
+
+<b>Selection:</b> choose the engineer unit and bridge.
+
+### Placement
+
+<b>Unit requirements:</b> a unit available for setup placement. Hidden placement requires a defending [Ranger](/heroes/#ranger) attached to a stealth-capable unit.
+
+<b>Action Point cost:</b> no AP cost during setup.
+
+<b>Available when:</b> the battle is in setup and a valid placement hex is available.
+
+<b>Effect:</b> Put a reserve unit onto the battlefield. Rangers on stealth-capable units can be placed hidden during defensive setup.
+
+<b>Selection:</b> choose the unit and setup hex.
+
+### Scout
+
+<b>Unit requirements:</b> [Ranger](/heroes/#ranger) attached to a stealth-capable unit.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the ranger can scout a hex within 4 hexes.
+
+<b>Effect:</b> Reveal information about the target hex and nearby terrain, including possible hidden-unit information.
+
+<b>Selection:</b> choose the scouting unit and target.
+
+### Raise Dead
+
+<b>Unit requirements:</b> [Necromancer](/heroes/#necromancer) attached to Light Infantry, Light Cavalry, or Longbowmen, and the hero must not already control a unit. Heavy units and Undead cannot cast.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> there is an empty, undead-traversable target hex within 2 hexes.
+
+<b>Effect:</b> Create or restore undead forces through necromantic action.
+
+<b>Selection:</b> choose the necromancer unit and target.
+
+### Dismiss Unit
+
+<b>Unit requirements:</b> a unit that is allowed to be dismissed.
+
+<b>Action Point cost:</b> requires the controlling unit to have more than 0 AP; execution sets both the controlling unit and dismissed unit to 0 AP.
+
+<b>Available when:</b> dismissal is valid for the current tactical state.
+
+<b>Effect:</b> Remove the unit from the tactical battle.
+
+<b>Selection:</b> choose the unit to dismiss.
+
+### Holy Wave
+
+<b>Unit requirements:</b> [Paladin](/heroes/#paladin).
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the paladin has a valid holy-wave action.
+
+<b>Effect:</b> Use a holy-area effect from the capable unit.
+
+<b>Selection:</b> choose the paladin unit and command target, if one is required.
+
+### Stop and Rest
+
+<b>Unit requirements:</b> a unit that can stop or rest.
+
+<b>Action Point cost:</b> Stop costs 0 AP; Rest consumes all remaining AP.
+
+<b>Available when:</b> the unit can end movement or spend its action resting.
+
+<b>Effect:</b> `UNIT_STOP_COMMAND` stops a unit. `UNIT_REST_COMMAND` has a unit spend its action resting instead of acting aggressively.
+
+<b>Selection:</b> choose stop or rest for the acting unit.
+
+### Challenge Duel
+
+<b>Unit requirements:</b> [Champion](/heroes/#champion).
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> an opposing unit can be challenged.
+
+<b>Effect:</b> Challenge an opposing unit to a duel. The tactical action emits accepted or declined outcomes directly.
+
+<b>Selection:</b> choose the champion unit and duel target.
+
+### Fear
+
+<b>Unit requirements:</b> [Necromancer](/heroes/#necromancer) attached to Light Infantry, Light Cavalry, or Longbowmen. Heavy units and Undead cannot cast.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a known enemy that uses morale is within 3 hexes.
+
+<b>Effect:</b> Use a fear effect against the target.
+
+<b>Selection:</b> choose the necromancer unit and target.
+
+### Repair
+
+<b>Unit requirements:</b> [Engineer](/heroes/#engineer).
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> a damaged unit or battlefield object can be repaired.
+
+<b>Effect:</b> Repair the damaged target.
+
+<b>Selection:</b> choose the engineer unit and repair target.
+
+### Reduce
+
+<b>Unit requirements:</b> [Engineer](/heroes/#engineer) in a castle or fortified position.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> an enemy or damaged castle is within 3 hexes and the line is not blocked by mountains.
+
+<b>Effect:</b> Reduce the target's defensive or structural value.
+
+<b>Selection:</b> choose the engineer unit and target.
+
+### Flee and Retreat
+
+<b>Unit requirements:</b> a unit that is allowed to leave or withdraw.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> flight or retreat is valid for the current battlefield state.
+
+<b>Effect:</b> `FLEE_COMMAND` handles immediate flight from a tactical situation. `RETREAT_COMMAND` handles a more formal withdrawal command.
+
+<b>Selection:</b> choose the fleeing or retreating unit.
+
+### Control
+
+<b>Unit requirements:</b> a unit with access to a control effect.
+
+<b>Action Point cost:</b> requires more than 0 AP; execution sets the acting unit to 0 AP.
+
+<b>Available when:</b> a valid target can be controlled.
+
+<b>Effect:</b> Take control of the target when the command is available.
+
+<b>Selection:</b> choose the acting unit and control target.
+
+### Reinforce
+
+<b>Unit requirements:</b> reinforcements available to enter the battle.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the battle state allows reinforcement and there is a valid entry option.
+
+<b>Effect:</b> Bring reinforcements into the battle.
+
+<b>Selection:</b> choose the reinforcement option and entry placement.
+
+### Brave Water
+
+<b>Unit requirements:</b> a unit that can attempt brave-water movement. [Ranger](/heroes/#ranger) is not required, but Rangers get an odds bonus.
+
+<b>Action Point cost:</b> 8 AP; consumes all remaining AP.
+
+<b>Available when:</b> the unit has a valid water path or water target.
+
+<b>Effect:</b> Move through water despite the usual danger or restriction.
+
+<b>Selection:</b> choose the unit and water movement target.
+
+### Release Unit
+
+<b>Unit requirements:</b> a unit that can release a constrained target.
+
+<b>Action Point cost:</b> requires more than 0 AP; execution sets both the controlling unit and released unit to 0 AP.
+
+<b>Available when:</b> a controlled, held, or otherwise constrained unit can be released.
+
+<b>Effect:</b> Release the constrained unit.
+
+<b>Selection:</b> choose the acting unit and unit to release.
+
+### End Turn and Setup
+
+<b>Unit requirements:</b> None.
+
+<b>Action Point cost:</b> no AP cost to post the command; End Turn then sets that player's remaining unit AP to 0.
+
+<b>Available when:</b> the active player can end the tactical turn or finish setup.
+
+<b>Effect:</b> `END_TURN_COMMAND` ends the active tactical turn. `END_PLAYER_SETUP_COMMAND` ends that player's setup phase.
+
+<b>Selection:</b> choose the end-turn or end-setup command.
+
+### Hide
+
+<b>Unit requirements:</b> [Ranger](/heroes/#ranger) attached to a stealth-capable unit.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the unit can enter or remain in hidden status.
+
+<b>Effect:</b> Hide the unit.
+
+<b>Selection:</b> choose the ranger unit.
+
+### Fortify
+
+<b>Unit requirements:</b> [Engineer](/heroes/#engineer).
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> the engineer can fortify its current position.
+
+<b>Effect:</b> Have the unit fortify its current position.
+
+<b>Selection:</b> choose the engineer unit.
+
+### Become Outlaw
+
+<b>Unit requirements:</b> a unit or hero eligible for the outlaw consequence.
+
+<b>Action Point cost:</b> 5 AP through the flee/outlaw action.
+
+<b>Available when:</b> the battle result or tactical state allows the outlaw transition.
+
+<b>Effect:</b> Mark the unit or hero as becoming an outlaw as a battle consequence.
+
+<b>Selection:</b> choose the outlaw command when offered.
+
+### Evacuate Prisoners
+
+<b>Unit requirements:</b> [Warden](/heroes/#warden) on a unit that can flee.
+
+<b>Action Point cost:</b> 5 AP; consumes all remaining AP.
+
+<b>Available when:</b> prisoners can be moved out of danger.
+
+<b>Effect:</b> Move prisoners out of danger when the battlefield state allows prisoner evacuation.
+
+<b>Selection:</b> choose the warden unit and evacuation command.

docs/eagle0pedia/src/styles/custom.css

@@ -0,0 +1,258 @@
+.sl-markdown-content:has(.command-reference-marker) {
+  --command-border: color-mix(in srgb, var(--sl-color-gray-5), transparent 18%);
+  --command-surface: color-mix(in srgb, var(--sl-color-bg), var(--sl-color-gray-6) 22%);
+  --command-surface-strong: color-mix(in srgb, var(--sl-color-bg), var(--sl-color-accent-low) 28%);
+  --command-muted: var(--sl-color-gray-2);
+  --command-label: var(--sl-color-accent-high);
+}
+
+.command-reference-marker {
+  display: none;
+}
+
+.command-reference-five-row-marker {
+  display: none;
+}
+
+.sl-markdown-content:has(.command-reference-marker) > p:has(.command-reference-marker) {
+  display: none;
+}
+
+.sl-markdown-content:has(.command-reference-five-row-marker) > p:has(.command-reference-five-row-marker) {
+  display: none;
+}
+
+.sl-markdown-content:has(.command-reference-marker) > p {
+  max-width: 68rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h2 {
+  margin-top: 3rem;
+  padding: 1rem 1.125rem;
+  border: 1px solid var(--command-border);
+  border-radius: 0.5rem;
+  background:
+    linear-gradient(90deg, var(--sl-color-accent-low), transparent 72%),
+    var(--command-surface);
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h2 h2 {
+  font-size: clamp(1.35rem, 2.4vw, 1.7rem);
+  line-height: 1.2;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h2 + p {
+  margin-top: 0.75rem;
+  color: var(--command-muted);
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 {
+  margin-top: 1.5rem;
+  margin-bottom: 0;
+  padding: 1rem 1.125rem 0.875rem;
+  border: 1px solid var(--command-border);
+  border-bottom: 0;
+  border-radius: 0.5rem 0.5rem 0 0;
+  background: var(--command-surface-strong);
+  font-size: 1.18rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 h3 {
+  font-size: 1.15rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p + p {
+  margin: 0;
+  padding: 0.75rem 1.125rem;
+  border-right: 1px solid var(--command-border);
+  border-left: 1px solid var(--command-border);
+  background: var(--sl-color-bg);
+  position: relative;
+  padding-left: 13.625rem;
+}
+
+.sl-markdown-content:has(.command-reference-five-row-marker)
+  .sl-heading-wrapper.level-h3
+  + p
+  + p
+  + p
+  + p
+  + p {
+  margin: 0;
+  padding: 0.75rem 1.125rem;
+  border-right: 1px solid var(--command-border);
+  border-left: 1px solid var(--command-border);
+  background: var(--sl-color-bg);
+  position: relative;
+  padding-left: 13.625rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p {
+  padding-top: 1rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p + p {
+  padding-bottom: 1rem;
+  border-bottom: 1px solid var(--command-border);
+  border-radius: 0 0 0.5rem 0.5rem;
+  box-shadow: 0 0.7rem 1.6rem color-mix(in srgb, black, transparent 92%);
+}
+
+.sl-markdown-content:has(.command-reference-five-row-marker)
+  .sl-heading-wrapper.level-h3
+  + p
+  + p
+  + p
+  + p {
+  padding-bottom: 0.75rem;
+  border-bottom: 0;
+  border-radius: 0;
+  box-shadow: none;
+}
+
+.sl-markdown-content:has(.command-reference-five-row-marker)
+  .sl-heading-wrapper.level-h3
+  + p
+  + p
+  + p
+  + p
+  + p {
+  padding-bottom: 1rem;
+  border-bottom: 1px solid var(--command-border);
+  border-radius: 0 0 0.5rem 0.5rem;
+  box-shadow: 0 0.7rem 1.6rem color-mix(in srgb, black, transparent 92%);
+}
+
+.sl-markdown-content:has(.command-reference-marker) p > b:first-child {
+  color: var(--command-label);
+  font-size: 0.82rem;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  white-space: nowrap;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p > b:first-child,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p > b:first-child,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p > b:first-child,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p + p > b:first-child,
+.sl-markdown-content:has(.command-reference-five-row-marker)
+  .sl-heading-wrapper.level-h3
+  + p
+  + p
+  + p
+  + p
+  + p
+  > b:first-child {
+  position: absolute;
+  left: 1.125rem;
+  width: 11.5rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h4 {
+  margin-top: 1rem;
+  padding: 0.65rem 1rem;
+  border: 1px solid var(--command-border);
+  border-radius: 0.45rem;
+  background: color-mix(in srgb, var(--sl-color-gray-6), transparent 55%);
+  color: var(--sl-color-white);
+  font-size: 0.92rem;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 {
+  margin-top: 1rem;
+  margin-bottom: 0;
+  padding: 0.75rem 1rem 0.25rem;
+  border-top: 1px solid var(--command-border);
+  color: var(--sl-color-accent-high);
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p + p {
+  margin: 0;
+  padding: 0.4rem 1rem;
+  border-right: 1px solid var(--command-border);
+  border-left: 1px solid var(--command-border);
+  position: relative;
+  padding-left: 7.5rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p > b:first-child,
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p + p > b:first-child {
+  position: absolute;
+  left: 1rem;
+  width: 5.5rem;
+}
+
+.sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p + p {
+  padding-bottom: 0.8rem;
+  border-bottom: 1px solid var(--command-border);
+  border-radius: 0 0 0.45rem 0.45rem;
+}
+
+@media (max-width: 50rem) {
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h2,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 {
+    padding-right: 0.875rem;
+    padding-left: 0.875rem;
+  }
+
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p + p,
+  .sl-markdown-content:has(.command-reference-five-row-marker)
+    .sl-heading-wrapper.level-h3
+    + p
+    + p
+    + p
+    + p
+    + p {
+    padding-right: 0.875rem;
+    padding-left: 0.875rem;
+  }
+
+  .sl-markdown-content:has(.command-reference-marker) p > b:first-child {
+    display: block;
+    margin-bottom: 0.2rem;
+    white-space: normal;
+  }
+
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p + p,
+  .sl-markdown-content:has(.command-reference-five-row-marker)
+    .sl-heading-wrapper.level-h3
+    + p
+    + p
+    + p
+    + p
+    + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p + p {
+    padding-left: 0.875rem;
+  }
+
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p > b:first-child,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p > b:first-child,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p > b:first-child,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h3 + p + p + p + p > b:first-child,
+  .sl-markdown-content:has(.command-reference-five-row-marker)
+    .sl-heading-wrapper.level-h3
+    + p
+    + p
+    + p
+    + p
+    + p
+    > b:first-child,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p > b:first-child,
+  .sl-markdown-content:has(.command-reference-marker) .sl-heading-wrapper.level-h5 + p + p > b:first-child {
+    position: static;
+    width: auto;
+  }
+}

docs/eagle0pedia/tools/astro-cli.mjs

@@ -0,0 +1 @@
+import "../node_modules/astro/astro.js";

docs/eagle0pedia/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "astro/tsconfigs/strict"
+}

maven_install.json

@@ -29,6 +29,7 @@
     "com.thesamet.scalapb:scalapb-json4s_3": -772830803,
     "com.thesamet.scalapb:scalapb-runtime-grpc_3": -2026114331,
     "com.thesamet.scalapb:scalapb-runtime_3": -1281968352,
+    "com.zaxxer:HikariCP": 1858991878,
     "io.netty:netty-buffer": 732437843,
     "io.netty:netty-codec": -1199307927,
     "io.netty:netty-codec-http": -1456497900,
@@ -117,6 +118,7 @@
     "com.thesamet.scalapb:scalapb-runtime-grpc_3": 97373115,
     "com.thesamet.scalapb:scalapb-runtime_3": 818778125,
     "com.typesafe:config": -1791448454,
+    "com.zaxxer:HikariCP": -704610647,
     "commons-codec:commons-codec": 1377992676,
     "commons-io:commons-io": 669567296,
     "dev.dirs:directories": 1716880629,
@@ -550,6 +552,12 @@
       },
       "version": "1.4.6"
     },
+    "com.zaxxer:HikariCP": {
+      "shasums": {
+        "jar": "709f378c05756280939ce50fc1b1f1a53bb8e1899dc1b249f21f12703640b48b"
+      },
+      "version": "6.3.3"
+    },
     "commons-codec:commons-codec": {
       "shasums": {
         "jar": "f700de80ac270d0344fdea7468201d8b9c805e5c648331c3619f2ee067ccfc59"
@@ -1581,6 +1589,9 @@
       "org.scala-lang.modules:scala-collection-compat_3",
       "org.scala-lang:scala3-library_3"
     ],
+    "com.zaxxer:HikariCP": [
+      "org.slf4j:slf4j-api"
+    ],
     "io.get-coursier:coursier-cache_2.13": [
       "io.get-coursier.jniutils:windows-jni-utils",
       "io.get-coursier:cache-util",
@@ -2557,6 +2568,16 @@
       "com.typesafe.config.impl",
       "com.typesafe.config.parser"
     ],
+    "com.zaxxer:HikariCP": [
+      "com.zaxxer.hikari",
+      "com.zaxxer.hikari.hibernate",
+      "com.zaxxer.hikari.metrics",
+      "com.zaxxer.hikari.metrics.dropwizard",
+      "com.zaxxer.hikari.metrics.micrometer",
+      "com.zaxxer.hikari.metrics.prometheus",
+      "com.zaxxer.hikari.pool",
+      "com.zaxxer.hikari.util"
+    ],
     "commons-codec:commons-codec": [
       "org.apache.commons.codec",
       "org.apache.commons.codec.binary",
@@ -4100,6 +4121,7 @@
       "com.thesamet.scalapb:scalapb-runtime-grpc_3",
       "com.thesamet.scalapb:scalapb-runtime_3",
       "com.typesafe:config",
+      "com.zaxxer:HikariCP",
       "commons-codec:commons-codec",
       "commons-io:commons-io",
       "dev.dirs:directories",

scripts/build_eagle_ci.sh

@@ -10,4 +10,8 @@ if [ -n "${BAZEL_OUTPUT_BASE:-}" ]; then
     bazel_cmd+=("--output_base=${BAZEL_OUTPUT_BASE}")
 fi
 
+if [ "$(uname -s)" = "Darwin" ]; then
+    ./scripts/sync_bazel_xcode.sh
+fi
+
 "${bazel_cmd[@]}" build "$@" //src/main/scala/net/eagle0/eagle:eagle_server

scripts/build_shardok_ci.sh

@@ -10,4 +10,8 @@ if [ -n "${BAZEL_OUTPUT_BASE:-}" ]; then
     bazel_cmd+=("--output_base=${BAZEL_OUTPUT_BASE}")
 fi
 
+if [ "$(uname -s)" = "Darwin" ]; then
+    ./scripts/sync_bazel_xcode.sh
+fi
+
 "${bazel_cmd[@]}" build -c opt "$@" //src/main/cpp/net/eagle0/shardok:shardok-server

scripts/check_shardok_clang_tidy.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Runs the curated Shardok clang-tidy gate used by CI.
+#
+# This intentionally checks representative files instead of the whole C++ tree.
+# Keep this list low-noise; expand it as cleanup PRs make more areas tidy-clean.
+
+set -euo pipefail
+
+repo_root="$(git rev-parse --show-toplevel)"
+source "$repo_root/scripts/shardok_cpp_config.sh"
+
+files=(
+    "src/main/cpp/net/eagle0/shardok/library/ActionCost.hpp"
+    "src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp"
+)
+
+compiler_args=(
+    "-I$repo_root"
+    "$SHARDOK_CXX_STANDARD_ARG"
+)
+
+if command -v xcrun >/dev/null 2>&1; then
+    sdk_path="$(xcrun --show-sdk-path)"
+    compiler_args+=("-isysroot" "$sdk_path")
+fi
+
+"$repo_root/scripts/run-clang-tidy.sh" --verify-config
+
+"$repo_root/scripts/run-clang-tidy.sh" --quiet --warnings-as-errors="*" "${files[@]}" -- "${compiler_args[@]}"

scripts/deploy-blue-green.sh

@@ -241,6 +241,8 @@ main() {
     if [ -x "${WARMUP_SCRIPT}" ]; then
         if ! "${WARMUP_SCRIPT}" "localhost:${staging_port}"; then
             log_error "Warmup/smoke test failed, aborting deployment"
+            log_error "Recent eagle-${staging} logs:"
+            docker logs "eagle-${staging}" --tail 200 2>&1 || true
             docker compose -f "${COMPOSE_FILE}" stop "eagle-${staging}"
             cleanup_markers_on_failure "eagle-${active}"
             exit 1

scripts/notarize_submit.sh

@@ -32,23 +32,33 @@ echo "=== Creating ZIP for notarization: $ZIP_PATH ===" >&2
 ditto -c -k --keepParent "$APP_PATH" "$ZIP_PATH"
 
 echo "=== Submitting to Apple for notarization ===" >&2
+set +e
 SUBMIT_OUTPUT=$(xcrun notarytool submit "$ZIP_PATH" \
     --apple-id "$APPLE_ID" \
     --password "$APP_SPECIFIC_PASSWORD" \
     --team-id "$TEAM_ID" 2>&1)
+SUBMIT_STATUS=$?
+set -e
 
 echo "$SUBMIT_OUTPUT" >&2
 
+if [ "$SUBMIT_STATUS" -ne 0 ]; then
+    rm -f "$ZIP_PATH"
+    echo "ERROR: notarytool submit failed with exit code $SUBMIT_STATUS" >&2
+    exit "$SUBMIT_STATUS"
+fi
+
 # Extract submission ID
-SUBMISSION_ID=$(echo "$SUBMIT_OUTPUT" | grep "id:" | head -1 | awk '{print $2}')
+SUBMISSION_ID=$(echo "$SUBMIT_OUTPUT" | awk '/^[[:space:]]*id:/ {print $2; exit}')
 
 if [ -z "$SUBMISSION_ID" ]; then
+    rm -f "$ZIP_PATH"
     echo "ERROR: Failed to get submission ID" >&2
     exit 1
 fi
 
 # Clean up the zip
-rm "$ZIP_PATH"
+rm -f "$ZIP_PATH"
 
 echo "Submission ID: $SUBMISSION_ID" >&2
 

scripts/run-clang-tidy.sh

@@ -10,13 +10,14 @@ set -e
 export PATH="/opt/homebrew/bin:/usr/local/bin:$PATH"
 
 repo_root="$(git rev-parse --show-toplevel)"
+source "$repo_root/scripts/shardok_cpp_config.sh"
 
 if [ "$#" -eq 0 ]; then
     echo "Usage: scripts/run-clang-tidy.sh [clang-tidy args] <files> [-- <compiler args>]"
     echo ""
     echo "Examples:"
     echo "  scripts/run-clang-tidy.sh --verify-config"
-    echo "  scripts/run-clang-tidy.sh src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp -- -I$repo_root -std=c++23"
+    echo "  scripts/run-clang-tidy.sh src/main/cpp/net/eagle0/shardok/library/CombatDamage.hpp -- -I$repo_root $SHARDOK_CXX_STANDARD_ARG"
     exit 2
 fi
 

scripts/shardok_cpp_config.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Shared C++ settings for shell scripts that invoke Shardok tooling outside Bazel.
+
+SHARDOK_CXX_STANDARD="c++23"
+SHARDOK_CXX_STANDARD_ARG="-std=${SHARDOK_CXX_STANDARD}"

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

@@ -28,7 +28,7 @@ static inline auto HashBuffer(const uint8_t* data, size_t size) -> uint64_t {
 
     // Process 8 bytes at a time
     while (data + 8 <= end) {
-        uint64_t word;
+        uint64_t word = 0;
         // Use memcpy to avoid alignment issues and let compiler optimize
         __builtin_memcpy(&word, data, sizeof(word));
         hash ^= word;

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

@@ -9,6 +9,7 @@
 #include <bit>
 #include <cstdint>
 #include <cstdlib>
+#include <iterator>
 
 #define ITERABLE_BITSET_INDEX_CHECKS false
 
@@ -104,9 +105,11 @@ public:
 
     class Iter {
     public:
+        using iterator_category = std::forward_iterator_tag;
+        using difference_type = std::ptrdiff_t;
         using value_type = size_t;
-        using pointer = size_t*;
-        using reference = size_t&;
+        using pointer = void;
+        using reference = size_t;
 
     private:
         size_t storeIndex;
@@ -142,13 +145,20 @@ public:
         auto operator!=(const Iter& rhs) const -> bool {
             return storeIndex != rhs.storeIndex || bitIndex != rhs.bitIndex;
         }
-        void operator++() {
+        auto operator++() -> Iter& {
             bitIndex++;
             if (bitIndex >= STORE_BITS) {
                 storeIndex++;
                 bitIndex = 0;
             }
             ToNext();
+            return *this;
+        }
+
+        auto operator++(int) -> Iter {
+            Iter previous = *this;
+            ++(*this);
+            return previous;
         }
 
         auto operator*() const -> size_t { return (storeIndex << BIT_SHIFT) + bitIndex; }

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

@@ -8,7 +8,9 @@
 
 #include "RandomGenerator.hpp"
 
+#include <algorithm>
 #include <ctime>
+#include <stdexcept>
 
 constexpr double kOpenEndedHighThreshold = 95.0;
 constexpr double kOpenEndedLowThreshold = 5.0;
@@ -67,7 +69,8 @@ auto RandomGenerator::ReverseOpenEndedPercentile() -> double {
 }
 
 auto RandomGenerator::IntBetween(const int min, const int max) -> int {
-    return int(DoubleZeroToOne() * (max - min)) + min;
+    if (min >= max) { throw std::invalid_argument("random integer range must be non-empty"); }
+    return std::min(int(DoubleZeroToOne() * (max - min)) + min, max - 1);
 }
 
 auto RandomGenerator::IntBelow(const int max) -> int { return IntBetween(0, max); }
@@ -94,6 +97,7 @@ StdLibraryGenerator::StdLibraryGenerator(const std::mt19937_64::result_type seed
 }
 
 auto StdLibraryGenerator::IntBetween(const int min, const int max) -> int {
+    if (min >= max) { throw std::invalid_argument("random integer range must be non-empty"); }
     std::uniform_int_distribution<int> unifInt(min, max - 1);
     return unifInt(engine);
 }

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

@@ -12,6 +12,7 @@
 #include <cstddef>
 #include <memory>
 #include <random>
+#include <stdexcept>
 #include <vector>
 
 class RandomGenerator;
@@ -41,6 +42,7 @@ public:
 
     template<class T>
     auto RandomElement(const std::vector<T>& vec) -> T {
+        if (vec.empty()) { throw std::invalid_argument("cannot choose from an empty vector"); }
         return vec.at(static_cast<std::size_t>(IntBelow(static_cast<int>(vec.size()))));
     }
 

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

@@ -9,7 +9,9 @@
 #ifndef EAGLE0_COMMON_SEQUENCE_RANDOM_GENERATOR_HPP
 #define EAGLE0_COMMON_SEQUENCE_RANDOM_GENERATOR_HPP
 
+#include <cmath>
 #include <memory>
+#include <stdexcept>
 #include <utility>
 #include <vector>
 
@@ -29,14 +31,24 @@ private:
     size_t position = 0;
 
     auto DoubleZeroToOne() -> double override {
+        if (position >= sequence.size()) { position = 0; }
         const double nextVal = sequence.at(position);
         position++;
-        if (position >= sequence.size()) { position = 0; }
         return nextVal;
     }
 
 public:
-    explicit SequenceRandomGenerator(std::vector<double> s) : sequence(std::move(s)) {}
+    explicit SequenceRandomGenerator(std::vector<double> s) : sequence(std::move(s)) {
+        if (sequence.empty()) {
+            throw std::invalid_argument("sequence random generator requires at least one value");
+        }
+        for (const double value : sequence) {
+            if (!std::isfinite(value) || value < 0.0 || value > 1.0) {
+                throw std::invalid_argument(
+                        "sequence random generator values must be between 0 and 1");
+            }
+        }
+    }
     static auto WithSequence(const std::vector<double>& s)
             -> std::shared_ptr<SequenceRandomGenerator> {
         return std::make_shared<SequenceRandomGenerator>(s);

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

@@ -9,6 +9,7 @@ namespace shardok {
 using Coords = net::eagle0::shardok::storage::fb::Coords;
 
 constexpr double kDefaultMorale = 50.0;
+constexpr float kExplicitMoraleSentinel = -1.0f;
 
 auto ConvertBattalion(const net::eagle0::common::CommonBattalion &battalion) -> Battalion {
     Battalion shardokBattalion{};
@@ -18,6 +19,10 @@ auto ConvertBattalion(const net::eagle0::common::CommonBattalion &battalion) ->
     shardokBattalion.mutate_type(
             static_cast<net::eagle0::shardok::storage::fb::BattalionTypeId>(battalion.type()));
     shardokBattalion.mutate_morale(kDefaultMorale);
+    if (battalion.has_morale()) {
+        shardokBattalion.mutate_morale(static_cast<float>(battalion.morale()));
+        shardokBattalion.mutate_base_morale(kExplicitMoraleSentinel);
+    }
     shardokBattalion.mutate_armament(static_cast<float>(battalion.armament()));
     shardokBattalion.mutate_training(static_cast<float>(battalion.training()));
 
@@ -125,4 +130,4 @@ auto ConvertUnit(
     return shardokUnit;
 }
 
-}  // namespace shardok
+}  // namespace shardok

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

@@ -9,18 +9,24 @@
 #ifndef EAGLE0_COMMON_BYTE_VECTOR_HPP
 #define EAGLE0_COMMON_BYTE_VECTOR_HPP
 
+#include <charconv>
 #include <cstdint>
 #include <cstring>
 #include <fstream>
-#include <sstream>
+#include <initializer_list>
 #include <stdexcept>
 #include <string>
+#include <string_view>
+#include <utility>
 #include <vector>
 
 using std::string;
 using std::vector;
 
-class byte_vector : public vector<uint8_t> {
+class byte_vector {
+private:
+    std::vector<uint8_t> bytes_;
+
 public:
     class HexException : public std::exception {
         const std::string description;
@@ -35,60 +41,78 @@ public:
     };
 
 private:
-    static auto HexNibbleToValue(const char nibble) -> uint8_t {
-        if (nibble >= '0' && nibble <= '9') {
-            return uint8_t(nibble - '0');
-        } else if (nibble >= 'A' && nibble <= 'F') {
-            return uint8_t(nibble - 'A' + 10);
-        } else if (nibble >= 'a' && nibble <= 'f') {
-            return uint8_t(nibble - 'a' + 10);
+    static auto HexCharsToByte(const std::string_view digits) -> uint8_t {
+        unsigned int parsedByte = 0;
+        const auto [ptr, ec] =
+                std::from_chars(digits.data(), digits.data() + digits.size(), parsedByte, 16);
+        if (ec != std::errc() || ptr != digits.data() + digits.size()) {
+            throw HexException(ptr == digits.data() + digits.size() ? digits.back() : *ptr);
         }
-        throw HexException(nibble);
-    }
-
-    static auto HexCharsToByte(std::istringstream& str) -> uint8_t {
-        uint8_t b = 0;
-        char c = 0;
-        str >> c;
-        b |= (HexNibbleToValue(c) << 4u);
-        str >> c;
-        b |= HexNibbleToValue(c);
-        return b;
+        return static_cast<uint8_t>(parsedByte);
     }
 
 public:
     byte_vector() = default;
-    byte_vector(const std::initializer_list<uint8_t> list) : vector<uint8_t>(list) {}
+    byte_vector(const std::initializer_list<uint8_t> list) : bytes_(list) {}
     template<class InputIt>
-    byte_vector(InputIt begin, InputIt end) : vector<uint8_t>(begin, end) {}
+    byte_vector(InputIt begin, InputIt end) : bytes_(begin, end) {}
     byte_vector(const byte_vector& rhs) = default;
-    explicit byte_vector(const std::string& s) : byte_vector(s.begin(), s.end()) {}
-    explicit byte_vector(const size_t size) : vector<uint8_t>(size) {}
-    explicit byte_vector(void* data, const size_t size) : vector<uint8_t>(size) {
-        this->assign((uint8_t*)data, (uint8_t*)data + size);
+    byte_vector(byte_vector&& rhs) noexcept = default;
+    explicit byte_vector(const std::string& s) : bytes_(s.begin(), s.end()) {}
+    explicit byte_vector(std::vector<uint8_t> bytes) : bytes_(std::move(bytes)) {}
+    explicit byte_vector(const size_t size) : bytes_(size) {}
+    explicit byte_vector(const void* data, const size_t size) {
+        auto* bytes = static_cast<const uint8_t*>(data);
+        bytes_.assign(bytes, bytes + size);
     }
 
-    auto operator==(const vector<uint8_t>& vec) -> bool {
-        if (this->size() != vec.size()) return false;
-        for (size_t i = 0; i < size(); i++) {
-            if ((*this)[i] != vec[i]) return false;
-        }
-        return true;
+    auto operator=(const byte_vector& rhs) -> byte_vector& = default;
+    auto operator=(byte_vector&& rhs) noexcept -> byte_vector& = default;
+
+    [[nodiscard]] auto operator==(const std::vector<uint8_t>& vec) const -> bool {
+        return bytes_ == vec;
     }
+    [[nodiscard]] auto operator==(const byte_vector& vec) const -> bool {
+        return bytes_ == vec.bytes_;
+    }
+
+    [[nodiscard]] auto data() -> uint8_t* { return bytes_.data(); }
+    [[nodiscard]] auto data() const -> const uint8_t* { return bytes_.data(); }
+    [[nodiscard]] auto size() const -> size_t { return bytes_.size(); }
+    [[nodiscard]] auto empty() const -> bool { return bytes_.empty(); }
+    void reserve(const size_t count) { bytes_.reserve(count); }
+    void resize(const size_t count) { bytes_.resize(count); }
+    void swap(byte_vector& other) noexcept { bytes_.swap(other.bytes_); }
+
+    [[nodiscard]] auto begin() -> std::vector<uint8_t>::iterator { return bytes_.begin(); }
+    [[nodiscard]] auto begin() const -> std::vector<uint8_t>::const_iterator {
+        return bytes_.begin();
+    }
+    [[nodiscard]] auto end() -> std::vector<uint8_t>::iterator { return bytes_.end(); }
+    [[nodiscard]] auto end() const -> std::vector<uint8_t>::const_iterator { return bytes_.end(); }
+    [[nodiscard]] auto cbegin() const -> std::vector<uint8_t>::const_iterator {
+        return bytes_.cbegin();
+    }
+    [[nodiscard]] auto cend() const -> std::vector<uint8_t>::const_iterator {
+        return bytes_.cend();
+    }
+
+    [[nodiscard]] auto operator[](const size_t index) -> uint8_t& { return bytes_[index]; }
+    [[nodiscard]] auto operator[](const size_t index) const -> uint8_t { return bytes_[index]; }
 
     auto append(const char* bytes, const size_t length) {
-        const auto previousSize = this->size();
-        this->resize(previousSize + length);
-        std::memcpy(this->data() + previousSize, bytes, length);
+        const auto previousSize = size();
+        resize(previousSize + length);
+        std::memcpy(data() + previousSize, bytes, length);
     }
 
     template<class T>
     auto append(const T* elts, const size_t count) {
-        append((char*)elts, count * sizeof(T));
+        append(reinterpret_cast<const char*>(elts), count * sizeof(T));
     }
 
     template<class T>
-    auto append(const vector<T> elts) {
+    auto append(const vector<T>& elts) {
         append(elts.data(), elts.size());
     }
 
@@ -98,7 +122,7 @@ public:
     }
 
     auto operator+=(const uint8_t c) -> byte_vector& {
-        this->insert(end(), c);
+        bytes_.push_back(c);
         return *this;
     }
 
@@ -111,7 +135,7 @@ public:
 
     template<class Iterable>
     auto operator+=(const Iterable& rhs) -> byte_vector& {
-        this->insert(end(), rhs.cbegin(), rhs.cend());
+        bytes_.insert(end(), rhs.cbegin(), rhs.cend());
         return *this;
     }
 
@@ -119,7 +143,7 @@ public:
         if (size() < 8) {
             uint64_t total = 0;
             for (size_t i = 0; i < size(); i++) {
-                total <<= 8u;
+                total <<= 8U;
                 total += (*this)[i];
             }
             return total;
@@ -128,9 +152,9 @@ public:
         uint64_t firstBytes = 0;
         uint64_t lastBytes = 0;
         for (unsigned i = 0; i < 8; i++) {
-            firstBytes <<= 8u;
+            firstBytes <<= 8U;
             firstBytes += (*this)[i];
-            lastBytes <<= 8u;
+            lastBytes <<= 8U;
             lastBytes += (*this)[i];
         }
 
@@ -141,8 +165,8 @@ public:
         std::ifstream inputFileStream(path, std::ios::binary | std::ios::ate);
         const std::streamsize size = inputFileStream.tellg();
         inputFileStream.seekg(0, std::ios::beg);
-        this->resize((size_t(size)));
-        inputFileStream.read((char*)this->data(), size);
+        this->resize(static_cast<size_t>(size));
+        inputFileStream.read(reinterpret_cast<char*>(this->data()), size);
         return *this;
     }
 
@@ -153,34 +177,41 @@ public:
         }
         const std::streamsize size = inputFileStream.tellg();
         inputFileStream.seekg(0, std::ios::beg);
-        byte_vector serializedGame((size_t(size)));
-        inputFileStream.read((char*)serializedGame.data(), size);
+        byte_vector serializedGame(static_cast<size_t>(size));
+        inputFileStream.read(reinterpret_cast<char*>(serializedGame.data()), size);
         return serializedGame;
     }
 
     static auto FromHex(const char* hexString) -> byte_vector { return FromHex(string(hexString)); }
 
-    static auto FromHex(string hexString) -> byte_vector {
-        if (hexString[0] == '0' && (hexString[1] == 'x' || hexString[1] == 'X')) {
-            hexString = string(hexString.begin() + 1, hexString.end());
+    static auto FromHex(const string& hexString) -> byte_vector {
+        std::string_view digits(hexString);
+        if (digits.starts_with("0x") || digits.starts_with("0X")) {
+            digits.remove_prefix(2);
+        } else if (digits.starts_with("x") || digits.starts_with("X")) {
+            digits.remove_prefix(1);
         }
-        if (hexString[0] == 'x' || hexString[0] == 'X') {
-            hexString = string(hexString.begin() + 1, hexString.end());
-        }
-        byte_vector vec;
-        const size_t len = hexString.size();
-        vec.reserve(len / 2);
-        std::istringstream hexStream(hexString);
 
-        while (size_t(hexStream.tellg()) < len) { vec += HexCharsToByte(hexStream); }
+        if (digits.size() % 2 != 0) { throw HexException(digits.empty() ? '\0' : digits.back()); }
+
+        byte_vector vec;
+        vec.reserve(digits.size() / 2);
+
+        for (size_t index = 0; index < digits.size(); index += 2) {
+            vec += HexCharsToByte(digits.substr(index, 2));
+        }
         return vec;
     }
 
     explicit operator std::string() const { return std::string(begin(), end()); }
 };
 
-inline auto operator<<(std::ostream& ostr, byte_vector vec) -> std::ostream& {
-    ostr.write((char*)vec.data(), (std::streamsize)vec.size());
+inline auto operator==(const std::vector<uint8_t>& lhs, const byte_vector& rhs) -> bool {
+    return rhs == lhs;
+}
+
+inline auto operator<<(std::ostream& ostr, const byte_vector& vec) -> std::ostream& {
+    ostr.write(reinterpret_cast<const char*>(vec.data()), static_cast<std::streamsize>(vec.size()));
     return ostr;
 }
 

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

@@ -209,8 +209,8 @@ auto AbstractMCTSAI::BuildMCTSTree(
             }));
         }
 
-        // Wait for all threads to complete
-        for (auto& future : futures) { future.wait(); }
+        // Wait for all threads to complete and propagate worker exceptions.
+        for (auto& future : futures) { future.get(); }
     } else {
         // Single-threaded MCTS
         while (std::chrono::steady_clock::now() < deadline) {

src/main/cpp/net/eagle0/shardok/HexMapMigrator.cpp

@@ -37,7 +37,7 @@ int main(const int argc, char** argv) {
 
 void ModifyMap(HexMapProto& map) {
     const int terrainCount = map.terrain_size();
-    for (int i = 0; i < terrainCount; i++) {
+    for (int i = 0; i < terrainCount; ++i) {
         const auto existingTerrainType = map.terrain(i).type();
         const auto newTerrain =
                 static_cast<net::eagle0::shardok::common::Terrain_Type>(existingTerrainType + 2);

src/main/cpp/net/eagle0/shardok/MapInfoCalculator.cpp

@@ -37,7 +37,7 @@ auto CalculateMap(
             .name = mapName,
             .positionsRequiringCrossing = {}};
 
-    for (std::size_t i = 0; i < hexMap->attacker_starting_positions()->size(); i++) {
+    for (std::size_t i = 0; i < hexMap->attacker_starting_positions()->size(); ++i) {
         const auto* positionList = hexMap->attacker_starting_positions()->Get(i);
         const auto* positions = positionList->positions();
         if (positions->empty()) continue;

src/main/cpp/net/eagle0/shardok/MapInfoCalculator.hpp

@@ -18,7 +18,7 @@ struct alignas(64) OneMapInfo {
     std::map<int, int> positionsRequiringCrossing;
 };
 
-auto CalculateMap(
+[[nodiscard]] auto CalculateMap(
         const std::string& mapName,
         const std::shared_ptr<shardok::ActionPointDistancesCache>& apdCache,
         const shardok::BattalionTypeSPtr& battalionType) -> OneMapInfo;

src/main/cpp/net/eagle0/shardok/RandomBattleRunner.cpp

@@ -54,7 +54,7 @@ void runBattle(const std::vector<shardok::Unit>& units) {
     const auto p1UnitCount = randInt(1, static_cast<int>(maxP1UnitCount));
     std::vector<shardok::Unit> p1Units{};
     p1Units.reserve(p1UnitCount);
-    for (int i = 0; i < p1UnitCount; i++) {
+    for (int i = 0; i < p1UnitCount; ++i) {
         auto unit = units[i];
         unit.mutate_player_id(0);
         p1Units.push_back(std::move(unit));
@@ -64,7 +64,7 @@ void runBattle(const std::vector<shardok::Unit>& units) {
     const auto p2UnitCount = randInt(1, static_cast<int>(maxP2UnitCount));
     std::vector<shardok::Unit> p2Units{};
     p2Units.reserve(p2UnitCount);
-    for (int i = p1UnitCount; i < p1UnitCount + p2UnitCount; i++) {
+    for (int i = p1UnitCount; i < p1UnitCount + p2UnitCount; ++i) {
         auto unit = units[i];
         unit.mutate_player_id(1);
         p2Units.push_back(std::move(unit));
@@ -158,7 +158,7 @@ auto main(int /*argc*/, char** argv) -> int {
 
     std::array<std::thread, THREAD_COUNT> threads;
 
-    for (int i = 0; i < THREAD_COUNT; i++) {
+    for (int i = 0; i < THREAD_COUNT; ++i) {
         threads[i] = std::thread(runBattlesThread, randomUnits);
     }
 

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

@@ -25,25 +25,44 @@ DIST_T NormalizedCostWhenBraving(const DIST_T cost) {
 
 struct TargetAndDistance {
     Coords target;
+    size_t targetIndex;
     CoordsSet attackLocations;
     double targetPower;
     DIST_T distance;
 
-    TargetAndDistance(const Coords& t, const CoordsSet& al, const double tp, const DIST_T d)
+    TargetAndDistance(
+            const Coords& t,
+            const size_t ti,
+            const CoordsSet& al,
+            const double tp,
+            const DIST_T d)
         : target(t),
+          targetIndex(ti),
           attackLocations(al),
           targetPower(tp),
           distance(d) {}
 };
 
+auto CoordsIndex(const Coords& coords, const int columnCount) {
+    return coords.row() * columnCount + coords.column();
+}
+
+auto CoordsFromIndex(const size_t index, const int columnCount) -> Coords {
+    return Coords(
+            static_cast<int8_t>(index / static_cast<size_t>(columnCount)),
+            static_cast<int8_t>(index % static_cast<size_t>(columnCount)));
+}
+
 auto MinDistance(
         const Coords& start,
         const CoordsSet& destinations,
         const ActionPointDistances* apd) -> DIST_T {
     DIST_T minDistance = ActionPointDistances::IMPOSSIBLE;
+    const int startIndex = CoordsIndex(start, destinations.ColumnCount());
 
-    for (const Coords& dest : destinations) {
-        if (const DIST_T distance = apd->Distance(start, dest); distance < minDistance) {
+    for (const auto destIndex : destinations.indexIterator()) {
+        if (const DIST_T distance = apd->Distance(startIndex, static_cast<int>(destIndex));
+            distance < minDistance) {
             minDistance = distance;
         }
     }
@@ -113,10 +132,6 @@ auto EffectiveDistance(
 
 auto Power(const Unit* unit) -> double { return unit->battalion().size(); }
 
-auto CoordsIndex(const Coords& coords, const int columnCount) {
-    return coords.row() * columnCount + coords.column();
-}
-
 // Chooses a list of targets in priority order for each unit.
 auto GenerateTargetPriorities(
         const vector<const Unit*>& occupants,
@@ -163,10 +178,10 @@ auto GenerateTargetPriorities(
             bravingApd = apdCache->GetRaw(map, mapId, battType, true, braveWaterCost);
         }
 
-        for (const Coords& targetLocation : targets) {
-            const auto coordsIndex = CoordsIndex(targetLocation, cc);
-            const auto& occupant = occupants[coordsIndex];
+        for (const auto targetIndex : targets.indexIterator()) {
+            const auto& occupant = occupants[targetIndex];
 
+            const Coords targetLocation = CoordsFromIndex(targetIndex, cc);
             const auto& attackLocations = alCache->CachedLocations(targetLocation, isLateGame);
 
             if (occupant && occupant->player_id() != attackerId) {
@@ -179,12 +194,14 @@ auto GenerateTargetPriorities(
 
                     targetsWithDistance.emplace_back(
                             targetLocation,
+                            targetIndex,
                             attackLocsForUnit,
                             occupantPower,
                             distance);
                 } else {
                     targetsWithDistance.emplace_back(
                             targetLocation,
+                            targetIndex,
                             attackLocations.LocationsWithEnemyInRange(unit),
                             occupantPower,
                             ActionPointDistances::IMPOSSIBLE);
@@ -195,13 +212,11 @@ auto GenerateTargetPriorities(
         // Sort by distance
         std::ranges::sort(
                 targetsWithDistance,
-                [&powerAttackingEachTarget,
-                 cc](const TargetAndDistance& left, const TargetAndDistance& right) {
-                    const auto leftIndex = CoordsIndex(left.target, cc);
-                    const auto rightIndex = CoordsIndex(right.target, cc);
-
-                    const double powerAttackingLeft = powerAttackingEachTarget[leftIndex];
-                    const double powerAttackingRight = powerAttackingEachTarget[rightIndex];
+                [&powerAttackingEachTarget](
+                        const TargetAndDistance& left,
+                        const TargetAndDistance& right) {
+                    const double powerAttackingLeft = powerAttackingEachTarget[left.targetIndex];
+                    const double powerAttackingRight = powerAttackingEachTarget[right.targetIndex];
 
                     const bool leftAlreadyOverwhelmed =
                             powerAttackingLeft >= kOverpowerRatio * left.targetPower;
@@ -215,8 +230,7 @@ auto GenerateTargetPriorities(
                 });
 
         if (!targetsWithDistance.empty()) {
-            powerAttackingEachTarget[CoordsIndex(targetsWithDistance.front().target, cc)] +=
-                    Power(unit);
+            powerAttackingEachTarget[targetsWithDistance.front().targetIndex] += Power(unit);
         }
 
         tpl.priorityOrder.reserve(targetsWithDistance.size());

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

@@ -27,7 +27,7 @@ struct TargetAndAttackLocations {
     Coords target;
     CoordsSet attackLocations;
 
-    auto operator==(const TargetAndAttackLocations& rhs) const -> bool = default;
+    [[nodiscard]] auto operator==(const TargetAndAttackLocations& rhs) const -> bool = default;
 };
 
 struct TargetPriorityList {
@@ -39,7 +39,7 @@ struct TargetPriorityList {
           priorityOrder(po) {}
 };
 
-auto EffectiveDistance(
+[[nodiscard]] auto EffectiveDistance(
         const Unit* unit,
         const HexMap* map,
         const AttackLocations& attackLocations,
@@ -47,7 +47,7 @@ auto EffectiveDistance(
         const BattalionTypeGetter& battalionTypeGetter,
         ActionPoints braveWaterCost) -> DIST_T;
 
-auto EffectiveDistance(
+[[nodiscard]] auto EffectiveDistance(
         const Unit* unit,
         const HexMap* map,
         const CoordsSet& locations,
@@ -55,14 +55,14 @@ auto EffectiveDistance(
         const BattalionTypeGetter& battalionTypeGetter,
         ActionPoints braveWaterCost) -> DIST_T;
 
-auto EffectiveDistance(
+[[nodiscard]] auto EffectiveDistance(
         const Unit* unit,
         const ActionPointDistances* notBravingApd,
         const ActionPointDistances* bravingApd,
         const CoordsSet& locations) -> DIST_T;
 
 // Chooses a list of targets in priority order for each unit.
-auto GenerateTargetPriorities(
+[[nodiscard]] auto GenerateTargetPriorities(
         const std::vector<const Unit*>& occupants,
         const HexMap* map,
         const CoordsSet& targets,

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

@@ -53,8 +53,8 @@ AttackLocationsCache::AttackLocationsCache(const HexMap *hexMap, const SettingsG
 
     auto emptySet = CoordsSet(columnCount, rowCount);
 
-    for (MapIndex r = 0; r < hexMap->row_count(); r++) {
-        for (MapIndex c = 0; c < hexMap->column_count(); c++) {
+    for (MapIndex r = 0; r < hexMap->row_count(); ++r) {
+        for (MapIndex c = 0; c < hexMap->column_count(); ++c) {
             auto location = Coords(r, c);
             const auto terrain = GetTerrain(hexMap, location);
 
@@ -114,8 +114,7 @@ auto AttackLocationsCache::CachedLocations(const CoordsSet &targets, const bool
         -> AttackLocations {
     AttackLocations al(rowCount, columnCount);
 
-    for (const auto &target : targets) {
-        const int index = target.row() * columnCount + target.column();
+    for (const auto index : targets.indexIterator()) {
         if (lateGame) {
             al += lateGameLocations[index];
         } else {
@@ -137,4 +136,4 @@ auto AttackLocationsCache::CachedLocations(const vector<const Unit *> &enemies,
     return CachedLocations(targets, lateGame);
 }
 
-}  // namespace shardok
+}  // namespace shardok

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

@@ -11,6 +11,8 @@
 #include <iomanip>
 #include <iostream>
 #include <limits>
+#include <sstream>
+#include <stdexcept>
 
 #include "AICommandFilter.hpp"
 #include "TranspositionTable.hpp"
@@ -21,16 +23,49 @@
 
 namespace shardok {
 
-// No need to forward declare internal functions - use the public interface instead
-
-// Helper constants and static variables
-static const std::vector<double> kAverageSequence = {0.5};
-static const auto kAverageGenerator = std::make_shared<SequenceRandomGenerator>(kAverageSequence);
-
 constexpr bool kMultithread = true;
 constexpr bool kLogging = false;
 
-// Helper function to determine if a command type is deterministic
+[[nodiscard]] static auto AverageGenerator() -> std::shared_ptr<SequenceRandomGenerator> {
+    return std::make_shared<SequenceRandomGenerator>(std::vector{0.5});
+}
+
+[[nodiscard]] static auto DescribeCommandForLog(const CommandSPtr& command) -> std::string {
+    if (!command) { return "<null command>"; }
+
+    std::ostringstream out;
+    out << "type=" << command->GetCommandType()
+        << " player=" << static_cast<int>(command->GetPlayerId())
+        << " actor=" << command->GetActorUnitId() << " target=("
+        << static_cast<int>(command->GetTargetRow()) << ','
+        << static_cast<int>(command->GetTargetColumn()) << ')';
+
+    if (command->HasOdds()) { out << " odds_percentile=" << command->GetOddsPercentile(); }
+
+    return out.str();
+}
+
+[[nodiscard]] static auto DescribeCommandAt(
+        const CommandListSPtr& commands,
+        const size_t commandIndex) -> std::string {
+    if (!commands) { return "command=<null command list>"; }
+    if (commandIndex >= commands->size()) {
+        std::ostringstream out;
+        out << "command=<index " << commandIndex << " out of " << commands->size() << ">";
+        return out.str();
+    }
+
+    std::ostringstream out;
+    out << "command={" << DescribeCommandForLog(commands->at(commandIndex)) << '}';
+    return out.str();
+}
+
+[[nodiscard]] static auto WithExceptionContext(
+        const std::string& context,
+        const std::exception& exception) -> std::runtime_error {
+    return std::runtime_error(context + ": " + exception.what());
+}
+
 static auto IsDeterministic(const CommandType type) -> bool {
     switch (type) {
         case net::eagle0::shardok::common::MOVE_COMMAND:
@@ -43,13 +78,11 @@ static auto IsDeterministic(const CommandType type) -> bool {
         case net::eagle0::shardok::common::PLACE_HIDDEN_UNIT_COMMAND:
         case net::eagle0::shardok::common::UNIT_STOP_COMMAND:
         case net::eagle0::shardok::common::UNIT_REST_COMMAND:
-        case net::eagle0::shardok::common::FLEE_COMMAND:
         case net::eagle0::shardok::common::REINFORCE_COMMAND:
         case net::eagle0::shardok::common::RETREAT_COMMAND:
         case net::eagle0::shardok::common::END_PLAYER_SETUP_COMMAND:
         case net::eagle0::shardok::common::HIDE_COMMAND:
         case net::eagle0::shardok::common::FORTIFY_COMMAND:
-        case net::eagle0::shardok::common::BECOME_OUTLAW_COMMAND:
         case net::eagle0::shardok::common::HOLY_WAVE_COMMAND:
         case net::eagle0::shardok::common::EVACUATE_PRISONERS_COMMAND:
         case net::eagle0::shardok::common::REPAIR_COMMAND: return true;
@@ -63,7 +96,14 @@ static auto RandomnessSampleForRepeat(const int repeatIteration, const int maxRe
     return static_cast<double>(repeatIteration) / static_cast<double>(maxRepeatCount - 1);
 }
 
-// Helper function to sort commands by score
+static auto SuccessSampleForOdds(const double successChance) -> double {
+    return successChance / 2.0;
+}
+
+static auto FailureSampleForOdds(const double successChance) -> double {
+    return successChance + ((1.0 - successChance) / 2.0);
+}
+
 static auto CommandSorter(
         const AICommandEvaluator::IndexAndScore& l,
         const AICommandEvaluator::IndexAndScore& r) -> bool {
@@ -83,7 +123,7 @@ AICommandEvaluator::AICommandEvaluator(
         BattalionTypeGetter battalionTypeGetter)
     : scorer_(scorer),
       apdCache_(apdCache),
-      battalionTypeGetter_(std::move(battalionTypeGetter)) {}  // Move the function object
+      battalionTypeGetter_(std::move(battalionTypeGetter)) {}
 
 auto AICommandEvaluator::PerformLookahead(
         const PlayerId pid,
@@ -138,17 +178,34 @@ auto AICommandEvaluator::PerformLookahead(
                 std::launch::deferred,
                 [bestCommandFuture = std::move(bestCommandFuture),
                  innerEngine,
+                 nextCommands,
                  pid,
                  nextUtility,
                  remainingLookahead]() mutable -> EvaluationResult {
-                    const auto bestCommand = bestCommandFuture.get();
+                    IndexAndScore bestCommand;
+                    try {
+                        bestCommand = bestCommandFuture.get();
+                    } catch (const std::exception& e) {
+                        std::ostringstream context;
+                        context << "AI PerformLookahead failed while resolving best command"
+                                << " player=" << static_cast<int>(pid)
+                                << " remaining_lookahead=" << remainingLookahead
+                                << " next_command_count=" << nextCommands->size();
+                        throw WithExceptionContext(context.str(), e);
+                    }
                     if (!bestCommand.completed) {
                         return EvaluationResult{.score = nextUtility, .completed = false};
                     }
+                    if (bestCommand.index >= nextCommands->size()) {
+                        std::cerr << "AI lookahead produced command index " << bestCommand.index
+                                  << " with only " << nextCommands->size()
+                                  << " available commands for player " << static_cast<int>(pid)
+                                  << " at remaining lookahead " << remainingLookahead << "\n";
+                        return EvaluationResult{.score = nextUtility, .completed = false};
+                    }
 
                     ScoreValue resultScore;
-                    if (auto& nextCommand = innerEngine->GetAvailableCommandsForAIPlayer(pid)->at(
-                                bestCommand.index);
+                    if (const auto& nextCommand = nextCommands->at(bestCommand.index);
                         nextCommand->GetCommandType() !=
                         net::eagle0::shardok::common::END_TURN_COMMAND) {
                         resultScore = bestCommand.immediateScore;
@@ -199,14 +256,36 @@ auto AICommandEvaluator::EvaluateWithRandomness(
         return returnValue;
     }
 
+    const auto guessedCommands = guessedEngine.GetAvailableCommandsForAIPlayer(pid);
     auto innerEngine = std::make_shared<ShardokEngine>(guessedEngine, false);
-    innerEngine->PostCommand(pid, commandIndex, randomGenerator);
+    try {
+        innerEngine->PostCommand(pid, commandIndex, randomGenerator);
+    } catch (const std::exception& e) {
+        std::ostringstream context;
+        context << "AI EvaluateWithRandomness failed while posting simulated command"
+                << " player=" << static_cast<int>(pid) << " command_index=" << commandIndex
+                << " guessed_command_count=" << guessedCommands->size()
+                << " remaining_lookahead=" << remainingLookahead << ' '
+                << DescribeCommandAt(guessedCommands, commandIndex);
+        throw WithExceptionContext(context.str(), e);
+    }
 
-    auto innerUtility = scorer_.GuessedStateScore(
-            isDefender,
-            innerEngine->GetCurrentGameState(),
-            attackerStrategy,
-            allCastleCoords);
+    ScoreValue innerUtility;
+    try {
+        innerUtility = scorer_.GuessedStateScore(
+                isDefender,
+                innerEngine->GetCurrentGameState(),
+                attackerStrategy,
+                allCastleCoords);
+    } catch (const std::exception& e) {
+        std::ostringstream context;
+        context << "AI EvaluateWithRandomness failed while scoring simulated state"
+                << " player=" << static_cast<int>(pid) << " command_index=" << commandIndex
+                << " guessed_command_count=" << guessedCommands->size()
+                << " remaining_lookahead=" << remainingLookahead << ' '
+                << DescribeCommandAt(guessedCommands, commandIndex);
+        throw WithExceptionContext(context.str(), e);
+    }
 
     returnValue.immediateScore = innerUtility;
     returnValue.completed = true;
@@ -221,22 +300,33 @@ auto AICommandEvaluator::EvaluateWithRandomness(
                                 isDefender,
                                 remainingLookahead,
                                 maxRepeatCount,
+                                commandIndex,
                                 innerEngine,
                                 attackerStrategy,
                                 innerUtility,
-                                &allCastleCoords,
+                                guessedCommands,
+                                allCastleCoords,
                                 deadline]() -> EvaluationResult {
-            auto lookaheadFuture = PerformLookahead(
-                    pid,
-                    isDefender,
-                    remainingLookahead,
-                    maxRepeatCount,
-                    innerEngine,
-                    innerUtility,
-                    attackerStrategy,
-                    allCastleCoords,
-                    deadline);
-            return lookaheadFuture.get();
+            try {
+                auto lookaheadFuture = PerformLookahead(
+                        pid,
+                        isDefender,
+                        remainingLookahead,
+                        maxRepeatCount,
+                        innerEngine,
+                        innerUtility,
+                        attackerStrategy,
+                        allCastleCoords,
+                        deadline);
+                return lookaheadFuture.get();
+            } catch (const std::exception& e) {
+                std::ostringstream context;
+                context << "AI EvaluateWithRandomness failed during recursive lookahead"
+                        << " player=" << static_cast<int>(pid) << " command_index=" << commandIndex
+                        << " remaining_lookahead=" << remainingLookahead << ' '
+                        << DescribeCommandAt(guessedCommands, commandIndex);
+                throw WithExceptionContext(context.str(), e);
+            }
         };
 
         if constexpr (kMultithread) {
@@ -336,9 +426,21 @@ auto AICommandEvaluator::FindBestCommand(
 
     std::vector<CommandEvaluation> commandEvaluations(commandCount);
 
-    for (uint32_t index = 0; index < commandCount; index++) {
+    for (uint32_t index = 0; index < commandCount; ++index) {
         const auto originalIndex = filteredIndices[index];
-        const auto& guessedDescriptor = guessedDescriptors->at(originalIndex);
+        const CommandSPtr guessedDescriptor = [&] {
+            try {
+                return guessedDescriptors->at(originalIndex);
+            } catch (const std::exception& e) {
+                std::ostringstream context;
+                context << "AI FindBestCommand failed while reading filtered command"
+                        << " player=" << static_cast<int>(pid) << " filtered_index=" << index
+                        << " original_index=" << originalIndex
+                        << " guessed_command_count=" << guessedDescriptors->size()
+                        << " filtered_command_count=" << filteredIndices.size();
+                throw WithExceptionContext(context.str(), e);
+            }
+        }();
         const auto guessedCommandType = guessedDescriptor->GetCommandType();
 
         commandEvaluations[index].index = originalIndex;
@@ -356,7 +458,7 @@ auto AICommandEvaluator::FindBestCommand(
                     originalIndex,
                     remainingLookahead,
                     maxRepeatCount,
-                    kAverageGenerator,
+                    AverageGenerator(),
                     guessedEngine,
                     attackerStrategy,
                     allCastleCoords,
@@ -370,7 +472,7 @@ auto AICommandEvaluator::FindBestCommand(
             const auto successChancePercentile = guessedDescriptor->GetOddsPercentile();
             const double successChance = static_cast<double>(successChancePercentile) / 100.0;
 
-            // Success attempt uses 1.0 - (successChance / 2) as the roll
+            // Success attempt uses the midpoint of the successful percentile range.
             auto successEvaluation = EvaluateWithRandomness(
                     pid,
                     isDefender,
@@ -378,13 +480,13 @@ auto AICommandEvaluator::FindBestCommand(
                     remainingLookahead,
                     maxRepeatCount,
                     std::make_shared<SequenceRandomGenerator>(
-                            std::vector{1.0 - successChance / 2.0}),
+                            std::vector{SuccessSampleForOdds(successChance)}),
                     guessedEngine,
                     attackerStrategy,
                     allCastleCoords,
                     deadline);
 
-            // Failure attempt uses the average of (1 - successChance) and 0 as the roll
+            // Failure attempt uses the midpoint of the failing percentile range.
             auto failureEvaluation = EvaluateWithRandomness(
                     pid,
                     isDefender,
@@ -392,7 +494,7 @@ auto AICommandEvaluator::FindBestCommand(
                     remainingLookahead,
                     maxRepeatCount,
                     std::make_shared<SequenceRandomGenerator>(
-                            std::vector{(1.0 - successChance) / 2.0}),
+                            std::vector{FailureSampleForOdds(successChance)}),
                     guessedEngine,
                     attackerStrategy,
                     allCastleCoords,
@@ -423,7 +525,7 @@ auto AICommandEvaluator::FindBestCommand(
             ScoreValue sum = 0.0;
             const int sampleCount = std::max(1, maxRepeatCount);
             commandEvaluations[index].lookaheadFutures.reserve(sampleCount);
-            for (int repeatIteration = 0; repeatIteration < sampleCount; repeatIteration++) {
+            for (int repeatIteration = 0; repeatIteration < sampleCount; ++repeatIteration) {
                 // In each iteration, use a double from [0, 1] as the random roll
                 auto sequence =
                         std::vector{RandomnessSampleForRepeat(repeatIteration, sampleCount)};
@@ -460,7 +562,17 @@ auto AICommandEvaluator::FindBestCommand(
                     ScoreValue totalLookaheadScore = 0.0;
                     bool completed = eval.immediateCompleted;
                     for (auto& future : eval.lookaheadFutures) {
-                        const auto lookahead = future.get();
+                        EvaluationResult lookahead;
+                        try {
+                            lookahead = future.get();
+                        } catch (const std::exception& e) {
+                            std::ostringstream context;
+                            context << "AI FindBestCommand failed while resolving lookahead future"
+                                    << " command_index=" << eval.index
+                                    << " command_type=" << eval.type
+                                    << " lookahead_future_count=" << eval.lookaheadFutures.size();
+                            throw WithExceptionContext(context.str(), e);
+                        }
                         if (!lookahead.completed) { completed = false; }
                         totalLookaheadScore += lookahead.score;
                     }
@@ -527,7 +639,7 @@ auto AICommandEvaluator::EvaluateCommand(
                 commandIndex,
                 remainingLookahead,
                 maxRepeatCount,
-                kAverageGenerator,
+                AverageGenerator(),
                 guessedEngine,
                 attackerStrategy,
                 allCastleCoords,
@@ -546,7 +658,8 @@ auto AICommandEvaluator::EvaluateCommand(
                 commandIndex,
                 remainingLookahead,
                 maxRepeatCount,
-                std::make_shared<SequenceRandomGenerator>(std::vector{1.0 - successChance / 2.0}),
+                std::make_shared<SequenceRandomGenerator>(
+                        std::vector{SuccessSampleForOdds(successChance)}),
                 guessedEngine,
                 attackerStrategy,
                 allCastleCoords,
@@ -559,7 +672,8 @@ auto AICommandEvaluator::EvaluateCommand(
                 commandIndex,
                 remainingLookahead,
                 maxRepeatCount,
-                std::make_shared<SequenceRandomGenerator>(std::vector{(1.0 - successChance) / 2.0}),
+                std::make_shared<SequenceRandomGenerator>(
+                        std::vector{FailureSampleForOdds(successChance)}),
                 guessedEngine,
                 attackerStrategy,
                 allCastleCoords,
@@ -587,7 +701,7 @@ auto AICommandEvaluator::EvaluateCommand(
     const int sampleCount = std::max(1, maxRepeatCount);
     lookaheadFutures.reserve(sampleCount);
 
-    for (int repeatIteration = 0; repeatIteration < sampleCount; repeatIteration++) {
+    for (int repeatIteration = 0; repeatIteration < sampleCount; ++repeatIteration) {
         auto sequence = std::vector{RandomnessSampleForRepeat(repeatIteration, sampleCount)};
         auto evaluation = EvaluateWithRandomness(
                 pid,

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

@@ -78,7 +78,7 @@ public:
 private:
     const AIScoreCalculator& scorer_;
     const APDCache& apdCache_;
-    BattalionTypeGetter battalionTypeGetter_;  // Store by value
+    BattalionTypeGetter battalionTypeGetter_;
 
     struct ImmediateAndLookaheadScore {
         ScoreValue immediateScore{};

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

@@ -104,23 +104,21 @@ auto DefenderDistanceBuf(
                 pointCostToDesiredTargetWithBraving);
     }
 
-    std::sort(
-            begin(pointCosts),
-            end(pointCosts),
-            [](const WithoutAndWith &left, const WithoutAndWith &right) {
-                return left.without == right.without ? left.with < right.with
-                                                     : left.without < right.without;
-            });
+    std::ranges::sort(pointCosts, [](const WithoutAndWith &left, const WithoutAndWith &right) {
+        return left.without == right.without ? left.with < right.with
+                                             : left.without < right.without;
+    });
 
     // experiment: add dummy values to the end with very high cost, so there's never an advantage
     // to leaving a defender unit alive in a castle.
-    for (size_t i = attackerUnits.size(); i < 20; i++) { pointCosts.emplace_back(999, 999); }
+    for (size_t i = attackerUnits.size(); i < 20; ++i) { pointCosts.emplace_back(999, 999); }
 
     double sum = 0.0;
     double decr = kPerUnitDebufDecay;
     for (const WithoutAndWith &pointCost : pointCosts) {
-        const int effectiveCost =
-                (pointCost.without == 999) ? int(1.2 * pointCost.with) : pointCost.without;
+        const int effectiveCost = (pointCost.without == 999)
+                                          ? static_cast<int>(1.2 * pointCost.with)
+                                          : pointCost.without;
         sum += decr / (effectiveCost + 1);
         decr *= kPerUnitDebufDecay;
     }

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

@@ -13,7 +13,7 @@
 
 namespace shardok {
 
-auto DefenderDistanceBuf(
+[[nodiscard]] auto DefenderDistanceBuf(
         const Coords &defenderLocation,
         const HexMap *hexMap,
         const MapId &mapId,

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

@@ -12,7 +12,7 @@
 
 namespace shardok {
 
-inline auto CurrentAIExperimentId() -> int {
+[[nodiscard]] inline auto CurrentAIExperimentId() -> int {
     const char* rawValue = std::getenv("SHARDOK_SCORING_EXPERIMENT_ID");
     if (rawValue == nullptr) { return 0; }
 
@@ -28,7 +28,9 @@ inline auto CurrentAIExperimentId() -> int {
     return experimentId;
 }
 
-inline auto IsAIExperiment(const int id) -> bool { return CurrentAIExperimentId() == id; }
+[[nodiscard]] inline auto IsAIExperiment(const int id) -> bool {
+    return CurrentAIExperimentId() == id;
+}
 
 }  // namespace shardok
 

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

@@ -19,6 +19,8 @@ namespace shardok {
 
 namespace {
 
+constexpr double kCertainCombatWinChance = 0.95;
+
 void WritePercent(std::ostream& output, const double value) {
     const auto flags = output.flags();
     const auto precision = output.precision();
@@ -154,8 +156,8 @@ auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
         const CommandListSPtr& availableCommands,
         const CommandList::const_iterator& fleeCommand,
         int maxRounds,
-        int minimumFleeOddsThreshold,
-        int desperateFleeThreshold,
+        int /*minimumFleeOddsThreshold*/,
+        int /*desperateFleeThreshold*/,
         bool enableDebugLogging) -> FleeDecision {
     // Get flee success odds
     const int fleeSuccessChance = (*fleeCommand)->GetOddsPercentile();
@@ -164,67 +166,31 @@ auto AIFleeDecisionCalculator::EvaluateFleeVsFight(
         std::cout << "AI FinalRound: Evaluating flee (odds=" << fleeSuccessChance << "%)...\n";
     }
 
-    // Check if flee odds are good enough to attempt
-    if (fleeSuccessChance >= minimumFleeOddsThreshold) {
-        if (enableDebugLogging) {
-            std::cout << "AI FinalRound: Good flee odds (" << fleeSuccessChance
-                      << "% >= " << minimumFleeOddsThreshold << "%), choosing flee\n";
-        }
-        return FleeDecision{
-                true,
-                GetFleeCommandIndex(fleeCommand, availableCommands),
-                "Good flee odds"};
-    }
-
-    // Low flee odds - evaluate if fighting might be better
     const double combatWinChance = EstimateCombatSuccess(playerId, guessedState, maxRounds);
 
-    // If combat situation is hopeless, even bad flee odds are better than certain death
-    if (combatWinChance <= 0.05 && fleeSuccessChance >= desperateFleeThreshold) {
+    if (combatWinChance < kCertainCombatWinChance) {
         if (enableDebugLogging) {
-            std::cout << "AI FinalRound: Combat hopeless (";
+            std::cout << "AI FinalRound: Combat not certain (";
             WritePercent(std::cout, combatWinChance * 100);
-            std::cout << "%), desperate flee attempt (" << fleeSuccessChance << "%)\n";
+            std::cout << "% < ";
+            WritePercent(std::cout, kCertainCombatWinChance * 100);
+            std::cout << "%), choosing flee\n";
         }
         return FleeDecision{
                 true,
                 GetFleeCommandIndex(fleeCommand, availableCommands),
-                "Combat hopeless, desperate flee"};
+                "Last round combat not certain"};
     }
 
-    // Detailed flee vs fight comparison
-    const double fleeChance = static_cast<double>(fleeSuccessChance) / 100.0;
-
-    // Compare expected outcomes:
-    // - Flee: fleeChance of survival (not victory, but avoiding loss)
-    // - Fight: combatWinChance of victory (better than survival)
-
-    constexpr double FLEE_VS_COMBAT_MARGIN =
-            0.8;  // Require 80% of combat chance to prefer fighting
-    const double adjustedCombatThreshold = combatWinChance * FLEE_VS_COMBAT_MARGIN;
-
     if (enableDebugLogging) {
-        std::cout << "AI FinalRound: Flee=" << fleeSuccessChance << "%, Combat=";
+        std::cout << "AI FinalRound: Combat effectively certain (";
         WritePercent(std::cout, combatWinChance * 100);
-        std::cout << "%, Threshold=";
-        WritePercent(std::cout, adjustedCombatThreshold * 100);
-        std::cout << "% -> ";
-    }
-
-    if (fleeChance > adjustedCombatThreshold) {
-        if (enableDebugLogging) { std::cout << "FLEE (better odds)\n"; }
-        return FleeDecision{
-                true,
-                GetFleeCommandIndex(fleeCommand, availableCommands),
-                "Flee has better expected outcome"};
-    } else {
-        if (enableDebugLogging) { std::cout << "FIGHT (better expected outcome)\n"; }
-        // Return 0 to indicate we should use standard command selection
-        return FleeDecision{
-                false,
-                0,  // Will be replaced by StandardChooseCommandIndex
-                "Fighting has better expected outcome"};
+        std::cout << "%), fighting\n";
     }
+    return FleeDecision{
+            false,
+            0,  // Will be replaced by StandardChooseCommandIndex
+            "Combat effectively certain"};
 }
 
 auto AIFleeDecisionCalculator::ShouldConsiderFleeing(

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

@@ -5,15 +5,34 @@
 #include "AIMinimumDistanceAndTarget.hpp"
 
 namespace shardok {
+namespace {
+
+auto CoordsIndex(const Coords &coords, const int columnCount) -> int {
+    return coords.row() * columnCount + coords.column();
+}
+
+auto CoordsFromIndex(const size_t index, const int columnCount) -> Coords {
+    return Coords(
+            static_cast<int8_t>(index / static_cast<size_t>(columnCount)),
+            static_cast<int8_t>(index % static_cast<size_t>(columnCount)));
+}
+
+}  // namespace
+
 auto MinimumDistanceAndTarget(
         const ActionPointDistances *apd,
         const Coords &origin,
         const CoordsSet &destinations) -> CoordsAndDistance {
     CoordsAndDistance min{Coords(-1, -1), ActionPointDistances::IMPOSSIBLE};
-    for (const auto &dest : destinations) {
-        const DIST_T dist = apd->Distance(origin, dest);
+    const int columnCount = destinations.ColumnCount();
+    const int originIndex = CoordsIndex(origin, columnCount);
+
+    for (const auto destIndex : destinations.indexIterator()) {
+        const DIST_T dist = apd->Distance(originIndex, static_cast<int>(destIndex));
         if (dist == ActionPointDistances::IMPOSSIBLE) continue;
-        if (dist < min.distance) min = CoordsAndDistance{dest, dist};
+        if (dist < min.distance) {
+            min = CoordsAndDistance{CoordsFromIndex(destIndex, columnCount), dist};
+        }
     }
 
     return min;
@@ -25,4 +44,4 @@ auto MinimumDistance(
         const CoordsSet &destinations) -> int {
     return MinimumDistanceAndTarget(apd, origin, destinations).distance;
 }
-}  // namespace shardok
+}  // namespace shardok

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

@@ -18,12 +18,12 @@ struct CoordsAndDistance {
     int distance;
 };
 
-auto MinimumDistanceAndTarget(
+[[nodiscard]] auto MinimumDistanceAndTarget(
         const ActionPointDistances *apd,
         const Coords &origin,
         const CoordsSet &destinations) -> CoordsAndDistance;
 
-auto MinimumDistance(
+[[nodiscard]] auto MinimumDistance(
         const ActionPointDistances *apd,
         const Coords &origin,
         const CoordsSet &destinations) -> int;

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

@@ -20,12 +20,13 @@ using GameState = net::eagle0::shardok::storage::fb::GameState;
 using PlayerInfo = net::eagle0::shardok::storage::fb::PlayerInfo;
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 
-auto HasAttachedHeroWithProfession(
+[[nodiscard]] auto HasAttachedHeroWithProfession(
         const Unit *unit,
         net::eagle0::shardok::storage::fb::Profession profession) -> bool;
 
-auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
-auto PlayerInfoForPid(const GameStateW &, PlayerId pid) -> const PlayerInfo *;
+[[nodiscard]] auto CastleClaimCapableAttackerUnitCount(const GameStateW &gameState) -> int;
+[[nodiscard]] auto PlayerInfoForPid(const GameStateW &gameState, PlayerId pid)
+        -> const PlayerInfo *;
 
 }  // namespace shardok
 

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

@@ -26,11 +26,13 @@ struct AIStrategy {
 };
 
 extern AIStrategy FleeStrategy;
-auto AttackUnitsStrategy(const vector<TargetPriorityList>& targetPriorities) -> AIStrategy;
-auto AttackCastlesStrategy(const vector<TargetPriorityList>& targetPriorities) -> AIStrategy;
+[[nodiscard]] auto AttackUnitsStrategy(const vector<TargetPriorityList>& targetPriorities)
+        -> AIStrategy;
+[[nodiscard]] auto AttackCastlesStrategy(const vector<TargetPriorityList>& targetPriorities)
+        -> AIStrategy;
 extern AIStrategy HoldCastlesStrategy;
 extern AIStrategy ScatterStrategy;
-auto CrossRiversStrategy(const CoordsSet& targetLocations) -> AIStrategy;
+[[nodiscard]] auto CrossRiversStrategy(const CoordsSet& targetLocations) -> AIStrategy;
 
 }  // namespace shardok
 

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

@@ -30,7 +30,7 @@ public:
     AIEvaluationCounter(AIEvaluationCounter&&) = delete;
     auto operator=(AIEvaluationCounter&&) -> AIEvaluationCounter& = delete;
 
-    static int GetCurrentCount();
+    [[nodiscard]] static int GetCurrentCount();
 };
 
 // Configuration structure for iterative deepening time budget
@@ -44,7 +44,7 @@ struct AITimeBudget {
 // Time budget is calculated dynamically based on number of available commands:
 //   budget = msPerCommand × numCommands (clamped to 200-5000ms)
 // If isAllAiBattle is true, uses allAiBattleTimeBudgetMaximum instead of the normal maximum.
-auto CalculateTimeBudget(
+[[nodiscard]] auto CalculateTimeBudget(
         PlayerId playerId,
         const GameSettingsSPtr& settings,
         const GameStateW& state,

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

@@ -88,8 +88,8 @@ auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue {
             break;
     }
 
-    const double battalionValue = battalionTypeMultiplier * (1.0 + armament / 100.0) *
-                                  (1.0 + training / 100.0) * (0.5 + morale / 100.0) *
+    const double battalionValue = battalionTypeMultiplier * (1.0 + (armament / 100.0)) *
+                                  (1.0 + (training / 100.0)) * (0.5 + (morale / 100.0)) *
                                   unit->battalion().size();
 
     const double heroValue =
@@ -120,15 +120,16 @@ auto archeryValue(const vector<const Unit *> &enemyUnits, const bool canShootNow
 
 auto reduceValue(const Unit *unit, const Terrain *unitTerrain) -> double {
     // TODO: make this depend on value of reducing castle too
-    if (unit->fortified() || unitTerrain->modifier().castle().present())
+    if (unit->fortified() || unitTerrain->modifier().castle().present()) {
         return kReduceFortifiedPossibleValue;
-    else if (AllowsFortification(unitTerrain))
-        return kReduceUnfortifiedPossibleValue;
-    else
-        return 0.0;
+    }
+    if (AllowsFortification(unitTerrain)) { return kReduceUnfortifiedPossibleValue; }
+    return 0.0;
 }
 
-auto fearValue(const vector<const Unit *> &) -> double { return kFearPossibleValue; }
+auto fearValue([[maybe_unused]] const vector<const Unit *> &enemyUnits) -> double {
+    return kFearPossibleValue;
+}
 
 auto lightningValue(const Unit *unit) -> double {
     // TODO: make this depend on the value of the targets
@@ -235,9 +236,8 @@ auto meteorValue(
                     multiplier = kMeteorNoneRoundMultiplier * vigorFactor;
                 }
                 return maxValue * multiplier;
-            } else {
-                return 0.0;
             }
+            return 0.0;
         }
 
         case net::eagle0::shardok::storage::fb::MultiroundMagicState_TARGET:
@@ -247,9 +247,8 @@ auto meteorValue(
                         map,
                         enemyOccupants,
                         friendlyOccupants);
-            } else {
-                return bestTargetValue(unit, map, enemyOccupants, friendlyOccupants, meteorRange);
             }
+            return bestTargetValue(unit, map, enemyOccupants, friendlyOccupants, meteorRange);
         case net::eagle0::shardok::storage::fb::MultiroundMagicState_CAST:
             return kMeteorCastRoundMultiplier *
                    meteorDropRawValue(

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

@@ -17,9 +17,9 @@ using net::eagle0::shardok::storage::fb::Unit;
 using ScoreValue = double;
 class AttackLocations;
 
-auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue;
+[[nodiscard]] auto ContextFreeUnitValue(const Unit *unit) -> ScoreValue;
 
-auto GetRangedAttackBonus(
+[[nodiscard]] auto GetRangedAttackBonus(
         const Unit *unit,
         bool isAttacker,
         const HexMap *map,
@@ -32,7 +32,7 @@ auto GetRangedAttackBonus(
         double minVigorToCast,
         ActionPoints archeryActionPointCost = 0) -> double;
 
-auto UnitValue(
+[[nodiscard]] auto UnitValue(
         const Unit *unit,
         bool isAttacker,
         const std::vector<const Unit *> &attackerUnits,

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

@@ -6,9 +6,18 @@
 
 #include "AIMinimumDistanceAndTarget.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/fb_helpers/HexMapHelpers.hpp"
+#include "src/main/cpp/net/eagle0/shardok/library/map/HexMapHasher.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/util/HexMapUtils.hpp"
 
 namespace shardok {
+namespace {
+
+auto RecomputeModifierHash(HexMap *hexMap) -> MapId {
+    hexMap->mutate_modifier_hash(GetModifierHash(hexMap));
+    return ActionPointDistancesCache::GetMapId(hexMap);
+}
+
+}  // namespace
 
 auto UnitIdsRequiringWaterCrossing(
         const GameStateW &gameState,
@@ -18,7 +27,7 @@ auto UnitIdsRequiringWaterCrossing(
         const BattalionTypeGetter &battalionTypeGetter) -> vector<UnitId> {
     // Put out all the fires, except on bridges
     fb::HexMapW mapCopy = fb::CopyHexMap(gameState->hex_map());
-    for (uint32_t index = 0; index < mapCopy->terrain()->size(); index++) {
+    for (uint32_t index = 0; index < mapCopy->terrain()->size(); ++index) {
         if (IsWater(mapCopy->terrain()->Get(index)->type())) continue;
         // const_cast is safe because we own the mutable buffer (mapCopy)
         const_cast<net::eagle0::shardok::storage::fb::Terrain *>(
@@ -155,7 +164,7 @@ auto WaterCrossingTiles(
     //  1) the tile is water
     //  2) the tile does not already have a bridge (that is not on fire)
     //  3) the tile is not already frozen
-    for (int index = 0; index < mapSize; index++) {
+    for (int index = 0; index < mapSize; ++index) {
         const auto startTerrain = *hexMap->terrain()->Get(index);
 
         if (!IsWater(startTerrain.type())) continue;
@@ -169,6 +178,7 @@ auto WaterCrossingTiles(
         auto *terr = const_cast<net::eagle0::shardok::storage::fb::Terrain *>(
                 mapCopy->mutable_terrain()->GetMutableObject(index));
         terr->mutable_modifier().mutable_bridge().mutate_present(true);
+        terr->mutable_modifier().mutable_bridge().mutate_integrity(100.0);
         terr->mutable_modifier().mutable_fire().mutate_present(false);
 
         auto hash = ActionPointDistancesCache::GetMapId(mapCopy);
@@ -185,6 +195,50 @@ auto WaterCrossingTiles(
     return returnCoords;
 }
 
+// Returns currently frozen water tiles that can act as an existing crossing from origin to
+// destination. The shared APD cache deliberately ignores ice, so this probes frozen tiles by
+// temporarily treating one as bridged for the water-crossing strategy only.
+auto FrozenWaterCrossingTiles(
+        const Coords &origin,
+        const Coords &destination,
+        const HexMap *hexMap,
+        const APDCache &apdCache,
+        const BattalionTypeSPtr &battalionType) -> CoordsSet {
+    AssertValid(origin, hexMap);
+    AssertValid(destination, hexMap);
+    auto returnCoords = CoordsSet(hexMap);
+
+    fb::HexMapW mapCopy = fb::CopyHexMap(hexMap);
+    const int mapSize = hexMap->row_count() * hexMap->column_count();
+
+    for (int index = 0; index < mapSize; ++index) {
+        const auto startTerrain = *hexMap->terrain()->Get(index);
+
+        if (!IsWater(startTerrain.type())) continue;
+
+        const auto modifier = startTerrain.modifier();
+        if (!modifier.ice().present() || modifier.fire().present()) continue;
+
+        auto *terr = const_cast<net::eagle0::shardok::storage::fb::Terrain *>(
+                mapCopy->mutable_terrain()->GetMutableObject(index));
+        terr->mutable_modifier().mutable_bridge().mutate_present(true);
+        terr->mutable_modifier().mutable_bridge().mutate_integrity(100.0);
+        terr->mutable_modifier().mutable_fire().mutate_present(false);
+
+        const MapId mapId = RecomputeModifierHash(mapCopy.Get());
+
+        if (const auto *distances = apdCache->GetRaw(mapCopy, mapId, battalionType, false);
+            distances->Distance(origin, destination) != ActionPointDistances::IMPOSSIBLE) {
+            returnCoords.Add(index / hexMap->column_count(), index % hexMap->column_count());
+        }
+
+        terr->mutable_modifier().mutable_bridge().mutate_present(false);
+        terr->mutable_modifier().mutable_bridge().mutate_integrity(0.0);
+    }
+
+    return returnCoords;
+}
+
 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
 auto IntendedCrossingStarts(
         const GameStateW &gameState,
@@ -213,7 +267,6 @@ auto IntendedCrossingStarts(
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 
 constexpr double kNoRequiredCrossingScore = std::numeric_limits<double>::max();
-constexpr double kNoCrossingCreatorsScore = std::numeric_limits<double>::min();
 
 auto WaterCrossingScore(
         const PlayerId playerId,
@@ -256,12 +309,26 @@ auto WaterCrossingScore(
 
     const auto unitIdsCreatingCrossing =
             UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
-    if (unitIdsCreatingCrossing.empty()) return kNoCrossingCreatorsScore;
 
     double totalScore = 0;
 
     const auto mapId = ActionPointDistancesCache::GetMapId(gameState->hex_map());
 
+    if (unitIdsCreatingCrossing.empty()) {
+        for (const UnitId uid : unitIdsRequiringCrossing) {
+            const Unit *unit = gameState->units()->Get(uid);
+            const auto &battalionType = battalionTypeGetter(unit->battalion().type());
+            const Coords location = unit->location();
+            const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
+
+            const int thisDistance =
+                    location.row() < 0 ? 1000 : MinimumDistance(apd, location, startCrossingFrom);
+            totalScore -= thisDistance;
+        }
+
+        return totalScore;
+    }
+
     // First put a big penalty on the distance for units that can create a crossing
     for (const UnitId uid : unitIdsCreatingCrossing) {
         const Unit *unit = gameState->units()->Get(uid);

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

@@ -31,7 +31,7 @@ static inline void AssertValid(const Coords& c, const HexMap* hexMap) {
 }
 
 // Units that need a water crossing to reach at least one of the destinations
-auto UnitIdsRequiringWaterCrossing(
+[[nodiscard]] auto UnitIdsRequiringWaterCrossing(
         const GameStateW& gameState,
         PlayerId pid,
         const CoordsSet& destinations,
@@ -39,14 +39,14 @@ auto UnitIdsRequiringWaterCrossing(
         const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;
 
 // Units belonging to the player that are capable of creating water crossings
-auto UnitIdsToCreateWaterCrossing(
+[[nodiscard]] auto UnitIdsToCreateWaterCrossing(
         const GameStateW& gameState,
         PlayerId pid,
         const BattalionTypeGetter& battalionTypeGetter) -> vector<UnitId>;
 
 // Whether a unit of the given type can reach destination from origin, given the current state
 // of the map
-auto CanReach(
+[[nodiscard]] auto CanReach(
         const Coords& origin,
         const Coords& destination,
         const HexMap* hexMap,
@@ -56,11 +56,21 @@ auto CanReach(
 
 // Returns the *non*-water tiles from which you could bridge/freeze water to allow a unit to cross
 // from origin to destination
-auto CrossingStartLocations(const HexMap* hexMap, const CoordsSet& waterCrossingTiles) -> CoordsSet;
+[[nodiscard]] auto CrossingStartLocations(const HexMap* hexMap, const CoordsSet& waterCrossingTiles)
+        -> CoordsSet;
 
 // Returns the water tiles that, if they were bridged/frozen, would allow a unit to cross from
 // origin to destination
-auto WaterCrossingTiles(
+[[nodiscard]] auto WaterCrossingTiles(
+        const Coords& origin,
+        const Coords& destination,
+        const HexMap* hexMap,
+        const APDCache& apdCache,
+        const BattalionTypeSPtr& battalionType) -> CoordsSet;
+
+// Returns currently frozen water tiles that can act as an existing crossing from origin to
+// destination.
+[[nodiscard]] auto FrozenWaterCrossingTiles(
         const Coords& origin,
         const Coords& destination,
         const HexMap* hexMap,
@@ -68,7 +78,7 @@ auto WaterCrossingTiles(
         const BattalionTypeSPtr& battalionType) -> CoordsSet;
 
 // Returns the set of tiles that the attacker should try to approach in order to bridge/freeze
-auto IntendedCrossingStarts(
+[[nodiscard]] auto IntendedCrossingStarts(
         const GameStateW& gameState,
         const vector<UnitId>& unitIdsCreatingCrossing,
         const CoordsSet& tilesToStartCrossingFrom,
@@ -76,7 +86,7 @@ auto IntendedCrossingStarts(
         const BattalionTypeGetter& battalionTypeGetter) -> CoordsSet;
 
 // Calculate score based on water crossing strategy
-auto WaterCrossingScore(
+[[nodiscard]] auto WaterCrossingScore(
         PlayerId playerId,
         const BattalionTypeGetter& battalionTypeGetter,
         const GameStateW& gameState,

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

@@ -15,7 +15,6 @@ namespace shardok {
 using Unit = net::eagle0::shardok::storage::fb::Unit;
 
 constexpr ScoreValue kNoRequiredCrossingScore = std::numeric_limits<ScoreValue>::max();
-constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>::min();
 
 [[nodiscard]] auto AIWaterCrossingCommandChooser::WaterCrossingScore(
         const BattalionTypeGetter &battalionTypeGetter,
@@ -56,12 +55,26 @@ constexpr ScoreValue kNoCrossingCreatorsScore = std::numeric_limits<ScoreValue>:
 
     const auto unitIdsCreatingCrossing =
             UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
-    if (unitIdsCreatingCrossing.empty()) return kNoCrossingCreatorsScore;
 
     ScoreValue totalScore = 0;
 
     const auto mapId = ActionPointDistancesCache::GetMapId(gameState->hex_map());
 
+    if (unitIdsCreatingCrossing.empty()) {
+        for (const UnitId uid : unitIdsRequiringCrossing) {
+            const Unit *unit = gameState->units()->Get(uid);
+            const auto &battalionType = battalionTypeGetter(unit->battalion().type());
+            const Coords location = unit->location();
+            const auto *apd = apdCache->GetRaw(gameState->hex_map(), mapId, battalionType, false);
+
+            const int thisDistance =
+                    location.row() < 0 ? 1000 : MinimumDistance(apd, location, startCrossingFrom);
+            totalScore -= thisDistance;
+        }
+
+        return totalScore;
+    }
+
     // First put a big penalty on the distance for units that can create a crossing
     for (const UnitId uid : unitIdsCreatingCrossing) {
         const Unit *unit = gameState->units()->Get(uid);
@@ -157,7 +170,6 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
 
     const auto unitIdsCreatingCrossing =
             UnitIdsToCreateWaterCrossing(gameState, playerId, battalionTypeGetter);
-    if (unitIdsCreatingCrossing.empty()) return startCrossingFrom;
 
     for (const UnitId uid : unitIdsRequiringCrossing) {
         const Unit *unit = gameState->units()->Get(uid);
@@ -177,6 +189,17 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
             Coords destination = *destinations.begin();
             AssertValid(destination, gameState->hex_map());
 
+            auto frozenWaterCrossingTiles = FrozenWaterCrossingTiles(
+                    origin,
+                    destination,
+                    gameState->hex_map(),
+                    apdCache,
+                    battalionType);
+            startCrossingFrom +=
+                    CrossingStartLocations(gameState->hex_map(), frozenWaterCrossingTiles);
+
+            if (unitIdsCreatingCrossing.empty()) continue;
+
             auto waterCrossingTiles = WaterCrossingTiles(
                     origin,
                     destination,
@@ -192,4 +215,4 @@ auto AIWaterCrossingCommandChooser::StartCrossingFrom(
     return startCrossingFrom;
 }
 
-}  // namespace shardok
+}  // namespace shardok

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

@@ -51,7 +51,7 @@ IterativeDeepeningAI::IterativeDeepeningAI(
       castleCoords(castleCoords),
       scorer(scorer),
       apdCache(apdCache),
-      battalionTypeGetter(std::move(battalionTypeGetter)) {}  // Move the function object
+      battalionTypeGetter(std::move(battalionTypeGetter)) {}
 
 auto IterativeDeepeningAI::IterativeSearch(
         const GameSettingsSPtr& settings,

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

@@ -79,7 +79,7 @@ private:
     CoordsSet castleCoords;
     const AIScoreCalculator& scorer;
     const APDCache& apdCache;
-    BattalionTypeGetter battalionTypeGetter;  // Store by value, not reference!
+    BattalionTypeGetter battalionTypeGetter;
 
     // Reusable vectors to reduce memory allocations
     mutable std::vector<std::vector<ScoreValue>> scoresByDepth;

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

@@ -19,8 +19,11 @@
 #include <sstream>
 #endif
 
+#include <array>
+#include <atomic>
 #include <iomanip>
 #include <iostream>
+#include <mutex>
 #include <set>
 #include <unordered_map>
 
@@ -182,7 +185,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(
                   << " round=" << guessedState->current_round() << "\n";
 
         const auto maxDump = std::max(commandCount, realAvailableCommands->size());
-        for (size_t i = 0; i < maxDump; i++) {
+        for (size_t i = 0; i < maxDump; ++i) {
             const auto realName = i < realAvailableCommands->size()
                                           ? net::eagle0::shardok::common::CommandType_Name(
                                                     (*realAvailableCommands)[i]->GetCommandType())
@@ -214,13 +217,13 @@ auto ShardokAIClient::StandardChooseCommandIndex(
         // Group by unit to find the missing position per unit
         std::unordered_map<int, std::set<std::pair<int, int>>> realPositions;
         std::unordered_map<int, std::set<std::pair<int, int>>> guessedPositions;
-        for (size_t i = 0; i < realAvailableCommands->size(); i++) {
+        for (size_t i = 0; i < realAvailableCommands->size(); ++i) {
             const auto &cmd = (*realAvailableCommands)[i];
             realPositions[cmd->GetActorUnitId()].emplace(
                     cmd->GetTargetRow(),
                     cmd->GetTargetColumn());
         }
-        for (size_t i = 0; i < commandCount; i++) {
+        for (size_t i = 0; i < commandCount; ++i) {
             const auto &cmd = (*guessedCommands)[i];
             guessedPositions[cmd->GetActorUnitId()].emplace(
                     cmd->GetTargetRow(),
@@ -250,7 +253,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(
 
         // Dump all guessed state units for full picture
         std::cerr << "  Guessed state units (" << guessedState->units()->size() << " total):\n";
-        for (size_t i = 0; i < guessedState->units()->size(); i++) {
+        for (size_t i = 0; i < guessedState->units()->size(); ++i) {
             const auto *u = guessedState->units()->Get(static_cast<unsigned int>(i));
             std::cerr << "    unit_id=" << u->unit_id() << " player=" << u->player_id()
                       << " status=" << static_cast<int>(u->status()) << " loc=("
@@ -263,7 +266,7 @@ auto ShardokAIClient::StandardChooseCommandIndex(
                 "AI command count mismatch: guessed=" + std::to_string(commandCount) +
                 " real=" + std::to_string(realAvailableCommands->size()));
     }
-    for (size_t i = 0; i < commandCount; i++) {
+    for (size_t i = 0; i < commandCount; ++i) {
         CheckCommand((*realAvailableCommands)[i], (*guessedCommands)[i]);
     }
 
@@ -465,8 +468,10 @@ auto ShardokAIClient::ChooseCommandIndex(
         const GameSettingsSPtr &settings,
         const GameStateView &gsv,
         const CommandListSPtr &realAvailableCommands) const -> CommandChoiceResults {
-    static int typeChosenCount[net::eagle0::shardok::common::CommandType_MAX + 1];
-    static int totalChoices = 0;
+    static std::array<std::atomic<int>, net::eagle0::shardok::common::CommandType_MAX + 1>
+            typeChosenCount;
+    static std::atomic<int> totalChoices = 0;
+    static std::mutex reportMutex;
 
     CommandChoiceResults results{};
 
@@ -484,15 +489,18 @@ auto ShardokAIClient::ChooseCommandIndex(
     }
 
     const auto chosenType = (*realAvailableCommands)[results.chosenIndex]->GetCommandType();
-    typeChosenCount[static_cast<int>(chosenType)]++;
-    totalChoices++;
+    typeChosenCount[static_cast<size_t>(chosenType)].fetch_add(1, std::memory_order_relaxed);
+    const int updatedTotal = totalChoices.fetch_add(1, std::memory_order_relaxed) + 1;
 
-    if (totalChoices % 1000 == 0) {
+    if (updatedTotal % 1000 == 0) {
+        std::lock_guard lock(reportMutex);
         std::cout << "TYPES CHOSEN:\n";
         vector<std::pair<int, CommandType>> choices{};
-        for (int i = 0; i <= net::eagle0::shardok::common::CommandType_MAX; i++) {
-            if (typeChosenCount[i] != 0) {
-                choices.emplace_back(typeChosenCount[i], static_cast<CommandType>(i));
+        for (int i = 0; i <= net::eagle0::shardok::common::CommandType_MAX; ++i) {
+            if (const int count =
+                        typeChosenCount[static_cast<size_t>(i)].load(std::memory_order_relaxed);
+                count != 0) {
+                choices.emplace_back(count, static_cast<CommandType>(i));
             }
         }
 

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

@@ -38,8 +38,10 @@ TranspositionTable::probe(const GameStateW& state, int depth, PlayerId player) {
     uint64_t stored_hash = entry.hash_full.load(std::memory_order_relaxed);
     uint8_t stored_depth = entry.depth.load(std::memory_order_relaxed);
     uint8_t stored_player = entry.player_id.load(std::memory_order_relaxed);
+    uint16_t stored_age = entry.age.load(std::memory_order_relaxed);
 
-    if (stored_hash == hash && stored_depth >= depth && stored_player == player) {
+    if (stored_hash == hash && stored_depth >= depth && stored_player == player &&
+        stored_age == current_age.load(std::memory_order_relaxed)) {
         stats.hits++;
         float score = entry.score.load(std::memory_order_relaxed);
         return static_cast<ScoreValue>(score);

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

@@ -44,6 +44,7 @@ public:
     [[nodiscard]] PlayerId getPlayer() const { return player_; }
     [[nodiscard]] int getActorId() const { return actorId_; }
     [[nodiscard]] std::pair<int, int> getTarget() const { return {targetRow_, targetCol_}; }
+    [[nodiscard]] bool hasOdds() const { return hasOdds_; }
 
 private:
     // Store only essential fields (~25 bytes, all POD, cache-friendly)

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

@@ -6,8 +6,10 @@
 
 #include <algorithm>
 #include <chrono>
+#include <cstdint>
 #include <iomanip>
 #include <iostream>
+#include <mutex>
 #include <numeric>
 
 #include "ShardokAction.hpp"
@@ -32,9 +34,30 @@ auto IsDefenderPlayer(const GameStateW& gameState, const PlayerId playerId) -> b
     return false;
 }
 
-auto LegalActionsCacheKey(const uint64_t stateHash, const bool rootIsDefender) -> uint64_t {
+auto MixCacheKey(uint64_t seed, const uint64_t value) -> uint64_t {
+    constexpr uint64_t kHashCombineConstant = 0x9e3779b97f4a7c15ULL;
+    seed ^= value + kHashCombineConstant + (seed << 6) + (seed >> 2);
+    return seed;
+}
+
+auto PointerIdentityHash(const void* ptr) -> uint64_t {
+    return static_cast<uint64_t>(reinterpret_cast<std::uintptr_t>(ptr));
+}
+
+auto LegalActionsCacheKey(
+        const uint64_t stateHash,
+        const bool rootIsDefender,
+        const GameSettings* gameSettings,
+        const APDCache* apdCache) -> uint64_t {
     constexpr uint64_t kDefenderRoleHash = 0x9e3779b97f4a7c15ULL;
-    return rootIsDefender ? stateHash ^ kDefenderRoleHash : stateHash;
+    uint64_t key = rootIsDefender ? stateHash ^ kDefenderRoleHash : stateHash;
+
+    // The cached action set is the output of AICommandFilter, not just the raw command list.
+    // Include the context objects that can affect filtering so a process-wide cache entry from
+    // one search cannot be reused by a different settings/APD context with the same state hash.
+    key = MixCacheKey(key, PointerIdentityHash(gameSettings));
+    key = MixCacheKey(key, PointerIdentityHash(apdCache != nullptr ? apdCache->get() : nullptr));
+    return key;
 }
 
 auto SortActionsByWeight(
@@ -43,7 +66,7 @@ auto SortActionsByWeight(
     std::vector<size_t> sortedIndices(actions.size());
     std::iota(sortedIndices.begin(), sortedIndices.end(), 0);
 
-    std::sort(sortedIndices.begin(), sortedIndices.end(), [&weights](size_t a, size_t b) {
+    std::ranges::sort(sortedIndices, [&weights](size_t a, size_t b) {
         return weights[a] > weights[b];
     });
 
@@ -72,6 +95,10 @@ std::atomic<uint64_t> ShardokGameEngine::cacheMisses_{0};
 std::atomic<uint64_t> ShardokGameEngine::timeInHashComputation_{0};
 std::atomic<uint64_t> ShardokGameEngine::timeInLegalActionsComputation_{0};
 
+namespace {
+std::once_flag legalActionsCacheReserveOnce;
+}  // namespace
+
 ShardokGameEngine::ShardokGameEngine(
         [[maybe_unused]] const ShardokEngine* engine,
         const AIScoreCalculator* scoreCalculator,
@@ -92,7 +119,9 @@ ShardokGameEngine::ShardokGameEngine(
       criticalTileCoords_(criticalTileCoords) {
     // Thread-local cache is automatically initialized per thread
     // Reserve space to reduce rehashing (based on profiling: ~30-50K unique states per search)
-    legalActionsCache_.reserve(100000);
+    std::call_once(legalActionsCacheReserveOnce, [] {
+        ShardokGameEngine::legalActionsCache_.reserve(100000);
+    });
 }
 
 std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
@@ -106,27 +135,15 @@ std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
 
     const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
 
-    // Use cached engine if available (avoids recomputing GetAvailableCommands for same state)
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        // Clone the cached engine to preserve command cache
-        engine = std::make_shared<ShardokEngine>(*cachedEngine);
-    } else {
-        // Create fresh engine and populate command cache
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_,
-                0,
-                false);
-        // Populate command cache (result intentionally unused, just populating cache)
-        [[maybe_unused]] const auto commands =
-                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-        // Cache the engine for future use with this state
-        shardokState->setCachedEngine(engine);
-        // Clone it for applying the action (don't mutate the cached engine)
-        engine = std::make_shared<ShardokEngine>(*engine);
-    }
+    auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_,
+            0,
+            false);
+    // Populate the AI command list before posting so the MCTS action index maps to the
+    // no-follow-up command ordering used by getLegalActions().
+    [[maybe_unused]] const auto commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
     // Create deterministic random generator if a specific roll is requested
     // deterministicRoll of -1.0 (default) means use random generator
@@ -187,11 +204,6 @@ std::unique_ptr<MCTSGameState> ShardokGameEngine::applyAction(
             *alCache_,
             criticalTileCoords_);
 
-    // Cache the engine on the new state so score() can use it for END_TURN normalization
-    // The engine's command list may be stale after the action was applied, but that's OK -
-    // we'll refresh it when we call GetAvailableCommandsForAIPlayer() in score()
-    newState->setCachedEngine(engine);
-
     // Don't pre-compute hash - let it be computed lazily on first use
     // Many states (especially in simulation) never need their hash computed
     return newState;
@@ -211,28 +223,18 @@ void ShardokGameEngine::applyActionMutable(
 
     const auto currentPlayer = static_cast<PlayerId>(state->currentPlayerId());
 
-    // Use cached engine if available
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        engine = std::make_shared<ShardokEngine>(*cachedEngine);
-    } else {
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_,
-                0,
-                false);
-        // Populate command cache (result intentionally unused, just populating cache)
-        [[maybe_unused]] const auto commands =
-                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-        shardokState->setCachedEngine(engine);
-        engine = std::make_shared<ShardokEngine>(*engine);
-    }
+    auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_,
+            0,
+            false);
+    // Populate the AI command list before posting so the MCTS action index maps to the
+    // no-follow-up command ordering used by getLegalActions().
+    [[maybe_unused]] const auto commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
     engine->PostCommand(currentPlayer, shardokAction->getIndex(), nullptr);
     shardokState->getMutableShardokState() = engine->GetCurrentGameState();
-    // Clear the cached engine and hash since the state has been mutated
-    shardokState->setCachedEngine(nullptr);
     shardokState->invalidateHashCache();
 }
 
@@ -258,7 +260,8 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
     // Time hash computation
     const auto hashStart = std::chrono::high_resolution_clock::now();
     const uint64_t stateHash = shardokState->hash();
-    const uint64_t cacheKey = LegalActionsCacheKey(stateHash, isDefender_);
+    const uint64_t cacheKey =
+            LegalActionsCacheKey(stateHash, isDefender_, gameSettings_.get(), apdCache_);
     const auto hashEnd = std::chrono::high_resolution_clock::now();
     timeInHashComputation_.fetch_add(
             std::chrono::duration_cast<std::chrono::microseconds>(hashEnd - hashStart).count(),
@@ -266,40 +269,49 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
 
     // Check transposition table for cached legal actions
     if (auto it = legalActionsCache_.find(cacheKey); it != legalActionsCache_.end()) {
-        cacheHits_.fetch_add(1, std::memory_order_relaxed);
+        const auto engine = std::make_shared<ShardokEngine>(
+                gameSettings_,
+                shardokState->getShardokState(),
+                criticalTileCoords_);
 
-        // Use cached engine
-        shardokState->setCachedEngine(it->second.engine);
+        const CommandListSPtr commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
-        // Get commands from the cached engine (Engine already caches these internally)
-        const CommandListSPtr commands =
-                it->second.engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-
-        if (!commands || commands->empty()) { return {}; }
-
-        // Convert to MCTSActions using stored filtered indices
-        std::vector<std::unique_ptr<MCTSAction>> actions;
-        actions.reserve(it->second.filteredIndices.size());
-
-        for (const size_t origIdx : it->second.filteredIndices) {
-            if (origIdx < commands->size()) {
-                const auto& cmd = commands->at(origIdx);
-
-                // Extract essential fields directly from command (no proto conversion!)
-                actions.push_back(std::make_unique<ShardokAction>(
-                        origIdx,
-                        cmd->GetCommandType(),
-                        cmd->GetPlayerId(),
-                        cmd->GetActorUnitId(),
-                        cmd->GetTargetRow(),
-                        cmd->GetTargetColumn(),
-                        cmd->HasOdds()));
+        bool cacheEntryMatches = commands != nullptr && commands->size() == it->second.commandCount;
+        for (const auto& cachedAction : it->second.actions) {
+            const size_t commandIndex = cachedAction.getIndex();
+            if (!cacheEntryMatches || commandIndex >= commands->size()) {
+                cacheEntryMatches = false;
+                break;
             }
+
+            const auto& command = commands->at(commandIndex);
+            const auto [targetRow, targetColumn] = cachedAction.getTarget();
+            cacheEntryMatches = command->GetCommandType() ==
+                                        static_cast<net::eagle0::shardok::common::CommandType>(
+                                                cachedAction.getType()) &&
+                                command->GetPlayerId() == cachedAction.getPlayer() &&
+                                command->GetActorUnitId() == cachedAction.getActorId() &&
+                                command->GetTargetRow() == targetRow &&
+                                command->GetTargetColumn() == targetColumn &&
+                                command->HasOdds() == cachedAction.hasOdds();
+            if (!cacheEntryMatches) { break; }
         }
 
-        // Sort actions by weight (descending) to ensure MCTS explores high-value actions first
-        const std::vector<double> weights = getActionWeights(actions, state);
-        return SortActionsByWeight(std::move(actions), weights);
+        if (cacheEntryMatches) {
+            cacheHits_.fetch_add(1, std::memory_order_relaxed);
+
+            // Convert immutable cached action snapshots to MCTS action instances.
+            std::vector<std::unique_ptr<MCTSAction>> actions;
+            actions.reserve(it->second.actions.size());
+
+            for (const auto& cachedAction : it->second.actions) {
+                actions.push_back(cachedAction.clone());
+            }
+
+            // Sort actions by weight (descending) to ensure MCTS explores high-value actions first
+            const std::vector<double> weights = getActionWeights(actions, state);
+            return SortActionsByWeight(std::move(actions), weights);
+        }
     }
 
     cacheMisses_.fetch_add(1, std::memory_order_relaxed);
@@ -307,17 +319,10 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
     // Time legal actions computation
     const auto actionsStart = std::chrono::high_resolution_clock::now();
 
-    // Use cached engine if available, otherwise create and cache it
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        engine = cachedEngine;
-    } else {
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_);
-        shardokState->setCachedEngine(engine);
-    }
+    const auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_);
 
     const CommandListSPtr commands = engine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
@@ -338,20 +343,24 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
     // Convert only filtered commands to MCTSActions
     std::vector<std::unique_ptr<MCTSAction>> actions;
     actions.reserve(filteredIndices.size());
+    std::vector<ShardokAction> cachedActions;
+    cachedActions.reserve(filteredIndices.size());
 
     for (const size_t idx : filteredIndices) {
         if (idx < commands->size()) {
             const auto& cmd = commands->at(idx);
 
             // Extract essential fields directly from command (no proto conversion!)
-            actions.push_back(std::make_unique<ShardokAction>(
+            ShardokAction action(
                     idx,
                     cmd->GetCommandType(),
                     cmd->GetPlayerId(),
                     cmd->GetActorUnitId(),
                     cmd->GetTargetRow(),
                     cmd->GetTargetColumn(),
-                    cmd->HasOdds()));
+                    cmd->HasOdds());
+            actions.push_back(action.clone());
+            cachedActions.push_back(action);
         }
     }
 
@@ -368,20 +377,20 @@ std::vector<std::unique_ptr<MCTSAction>> ShardokGameEngine::getLegalActions(
                     .count(),
             std::memory_order_relaxed);
 
-    // Store in transposition table for future lookups
-    // Note: We only store filtered indices and the engine (which caches commands internally)
-    // This avoids duplicating heavy protocol buffer objects
+    // Store immutable action snapshots in the transposition table for future lookups.
+    // Do not store ShardokEngine here: its command cache is mutable and not safe to share
+    // across MCTS worker threads.
     // Use lazy_emplace_l to ensure thread-safe insertion (locks the bucket during construction)
     legalActionsCache_.lazy_emplace_l(
             cacheKey,
             [&](typename decltype(legalActionsCache_)::value_type& v) {
                 // Update existing entry
-                v.second.filteredIndices = filteredIndices;
-                v.second.engine = engine;
+                v.second.commandCount = commands->size();
+                v.second.actions = cachedActions;
             },
             [&](const typename decltype(legalActionsCache_)::constructor& ctor) {
                 // Create new entry
-                ctor(cacheKey, LegalActionsCache{filteredIndices, engine});
+                ctor(cacheKey, LegalActionsCache{commands->size(), cachedActions});
             });
 
     return actions;
@@ -398,9 +407,8 @@ std::vector<size_t> ShardokGameEngine::filterActions(
         const MCTSGameState& /*state*/) const {
     // All filtering is already done in getLegalActions() using AICommandFilter
     // This method is used by simulation policies and doesn't need additional filtering
-    std::vector<size_t> indices;
-    indices.reserve(actions.size());
-    for (size_t i = 0; i < actions.size(); ++i) { indices.push_back(i); }
+    std::vector<size_t> indices(actions.size());
+    std::iota(indices.begin(), indices.end(), 0);
     return indices;
 }
 
@@ -415,15 +423,7 @@ std::vector<double> ShardokGameEngine::getActionWeights(
                 "indicates a type mismatch in the MCTS adapter layer");
     }
 
-    // Get cached engine and command list for looking up command protos
-    auto cachedEngine = shardokState->getCachedEngine();
-    if (!cachedEngine) {
-        throw MCTSInternalError(
-                "ShardokGameEngine::getActionWeights called with state that has no cached engine");
-    }
-
     const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
-    const CommandListSPtr commands = cachedEngine->GetAvailableCommandsForAIPlayer(currentPlayer);
 
     // Determine if current player is defender (not root player!)
     // During simulation we need to use the correct perspective for action weighting
@@ -442,20 +442,13 @@ std::vector<double> ShardokGameEngine::getActionWeights(
                     "indicates a type mismatch in the MCTS adapter layer");
         }
 
-        // Look up command proto from cached engine using action's index
-        const size_t cmdIndex = shardokAction->getIndex();
-        if (cmdIndex >= commands->size()) {
-            throw MCTSInternalError(
-                    "ShardokGameEngine::getActionWeights: action index out of bounds");
-        }
-
-        const auto& cmd = commands->at(cmdIndex);
+        const auto [targetRow, targetColumn] = shardokAction->getTarget();
 
         weights.push_back(AIHeuristicWeighting::GetCommandWeight(
-                cmd->GetCommandType(),
-                cmd->GetActorUnitId(),
-                cmd->GetPlayerId(),
-                Coords{cmd->GetTargetRow(), cmd->GetTargetColumn()},
+                static_cast<net::eagle0::shardok::common::CommandType>(shardokAction->getType()),
+                shardokAction->getActorId(),
+                shardokAction->getPlayer(),
+                Coords{static_cast<int8_t>(targetRow), static_cast<int8_t>(targetColumn)},
                 gameState,
                 castleCoords_,
                 apdCache_,
@@ -489,7 +482,7 @@ bool ShardokGameEngine::shouldStopSearch(
 size_t ShardokGameEngine::mapFilteredIndexToOriginal(
         size_t filteredIndex,
         const MCTSGameState& state) const {
-    // Get the filtered actions (uses cached engine)
+    // Get the filtered actions.
     auto actions = getLegalActions(state, state.currentPlayerId(), 0, 0);
 
     // Check bounds
@@ -591,22 +584,12 @@ ChanceOutcomeInfo ShardokGameEngine::getBinaryOutcomeInfo(
 
     const auto currentPlayer = static_cast<PlayerId>(state.currentPlayerId());
 
-    // Get or create the engine for this state
-    std::shared_ptr<ShardokEngine> engine;
-    if (auto cachedEngine = shardokState->getCachedEngine()) {
-        engine = cachedEngine;
-    } else {
-        engine = std::make_shared<ShardokEngine>(
-                gameSettings_,
-                shardokState->getShardokState(),
-                criticalTileCoords_,
-                0,
-                false);
-        // Populate command cache
-        [[maybe_unused]] const auto commands =
-                engine->GetAvailableCommandsForAIPlayer(currentPlayer);
-        shardokState->setCachedEngine(engine);
-    }
+    const auto engine = std::make_shared<ShardokEngine>(
+            gameSettings_,
+            shardokState->getShardokState(),
+            criticalTileCoords_,
+            0,
+            false);
 
     // Get command descriptors
     const auto descriptors = engine->GetAvailableCommandsForAIPlayer(currentPlayer);

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

@@ -15,6 +15,7 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSGameEngine.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIAttackLocations.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
+#include "src/main/cpp/net/eagle0/shardok/ai/mcts/adapters/ShardokAction.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
@@ -99,11 +100,12 @@ public:
     void resetCacheStatistics();
 
 private:
-    // Transposition table entry for caching legal actions
-    // Note: We don't store command protos since the Engine already caches them
+    // Transposition table entry for caching legal actions.
+    // Store immutable action snapshots only; ShardokEngine owns mutable command caches and
+    // must remain per-state/per-thread.
     struct LegalActionsCache {
-        std::vector<size_t> filteredIndices;
-        std::shared_ptr<ShardokEngine> engine;  // Engine with populated command cache
+        size_t commandCount;
+        std::vector<ShardokAction> actions;
     };
 
     const AIScoreCalculator* scoreCalculator_;

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

@@ -98,7 +98,6 @@ std::unique_ptr<MCTSGameState> ShardokGameState::clone() const {
             apdCache_,
             alCache_,
             criticalTileCoords_);
-    // Don't copy the cached engine - each state needs its own
     return cloned;
 }
 

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

@@ -10,7 +10,6 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSGameState.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/AIStrategy.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/GameStateW.hpp"
-#include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/action_point_distances/ActionPointDistancesCache.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
@@ -52,10 +51,6 @@ public:
     [[nodiscard]] const GameSettings* getSettings() const { return settings_; }
     [[nodiscard]] const CoordsSet& getCriticalTileCoords() const { return criticalTileCoords_; }
 
-    // Engine caching for performance (avoids recomputing available commands)
-    void setCachedEngine(std::shared_ptr<ShardokEngine> engine) const { cachedEngine_ = engine; }
-    [[nodiscard]] std::shared_ptr<ShardokEngine> getCachedEngine() const { return cachedEngine_; }
-
     // Invalidate hash cache when state is mutated
     void invalidateHashCache() const {
         hashCached_ = false;
@@ -74,7 +69,6 @@ private:
     mutable uint64_t cachedHash_ = 0;
     mutable bool hashCached_ = false;
     const CoordsSet criticalTileCoords_;  // Own the data to avoid dangling references
-    mutable std::shared_ptr<ShardokEngine> cachedEngine_;  // Engine with cached available commands
 };
 
 }  // namespace mcts

src/main/cpp/net/eagle0/shardok/ai/score/AIVictoryConditionScoreCalculator.cpp

@@ -133,8 +133,7 @@ auto DefenderHoldsCriticalTilesVictoryScore(
     const auto cc = gameState->hex_map()->column_count();
     const auto occupants = Occupants(*gameState->units(), rc, cc);
 
-    for (const Coords& criticalTileLocation : criticalTileLocations) {
-        const auto index = criticalTileLocation.row() * cc + criticalTileLocation.column();
+    for (const auto index : criticalTileLocations.indexIterator()) {
         const auto& occupant = occupants[index];
 
         if (occupant && occupant->battalion().type() !=

src/main/cpp/net/eagle0/shardok/ai/score/AIVictoryConditionScoreCalculator.hpp

@@ -23,7 +23,7 @@ using net::eagle0::shardok::storage::fb::PlayerInfo;
 
 using ScoreValue = double;
 
-auto AttackerHoldsCriticalTilesVictoryScore(
+[[nodiscard]] auto AttackerHoldsCriticalTilesVictoryScore(
         const GameStateW& gameState,
         const CoordsSet& criticalTileLocations,
         const PlayerInfo* player,
@@ -32,12 +32,12 @@ auto AttackerHoldsCriticalTilesVictoryScore(
         const BattalionTypeGetter& battalionTypeGetter,
         ActionPoints braveWaterCost) -> ScoreValue;
 
-auto DefenderHoldsCriticalTilesVictoryScore(
+[[nodiscard]] auto DefenderHoldsCriticalTilesVictoryScore(
         const GameStateW& gameState,
         const CoordsSet& criticalTileLocations,
         const PlayerInfo* player) -> ScoreValue;
 
-auto LastPlayerStandingVictoryScore(
+[[nodiscard]] auto LastPlayerStandingVictoryScore(
         const GameStateW& gameState,
         const PlayerInfo* player,
         const APDCache& apdCache,

src/main/cpp/net/eagle0/shardok/ai/score/MCTSOptimizedAIScoreCalculator.cpp

@@ -230,7 +230,7 @@ auto MakeMCTSOptimizedAIScoreCalculator(
     std::vector<BattalionTypeSPtr> battalionTypes(BattalionTypeId::BattalionTypeId_MAX + 1);
     for (int typeId = BattalionTypeId::BattalionTypeId_MIN;
          typeId <= BattalionTypeId::BattalionTypeId_MAX;
-         typeId++) {
+         ++typeId) {
         auto battalionTypeId = static_cast<BattalionTypeId>(typeId);
         battalionTypes[battalionTypeId] = settingsGetter.GetBattalionType(battalionTypeId);
     }

src/main/cpp/net/eagle0/shardok/ai/score/StandardAIScoreCalculator.cpp

@@ -356,7 +356,7 @@ auto MakeStandardAIScoreCalculatorWithExperiment(
     std::vector<BattalionTypeSPtr> battalionTypes(BattalionTypeId::BattalionTypeId_MAX + 1);
     for (int typeId = BattalionTypeId::BattalionTypeId_MIN;
          typeId <= BattalionTypeId::BattalionTypeId_MAX;
-         typeId++) {
+         ++typeId) {
         auto battalionTypeId = static_cast<BattalionTypeId>(typeId);
         battalionTypes[battalionTypeId] = settingsGetter.GetBattalionType(battalionTypeId);
     }

src/main/cpp/net/eagle0/shardok/ai/score/private/AIScoreCalculatorSharedUtilities.cpp

@@ -7,8 +7,7 @@
 #include "src/main/cpp/net/eagle0/shardok/ai/AIScoreUtilities.hpp"
 #include "src/main/cpp/net/eagle0/shardok/library/map/CoordsSet.hpp"
 
-namespace shardok {
-namespace score_calculator_internal {
+namespace shardok::score_calculator_internal {
 
 auto EffectiveDistanceCache::GetOrCompute(
         const Unit* unit,
@@ -125,5 +124,4 @@ auto AttackerMultiplierForTargetDistance(
             isLateGame);
 }
 
-}  // namespace score_calculator_internal
-}  // namespace shardok
+}  // namespace shardok::score_calculator_internal

src/main/cpp/net/eagle0/shardok/ai/score/private/AIScoreCalculatorSharedUtilities.hpp

@@ -24,8 +24,7 @@
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/hex_map_generated.h"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/unit_generated.h"
 
-namespace shardok {
-namespace score_calculator_internal {
+namespace shardok::score_calculator_internal {
 
 using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 using Unit = net::eagle0::shardok::storage::fb::Unit;
@@ -51,13 +50,13 @@ struct EffectiveDistanceCache {
     struct CacheKey {
         UnitId unitId;
         Coords target;
-        bool operator==(const CacheKey& other) const {
+        [[nodiscard]] bool operator==(const CacheKey& other) const {
             return unitId == other.unitId && target == other.target;
         }
     };
 
     struct CacheKeyHash {
-        size_t operator()(const CacheKey& key) const {
+        [[nodiscard]] size_t operator()(const CacheKey& key) const {
             return std::hash<UnitId>{}(key.unitId) ^ (std::hash<int>{}(key.target.row()) << 1) ^
                    (std::hash<int>{}(key.target.column()) << 2);
         }
@@ -65,7 +64,7 @@ struct EffectiveDistanceCache {
 
     mutable gtl::flat_hash_map<CacheKey, DIST_T, CacheKeyHash> cache;
 
-    DIST_T GetOrCompute(
+    [[nodiscard]] DIST_T GetOrCompute(
             const Unit* unit,
             const Coords& target,
             const ActionPointDistances* notBravingApd,
@@ -75,11 +74,12 @@ struct EffectiveDistanceCache {
 
 /// Calculate score for FLEE strategy
 /// Returns negative score based on fleeing units
-auto FleeStrategyScoreForState(const GameStateW& gameState, PlayerId playerId) -> ScoreValue;
+[[nodiscard]] auto FleeStrategyScoreForState(const GameStateW& gameState, PlayerId playerId)
+        -> ScoreValue;
 
 /// Calculate attacker multiplier based on distance to priority targets
 /// This is used to weight attacker units by their proximity to objectives
-auto AttackerMultiplierForTargetDistance(
+[[nodiscard]] auto AttackerMultiplierForTargetDistance(
         const Unit* attackingUnit,
         const std::vector<TargetAndAttackLocations>& priorityList,
         const std::vector<const Unit*>& occupants,
@@ -89,7 +89,6 @@ auto AttackerMultiplierForTargetDistance(
         const ActionPointDistances* bravingApd,
         bool isLateGame) -> double;
 
-}  // namespace score_calculator_internal
-}  // namespace shardok
+}  // namespace shardok::score_calculator_internal
 
 #endif  // EAGLE0_SHARDOK_AI_SCORE_PRIVATE_AI_SCORE_CALCULATOR_SHARED_UTILITIES_HPP

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleConfig.cpp

@@ -10,8 +10,7 @@
 #include <iostream>
 #include <sstream>
 
-namespace shardok {
-namespace ai_battle_simulator {
+namespace shardok::ai_battle_simulator {
 
 using net::eagle0::shardok::ai_battle_simulator::AIAlgorithmType;
 using net::eagle0::shardok::ai_battle_simulator::PlayerConfig;
@@ -110,5 +109,4 @@ std::string AiBattleConfigLoader::ToJsonString(const BattleConfigProto& config)
     return jsonString;
 }
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleConfig.hpp

@@ -13,8 +13,7 @@
 #include "src/main/protobuf/net/eagle0/shardok/ai_battle_simulator/ai_battle_config.pb.h"
 #pragma clang diagnostic pop
 
-namespace shardok {
-namespace ai_battle_simulator {
+namespace shardok::ai_battle_simulator {
 
 using BattleConfigProto = net::eagle0::shardok::ai_battle_simulator::BattleConfig;
 
@@ -41,7 +40,6 @@ public:
     [[nodiscard]] static std::string ToJsonString(const BattleConfigProto& config);
 };
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator
 
 #endif  // EAGLE0_SHARDOK_AI_BATTLE_SIMULATOR_AI_BATTLE_CONFIG_HPP

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleSimulator.cpp

@@ -28,8 +28,7 @@
 #include "src/main/protobuf/net/eagle0/shardok/common/player_info.pb.h"
 #pragma clang diagnostic pop
 
-namespace shardok {
-namespace ai_battle_simulator {
+namespace shardok::ai_battle_simulator {
 
 namespace {
 
@@ -331,10 +330,6 @@ GameStateW AiBattleSimulator::CreateInitialGameState() const {
     // Load map
     auto hexMapProto = LoadMap(config_.map_name());
 
-    // Create player info protos
-    std::vector<net::eagle0::shardok::common::PlayerInfo> playerInfoProtos;
-    playerInfoProtos.reserve(2);
-
     // Attacker info
     net::eagle0::shardok::common::PlayerInfo attackerInfo;
     attackerInfo.set_player_id(ATTACKER_ID);
@@ -344,7 +339,6 @@ GameStateW AiBattleSimulator::CreateInitialGameState() const {
             net::eagle0::shardok::common::VICTORY_CONDITION_LAST_PLAYER_STANDING);
     attackerInfo.add_victory_conditions(
             net::eagle0::shardok::common::VICTORY_CONDITION_HOLDS_CRITICAL_TILES);
-    playerInfoProtos.push_back(std::move(attackerInfo));
 
     // Defender info
     net::eagle0::shardok::common::PlayerInfo defenderInfo;
@@ -355,7 +349,10 @@ GameStateW AiBattleSimulator::CreateInitialGameState() const {
             net::eagle0::shardok::common::VICTORY_CONDITION_LAST_PLAYER_STANDING);
     defenderInfo.add_victory_conditions(
             net::eagle0::shardok::common::VICTORY_CONDITION_WIN_AFTER_MAX_ROUNDS);
-    playerInfoProtos.push_back(std::move(defenderInfo));
+
+    std::vector<net::eagle0::shardok::common::PlayerInfo> playerInfoProtos{
+            std::move(attackerInfo),
+            std::move(defenderInfo)};
 
     // Create units from config
     std::vector<net::eagle0::shardok::storage::fb::Unit> units;
@@ -961,5 +958,4 @@ BattleResult AiBattleSimulator::CreateResultFromGameState(
     return result;
 }
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/AiBattleSimulator.hpp

@@ -30,7 +30,9 @@ class ShardokEngine;
 // Type alias for hex map
 using HexMap = net::eagle0::shardok::storage::fb::HexMap;
 
-namespace ai_battle_simulator {
+}  // namespace shardok
+
+namespace shardok::ai_battle_simulator {
 
 using BattleConfigProto = net::eagle0::shardok::ai_battle_simulator::BattleConfig;
 
@@ -146,7 +148,6 @@ private:
     CreateResultFromGameState(const GameStateW& state, int totalRounds, int totalCommands) const;
 };
 
-}  // namespace ai_battle_simulator
-}  // namespace shardok
+}  // namespace shardok::ai_battle_simulator
 
 #endif  // EAGLE0_SHARDOK_AI_BATTLE_SIMULATOR_AI_BATTLE_SIMULATOR_HPP

src/main/cpp/net/eagle0/shardok/ai_battle_simulator/real_battle_smoke_metadata_main.cpp

@@ -191,7 +191,8 @@ int main(int argc, char *argv[]) {
             }
             std::cout << "],\"has_game_status\":" << (hasGameStatus ? "true" : "false") << "}\n";
             return 0;
-        } else if (!resultPath.empty()) {
+        }
+        if (!resultPath.empty()) {
             ActionResult result;
             if (!result.ParseFromString(ReadFile(resultPath))) {
                 throw std::runtime_error("Failed to parse Shardok action result proto");

src/main/cpp/net/eagle0/shardok/ai_performance_runner/PerformanceTestGameStateBuilder.hpp

@@ -32,7 +32,7 @@ public:
      * Initialize game settings from the default configuration files.
      * Must be called before creating game states.
      */
-    static auto InitializeGameSettings() -> GameSettingsSPtr;
+    [[nodiscard]] static auto InitializeGameSettings() -> GameSettingsSPtr;
 
     /**
      * Create the standard "Perf" test configuration:
@@ -44,7 +44,7 @@ public:
      * @param defenderToggle If true, AI is defender; if false, AI is attacker
      * @return A GameStateW with the configured battle
      */
-    static auto CreatePerfTestGameState(
+    [[nodiscard]] static auto CreatePerfTestGameState(
             const GameSettingsSPtr& settings,
             bool defenderToggle = false) -> GameStateW;
 
@@ -58,7 +58,7 @@ public:
      * @param defenderToggle If true, AI is defender; if false, AI is attacker
      * @return A GameStateW with the configured battle
      */
-    static auto CreateCustomTestGameState(
+    [[nodiscard]] static auto CreateCustomTestGameState(
             const GameSettingsSPtr& settings,
             const std::string& mapName,
             int aiUnitCount,
@@ -67,11 +67,11 @@ public:
 
 private:
     // Helper functions for building game state components
-    static auto
+    [[nodiscard]] static auto
     AddPlayerInfo(flatbuffers::FlatBufferBuilder& fbb, int playerId, bool isDefender, int food)
             -> flatbuffers::Offset<net::eagle0::shardok::storage::fb::PlayerInfo>;
 
-    static auto AddGenericUnit(
+    [[nodiscard]] static auto AddGenericUnit(
             PlayerId playerId,
             UnitId unitId,
             const net::eagle0::shardok::storage::fb::Coords& location,

src/main/cpp/net/eagle0/shardok/ai_testing_common/AIClientFactory.cpp

@@ -7,8 +7,7 @@
 #include "src/main/cpp/net/eagle0/common/mcts/abstract/MCTSTypes.hpp"
 #include "src/main/cpp/net/eagle0/shardok/ai/ShardokAIClient.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 auto AIClientFactory::Create(
         PlayerId playerId,
@@ -30,5 +29,4 @@ auto AIClientFactory::Create(
             mctsConfig);
 }
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common

src/main/cpp/net/eagle0/shardok/ai_testing_common/AIClientFactory.hpp

@@ -54,7 +54,7 @@ public:
      * @param mctsConfig MCTS settings, used only when algorithmType is MCTS
      * @return Unique pointer to created ShardokAIClient
      */
-    static auto Create(
+    [[nodiscard]] static auto Create(
             PlayerId playerId,
             bool isDefender,
             const net::eagle0::shardok::storage::fb::HexMap* hexMap,

src/main/cpp/net/eagle0/shardok/ai_testing_common/GamePhaseRunner.cpp

@@ -8,8 +8,7 @@
 #include "src/main/cpp/net/eagle0/shardok/library/ShardokEngine.hpp"
 #include "src/main/flatbuffer/net/eagle0/shardok/storage/game_state.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 auto GamePhaseRunner::RunSetupPhase(
         ShardokEngine& engine,
@@ -58,5 +57,4 @@ auto GamePhaseRunner::RunSingleTurn(ShardokEngine& engine, PlayerId playerId, Sh
     return true;
 }
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common

src/main/cpp/net/eagle0/shardok/ai_testing_common/GameSettingsFactory.cpp

@@ -9,8 +9,7 @@
 #include "src/main/cpp/net/eagle0/common/byte_vector.hpp"
 #include "src/main/cpp/net/eagle0/shardok/util/BattalionTypeRegistrar.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 auto GameSettingsFactory::CreateDefault() -> GameSettingsSPtr {
     auto settings = std::make_shared<GameSettings>();
@@ -31,5 +30,4 @@ auto GameSettingsFactory::CreateDefault() -> GameSettingsSPtr {
     return settings;
 }
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common

src/main/cpp/net/eagle0/shardok/ai_testing_common/GameSettingsFactory.hpp

@@ -10,8 +10,7 @@
 
 #include "src/main/cpp/net/eagle0/shardok/library/settings/GameSettings.hpp"
 
-namespace shardok {
-namespace ai_testing_common {
+namespace shardok::ai_testing_common {
 
 /**
  * Factory class for creating GameSettings instances with standard configuration.
@@ -30,10 +29,9 @@ public:
      *
      * @return Shared pointer to initialized GameSettings
      */
-    static auto CreateDefault() -> GameSettingsSPtr;
+    [[nodiscard]] static auto CreateDefault() -> GameSettingsSPtr;
 };
 
-}  // namespace ai_testing_common
-}  // namespace shardok
+}  // namespace shardok::ai_testing_common
 
 #endif  // EAGLE0_SHARDOK_AI_TESTING_COMMON_GAME_SETTINGS_FACTORY_HPP

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

@@ -14,6 +14,7 @@
 #include <iostream>
 #include <iterator>
 #include <ranges>
+#include <sstream>
 #include <string>
 #include <thread>
 
@@ -27,6 +28,77 @@ using net::eagle0::common::ScopedShardokLatencyTrace;
 
 using net::eagle0::shardok::common::GameStatus;
 
+namespace {
+
+[[nodiscard]] auto DescribeCommandForLog(const CommandSPtr &command) -> std::string {
+    if (!command) { return "<null command>"; }
+
+    std::ostringstream out;
+    out << "type=" << command->GetCommandType()
+        << " player=" << static_cast<int>(command->GetPlayerId())
+        << " actor=" << command->GetActorUnitId() << " target=("
+        << static_cast<int>(command->GetTargetRow()) << ','
+        << static_cast<int>(command->GetTargetColumn()) << ')';
+
+    if (command->HasOdds()) { out << " odds_percentile=" << command->GetOddsPercentile(); }
+
+    try {
+        out << " proto={" << command->GetCommandProto().ShortDebugString() << '}';
+    } catch (const std::exception &e) { out << " proto_error={" << e.what() << '}'; }
+
+    return out.str();
+}
+
+[[nodiscard]] auto DescribeCommandsForLog(const CommandList &commands) -> std::string {
+    std::ostringstream out;
+    out << "available_command_count=" << commands.size();
+    for (size_t i = 0; i < commands.size(); ++i) {
+        out << "\n  [" << i << "] " << DescribeCommandForLog(commands[i]);
+    }
+    return out.str();
+}
+
+[[nodiscard]] auto DescribeCurrentStateForLog(const ShardokEngine &engine) -> std::string {
+    const auto *state = engine.GetCurrentGameState().Get();
+    if (state == nullptr) { return "state=<null>"; }
+
+    const auto vectorSize = [](const auto *vector) -> size_t {
+        return vector == nullptr ? 0 : vector->size();
+    };
+
+    std::ostringstream out;
+    out << "state={round=" << static_cast<int>(state->current_round())
+        << " current_player=" << static_cast<int>(state->current_player())
+        << " history_count=" << engine.GetUnfilteredHistoryCount();
+
+    if (const auto *status = state->status(); status != nullptr) {
+        out << " status=" << static_cast<int>(status->state()) << " end_condition=";
+        if (const auto *endCondition = status->end_game_condition(); endCondition != nullptr) {
+            out << "{type=" << static_cast<int>(endCondition->victory_type())
+                << " victory_details=" << static_cast<int>(endCondition->victory_details())
+                << " draw_details=" << static_cast<int>(endCondition->draw_details()) << '}';
+        } else {
+            out << "<null>";
+        }
+    } else {
+        out << " status=<null>";
+    }
+
+    out << " units=" << vectorSize(state->units())
+        << " player_infos=" << vectorSize(state->player_infos());
+
+    if (const auto *hexMap = state->hex_map(); hexMap != nullptr) {
+        out << " map=" << hexMap->row_count() << 'x' << hexMap->column_count();
+    } else {
+        out << " map=<null>";
+    }
+
+    out << '}';
+    return out.str();
+}
+
+}  // namespace
+
 class InvalidTokenException : public std::exception {};
 
 class MismatchedPlayerIdException : public std::exception {
@@ -154,6 +226,8 @@ void ShardokGameController::DoAIThread() {
             continue;
         }
 
+        std::string aiPhase = "choosing command";
+        int64_t chosenIndex = -1;
         try {
             // Phase 2: AI thinks (NO LOCK - this is the slow part)
             auto results = [&] {
@@ -165,6 +239,7 @@ void ShardokGameController::DoAIThread() {
                          {"available_command_count", std::to_string(availableCommands->size())}});
                 return aiClient->ChooseCommandIndex(settings, gsv, availableCommands);
             }();
+            chosenIndex = results.chosenIndex;
 
             // Phase 3: Post the command (brief lock)
             {
@@ -183,6 +258,7 @@ void ShardokGameController::DoAIThread() {
                 }
 
                 {
+                    aiPhase = "posting chosen command";
                     ScopedShardokLatencyTrace trace(
                             "ai_engine_post_command",
                             cachedGameId,
@@ -193,6 +269,7 @@ void ShardokGameController::DoAIThread() {
                 }
                 LockedNotifyClients();
                 {
+                    aiPhase = "posting forced follow-up commands";
                     ScopedShardokLatencyTrace trace(
                             "ai_engine_post_forced_commands",
                             cachedGameId,
@@ -204,16 +281,32 @@ void ShardokGameController::DoAIThread() {
                 aiThreadKeepGoing = !engine->GameIsOver();
             }
         } catch (const std::exception &e) {
+            std::ostringstream error;
+            error << "AI error in game " << cachedGameId << ", player " << playerId << ", round "
+                  << gsv.current_round() << ": " << e.what();
+
+            std::ostringstream context;
+            context << "AI failure context: phase=" << aiPhase
+                    << ", expected_history_count=" << expectedHistoryCount
+                    << ", current_history_count=" << engine->GetUnfilteredHistoryCount()
+                    << ", chosen_index=" << chosenIndex
+                    << ", current_player=" << static_cast<int>(engine->GetCurrentPlayerId()) << ", "
+                    << DescribeCurrentStateForLog(*engine);
+
+            const std::string commandsContext = availableCommands
+                                                        ? DescribeCommandsForLog(*availableCommands)
+                                                        : "available_command_count=<cleared>";
+
             std::cerr << "AI thread exception in game " << cachedGameId << ", player " << playerId
                       << ", round " << gsv.current_round() << ": " << e.what() << '\n';
+            std::cerr << context.str() << '\n';
+            std::cerr << commandsContext << '\n';
 
             void *backtraceArray[20];
             const int backtraceSize = backtrace(backtraceArray, 20);
             backtrace_symbols_fd(backtraceArray, backtraceSize, STDERR_FILENO);
 
-            aiThreadErrorMessage = "AI error in game " + cachedGameId + ", player " +
-                                   std::to_string(playerId) + ", round " +
-                                   std::to_string(gsv.current_round()) + ": " + e.what();
+            aiThreadErrorMessage = error.str() + "\n" + context.str() + "\n" + commandsContext;
             aiThreadFailed.store(true);
             updateCondition.notify_all();
             break;

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

@@ -32,9 +32,8 @@ private:
     static auto CannotBecomeOutlaw(const GameStateW &gameState, PlayerId pid) -> bool {
         if (pid == UNCONTROLLED_PLAYER_ID) return false;
 
-        const auto &player = std::find_if(
-                std::begin(*gameState->player_infos()),
-                std::end(*gameState->player_infos()),
+        const auto &player = std::ranges::find_if(
+                *gameState->player_infos(),
                 [pid](const PlayerInfoFb *pi) { return pi->player_id() == pid; });
 
         return (player != std::end(*gameState->player_infos()) && player->cannot_become_outlaw());
@@ -43,9 +42,8 @@ private:
     static auto IsAttacker(const GameStateW &gameState, PlayerId pid) -> bool {
         if (pid == UNCONTROLLED_PLAYER_ID) return false;
 
-        const auto &player = std::find_if(
-                std::begin(*gameState->player_infos()),
-                std::end(*gameState->player_infos()),
+        const auto &player = std::ranges::find_if(
+                *gameState->player_infos(),
                 [pid](const PlayerInfoFb *pi) { return pi->player_id() == pid; });
 
         return (player == std::end(*gameState->player_infos()) || !player->is_defender());