ci: bump version with Build-134

Empty string config value caused DeploymentException when injected as String.
Optional[String] handles absent/empty cleanly without defaultValue workaround.

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

.github/workflows/native-image.yml

@@ -127,7 +127,7 @@ jobs:
           if [ -n "$MARCH" ]; then
             MARCH_ARG="-Dquarkus.native.additional-build-args=$MARCH"
           fi
-          ./gradlew :modules:${{ matrix.module }}:build -x test -Dquarkus.native.enabled=true -Dquarkus.package.jar.enabled=false -Dquarkus.profile=deployed $MARCH_ARG --no-daemon
+          ./gradlew :modules:${{ matrix.module }}:build -x test -x spotlessScalaCheck -x checkScalafix -Dquarkus.native.enabled=true -Dquarkus.package.jar.enabled=false -Dquarkus.profile=deployed $MARCH_ARG --no-daemon
 
       - name: Set up Docker Buildx
         if: steps.image-check.outputs.exists == 'false'

modules/analytics/CHANGELOG.md

@@ -23,3 +23,61 @@
 ### Bug Fixes
 
 * **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add Dockerfile, CI workflow, and stable jar name for K8s deployment ([95215b6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/95215b6a420fd526df1aa395f9b087556c8ad03b))
+* **analytics:** add PostgreSQL JDBC write-back to all four batch jobs ([0e0ea4c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0e0ea4c9893c6efed52e633e55d05ab3ed004502))
+* **analytics:** add Spark batch analytics module ([259b3bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/259b3bbb24c0f23326269b93f4b3c84012f727cd))
+* **analytics:** add Structured Streaming, MLlib clustering, GraphX jobs ([e1d80b9](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e1d80b9331666feea191b1fd08aa762f3581c918))
+* **official-bots:** park expert bot on tournament server at startup ([#76](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/76)) ([751a58b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/751a58b6061f7434115e229a7661894c76768bc2))
+
+### Bug Fixes
+
+* **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add 7 new Spark analytics jobs and extend GameSource ([8e17c14](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8e17c14dff740cd115011dfbf17de35083b8fe46))
+* **analytics:** add Dockerfile, CI workflow, and stable jar name for K8s deployment ([95215b6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/95215b6a420fd526df1aa395f9b087556c8ad03b))
+* **analytics:** add PostgreSQL JDBC write-back to all four batch jobs ([0e0ea4c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0e0ea4c9893c6efed52e633e55d05ab3ed004502))
+* **analytics:** add Spark batch analytics module ([259b3bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/259b3bbb24c0f23326269b93f4b3c84012f727cd))
+* **analytics:** add Structured Streaming, MLlib clustering, GraphX jobs ([e1d80b9](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e1d80b9331666feea191b1fd08aa762f3581c918))
+* **official-bots:** park expert bot on tournament server at startup ([#76](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/76)) ([751a58b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/751a58b6061f7434115e229a7661894c76768bc2))
+
+### Bug Fixes
+
+* **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add 7 new Spark analytics jobs and extend GameSource ([8e17c14](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8e17c14dff740cd115011dfbf17de35083b8fe46))
+* **analytics:** add Dockerfile, CI workflow, and stable jar name for K8s deployment ([95215b6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/95215b6a420fd526df1aa395f9b087556c8ad03b))
+* **analytics:** add PostgreSQL JDBC write-back to all four batch jobs ([0e0ea4c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0e0ea4c9893c6efed52e633e55d05ab3ed004502))
+* **analytics:** add Spark batch analytics module ([259b3bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/259b3bbb24c0f23326269b93f4b3c84012f727cd))
+* **analytics:** add Structured Streaming, MLlib clustering, GraphX jobs ([e1d80b9](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e1d80b9331666feea191b1fd08aa762f3581c918))
+* **analytics:** always write results to PostgreSQL regardless of input source ([da0e6d1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/da0e6d1ee2d391ecb6291396f82471eb51b1b25e))
+* **official-bots:** park expert bot on tournament server at startup ([#76](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/76)) ([751a58b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/751a58b6061f7434115e229a7661894c76768bc2))
+
+### Bug Fixes
+
+* **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add 7 new Spark analytics jobs and extend GameSource ([8e17c14](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8e17c14dff740cd115011dfbf17de35083b8fe46))
+* **analytics:** add Dockerfile, CI workflow, and stable jar name for K8s deployment ([95215b6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/95215b6a420fd526df1aa395f9b087556c8ad03b))
+* **analytics:** add PostgreSQL JDBC write-back to all four batch jobs ([0e0ea4c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0e0ea4c9893c6efed52e633e55d05ab3ed004502))
+* **analytics:** add Spark batch analytics module ([259b3bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/259b3bbb24c0f23326269b93f4b3c84012f727cd))
+* **analytics:** add Structured Streaming, MLlib clustering, GraphX jobs ([e1d80b9](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e1d80b9331666feea191b1fd08aa762f3581c918))
+* **analytics:** always write results to PostgreSQL regardless of input source ([da0e6d1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/da0e6d1ee2d391ecb6291396f82471eb51b1b25e))
+* **official-bots:** park expert bot on tournament server at startup ([#76](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/76)) ([751a58b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/751a58b6061f7434115e229a7661894c76768bc2))
+
+### Bug Fixes
+
+* **analytics:** upgrade Spark to 4.0.3 — 3.5.x has no official Docker image ([46af115](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/46af1154de34a8596cb6cb28c6fad7aba90f597c))
+* **analytics:** write decompressed PGN to shared PVC path for executor access ([a268a9a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a268a9acb7ba190c76e996ccf3ea3bd00e5cec92))

modules/analytics/src/main/scala/de/nowchess/analytics/ColorAdvantageJob.scala

@@ -0,0 +1,72 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.Row
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+import org.apache.spark.sql.types.DataTypes
+import org.apache.spark.sql.types.StructField
+import org.apache.spark.sql.types.StructType
+
+import scala.jdk.CollectionConverters.*
+
+object ColorAdvantageJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-color-advantage"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Color Advantage")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .load(spark, jdbcUrl, dbUser, dbPass)
+      .select("result")
+      .filter(F.col("result").isNotNull)
+
+    val totalGames = games.count()
+    val whiteWins  = games.filter(F.col("result") === "white").count()
+    val blackWins  = games.filter(F.col("result") === "black").count()
+    val draws      = games.filter(F.col("result") === "draw").count()
+
+    val schema = StructType(
+      Seq(
+        StructField("color", DataTypes.StringType, false),
+        StructField("total_games", DataTypes.LongType, false),
+        StructField("wins", DataTypes.LongType, false),
+        StructField("losses", DataTypes.LongType, false),
+        StructField("draws", DataTypes.LongType, false),
+      ),
+    )
+
+    val rows = List(
+      Row("white", totalGames, whiteWins, blackWins, draws),
+      Row("black", totalGames, blackWins, whiteWins, draws),
+    )
+
+    val stats = spark
+      .createDataFrame(rows.asJava, schema)
+      .withColumn("win_rate", F.round(F.col("wins") / F.col("total_games").cast("double"), 3))
+      .orderBy(F.asc("color"))
+
+    stats.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/color_advantage")
+
+    stats.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_color_advantage")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/DailyActivityJob.scala

@@ -0,0 +1,99 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+
+object DailyActivityJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-daily-activity"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Daily Activity")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .loadExtended(spark, jdbcUrl, dbUser, dbPass)
+      .select("result", "utc_date", "utc_time")
+      .filter(F.col("utc_time").isNotNull.and(F.col("utc_date").isNotNull))
+
+    val hourOfDay = F.regexp_extract(F.col("utc_time"), "^(\\d{2})", 1).cast("int")
+    val dow       = F.dayofweek(F.to_date(F.col("utc_date"), "yyyy.MM.dd"))
+
+    val tagged = games
+      .withColumn("hour_of_day", hourOfDay)
+      .withColumn("dow", dow)
+
+    val hourly = tagged
+      .groupBy("hour_of_day")
+      .agg(
+        F.count("*").as("total_games"),
+        F.sum(F.when(F.col("result") === "white", 1).otherwise(0)).as("white_wins"),
+        F.sum(F.when(F.col("result") === "black", 1).otherwise(0)).as("black_wins"),
+        F.sum(F.when(F.col("result") === "draw", 1).otherwise(0)).as("draws"),
+      )
+      .withColumn("white_win_rate", F.round(F.col("white_wins") / F.col("total_games").cast("double"), 3))
+      .orderBy(F.asc("hour_of_day"))
+      .select("hour_of_day", "total_games", "white_wins", "black_wins", "draws", "white_win_rate")
+
+    hourly.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/hourly_activity")
+
+    hourly.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_hourly_activity")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
+
+    val dayName = F
+      .when(F.col("dow") === 1, "Sunday")
+      .when(F.col("dow") === 2, "Monday")
+      .when(F.col("dow") === 3, "Tuesday")
+      .when(F.col("dow") === 4, "Wednesday")
+      .when(F.col("dow") === 5, "Thursday")
+      .when(F.col("dow") === 6, "Friday")
+      .otherwise("Saturday")
+
+    val weekly = tagged
+      .withColumn("day_of_week", dayName)
+      .withColumn("day_order", F.col("dow"))
+      .groupBy("day_of_week", "day_order")
+      .agg(
+        F.count("*").as("total_games"),
+        F.sum(F.when(F.col("result") === "white", 1).otherwise(0)).as("white_wins"),
+        F.sum(F.when(F.col("result") === "black", 1).otherwise(0)).as("black_wins"),
+        F.sum(F.when(F.col("result") === "draw", 1).otherwise(0)).as("draws"),
+      )
+      .withColumn("white_win_rate", F.round(F.col("white_wins") / F.col("total_games").cast("double"), 3))
+      .orderBy(F.asc("day_order"))
+      .drop("day_order")
+      .select("day_of_week", "total_games", "white_wins", "black_wins", "draws", "white_win_rate")
+
+    weekly.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/weekly_activity")
+
+    weekly.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_weekly_activity")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/EloDistributionJob.scala

@@ -0,0 +1,58 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+
+object EloDistributionJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-elo-distribution"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Elo Distribution")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .loadExtended(spark, jdbcUrl, dbUser, dbPass)
+      .filter(F.col("white_elo").isNotNull)
+
+    val whiteElo = games.select(F.col("white_elo").as("elo"))
+    val blackElo = games.select(F.col("black_elo").as("elo"))
+    val allElo   = whiteElo.union(blackElo).filter(F.col("elo").isNotNull)
+
+    val bucketMin = (F.floor(F.col("elo") / 200) * 200).cast("int")
+    val bucketLabel = F.when(
+      F.col("elo") >= 2800,
+      F.lit("2800+"),
+    ).otherwise(F.concat(bucketMin.cast("string"), F.lit("-"), (bucketMin + 199).cast("string")))
+
+    val distribution = allElo
+      .withColumn("elo_bucket", bucketLabel)
+      .withColumn("bucket_order", F.when(F.col("elo") >= 2800, 2800).otherwise(bucketMin))
+      .groupBy("elo_bucket", "bucket_order")
+      .agg(F.count("*").as("player_count"))
+      .orderBy(F.asc("bucket_order"))
+      .select("elo_bucket", "player_count")
+
+    distribution.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/elo_distribution")
+
+    distribution.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_elo_distribution")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/GameLengthJob.scala

@@ -0,0 +1,111 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+
+object GameLengthJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-game-length"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Game Length")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .load(spark, jdbcUrl, dbUser, dbPass)
+      .select("result", "move_count")
+      .filter(F.col("result").isNotNull.and(F.col("move_count").isNotNull))
+
+    val moves = F.col("move_count")
+    val bucket = F
+      .when(moves <= 10, "1-10")
+      .when(moves <= 20, "11-20")
+      .when(moves <= 30, "21-30")
+      .when(moves <= 40, "31-40")
+      .when(moves <= 60, "41-60")
+      .when(moves <= 100, "61-100")
+      .otherwise("101+")
+    val bucketOrder = F
+      .when(moves <= 10, 1)
+      .when(moves <= 20, 2)
+      .when(moves <= 30, 3)
+      .when(moves <= 40, 4)
+      .when(moves <= 60, 5)
+      .when(moves <= 100, 6)
+      .otherwise(7)
+
+    val tagged = games
+      .withColumn("move_bucket", bucket)
+      .withColumn("bucket_order", bucketOrder)
+
+    val distribution = tagged
+      .groupBy("move_bucket", "bucket_order")
+      .agg(
+        F.count("*").as("total_games"),
+        F.sum(F.when(F.col("result") === "white", 1).otherwise(0)).as("white_wins"),
+        F.sum(F.when(F.col("result") === "black", 1).otherwise(0)).as("black_wins"),
+        F.sum(F.when(F.col("result") === "draw", 1).otherwise(0)).as("draws"),
+      )
+      .withColumn("white_win_rate", F.round(F.col("white_wins") / F.col("total_games").cast("double"), 3))
+      .withColumn("black_win_rate", F.round(F.col("black_wins") / F.col("total_games").cast("double"), 3))
+      .withColumn("draw_rate", F.round(F.col("draws") / F.col("total_games").cast("double"), 3))
+      .orderBy(F.asc("bucket_order"))
+      .drop("bucket_order")
+      .select(
+        "move_bucket",
+        "total_games",
+        "white_wins",
+        "black_wins",
+        "draws",
+        "white_win_rate",
+        "black_win_rate",
+        "draw_rate",
+      )
+
+    distribution.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/game_length_distribution")
+
+    distribution.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_game_length_distribution")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
+
+    val byResult = games
+      .groupBy("result")
+      .agg(
+        F.round(F.avg("move_count"), 1).as("avg_move_count"),
+        F.min("move_count").as("min_moves"),
+        F.max("move_count").as("max_moves"),
+      )
+      .orderBy(F.asc("result"))
+
+    byResult.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/game_length_by_result")
+
+    byResult.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_game_length_by_result")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/GameSource.scala

@@ -9,17 +9,17 @@ import org.apache.spark.sql.functions as F
   *
   * Every batch job consumes the same five-column shape:
   *   - white_id, black_id : player identifiers
-  *   - result             : one of "white", "black", "draw"
-  *   - move_count         : number of plies
-  *   - pgn                : full PGN ("[Event …]…\n\n1. e4 …"), header and movetext separated by a blank line
+  *   - result : one of "white", "black", "draw"
+  *   - move_count : number of plies
+  *   - pgn : full PGN ("[Event …]…\n\n1. e4 …"), header and movetext separated by a blank line
   *
   * Two backends, selected by the `NOWCHESS_PGN_PATH` environment variable:
   *   - unset → PostgreSQL `game_records` table (production)
-  *   - set   → a Lichess PGN dump file/URL (demo). Point it at a `lichess_db_standard_rated_*.pgn[.zst]`
-  *             to drive every batch job from real Lichess games.
+  *   - set → a Lichess PGN dump file/URL (demo). Point it at a `lichess_db_standard_rated_*.pgn[.zst]` to drive every
+  *     batch job from real Lichess games.
   *
-  * Lichess parsing uses only Spark SQL string functions — no UDFs — so Catalyst can push predicates,
-  * matching the no-UDF approach already used in OpeningBookJob.
+  * Lichess parsing uses only Spark SQL string functions — no UDFs — so Catalyst can push predicates, matching the
+  * no-UDF approach already used in OpeningBookJob.
   */
 object GameSource:
 
@@ -33,6 +33,19 @@ object GameSource:
       case Some(path) => fromLichessPgn(spark, path)
       case None       => fromJdbc(spark, jdbcUrl, dbUser, dbPass)
 
+  def loadExtended(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String): DataFrame =
+    sys.env.get(PgnPathEnv) match
+      case Some(path) => fromLichessPgnExtended(spark, path)
+      case None =>
+        fromJdbc(spark, jdbcUrl, dbUser, dbPass)
+          .withColumn("white_elo", F.lit(null).cast("int"))
+          .withColumn("black_elo", F.lit(null).cast("int"))
+          .withColumn("time_control", F.lit(null).cast("string"))
+          .withColumn("utc_date", F.lit(null).cast("string"))
+          .withColumn("utc_time", F.lit(null).cast("string"))
+          .withColumn("termination", F.lit(null).cast("string"))
+          .withColumn("eco", F.lit(null).cast("string"))
+
   def fromJdbc(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String): DataFrame =
     spark.read
       .format("jdbc")
@@ -48,16 +61,16 @@ object GameSource:
   /** Parses a Lichess PGN dump into the normalised game shape.
     *
     * `path` may be:
-    *   - an http(s)/ftp URL — fetched once via SparkContext.addFile and distributed to executors, then read
-    *     from the local replica (no S3/PVC needed; handy for a staging demo)
+    *   - an http(s)/ftp URL — fetched once via SparkContext.addFile and distributed to executors, then read from the
+    *     local replica (no S3/PVC needed; handy for a staging demo)
     *   - any Hadoop-readable path (file://, hdfs://, s3a://, …)
     *
-    * `.zst` dumps (Lichess' native format) are decompressed in-process via zstd-jni; `.gz`/`.bz2` are
-    * handled by Spark's text reader codecs.
+    * `.zst` dumps (Lichess' native format) are decompressed in-process via zstd-jni; `.gz`/`.bz2` are handled by
+    * Spark's text reader codecs.
     *
-    * Records are split on the "[Event " tag that opens every game, so each row holds one complete game
-    * (the empty fragment before the first game is filtered out). Header tags are read with regexp_extract;
-    * the movetext (after the blank line) is cleaned of clock/eval comments and move numbers to count plies.
+    * Records are split on the "[Event " tag that opens every game, so each row holds one complete game (the empty
+    * fragment before the first game is filtered out). Header tags are read with regexp_extract; the movetext (after the
+    * blank line) is cleaned of clock/eval comments and move numbers to count plies.
     */
   def fromLichessPgn(spark: SparkSession, path: String): DataFrame =
     val resolved = resolvePath(spark, path)
@@ -89,31 +102,85 @@ object GameSource:
       )
       .filter((F.col("white_id") =!= "").and(F.col("black_id") =!= ""))
 
-  /** Turns an http(s)/ftp URL into a cluster-local path by fetching it once with SparkContext.addFile,
-    * which distributes the file to every executor. `.zst` is decompressed in-process and the plain `.pgn`
-    * is redistributed. Non-URL paths are returned unchanged.
+  private def fromLichessPgnExtended(spark: SparkSession, path: String): DataFrame =
+    val resolved = resolvePath(spark, path)
+    val record   = F.col("value")
+
+    val resultTag = F.regexp_extract(record, "Result \"([^\"]*)\"", 1)
+    val result = F
+      .when(resultTag === "1-0", "white")
+      .when(resultTag === "0-1", "black")
+      .when(resultTag === "1/2-1/2", "draw")
+      .otherwise(F.lit(null).cast("string"))
+
+    val moveText  = F.coalesce(F.split(record, "\n\n").getItem(1), F.lit(""))
+    val noComment = F.regexp_replace(moveText, "\\{[^}]*\\}", "")
+    val noResult  = F.regexp_replace(noComment, "(1-0|0-1|1/2-1/2|\\*)", "")
+    val noNumbers = F.regexp_replace(noResult, "\\d+\\.+", " ")
+    val plies     = F.size(F.filter(F.split(F.trim(noNumbers), "\\s+"), tok => F.length(tok) > 0))
+
+    def nullable(extracted: org.apache.spark.sql.Column): org.apache.spark.sql.Column =
+      F.when(F.length(extracted) > 0, extracted).otherwise(F.lit(null).cast("string"))
+
+    val whiteElo = nullable(F.regexp_extract(record, "WhiteElo \"([^\"]*)\"", 1)).cast("int")
+    val blackElo = nullable(F.regexp_extract(record, "BlackElo \"([^\"]*)\"", 1)).cast("int")
+
+    spark.read
+      .option("lineSep", "[Event ")
+      .text(resolved)
+      .filter(F.length(F.trim(record)) > 0)
+      .select(
+        F.regexp_extract(record, "White \"([^\"]*)\"", 1).as("white_id"),
+        F.regexp_extract(record, "Black \"([^\"]*)\"", 1).as("black_id"),
+        result.as("result"),
+        plies.as("move_count"),
+        F.concat(F.lit("[Event "), record).as("pgn"),
+        whiteElo.as("white_elo"),
+        blackElo.as("black_elo"),
+        nullable(F.regexp_extract(record, "TimeControl \"([^\"]*)\"", 1)).as("time_control"),
+        nullable(F.regexp_extract(record, "UTCDate \"([^\"]*)\"", 1)).as("utc_date"),
+        nullable(F.regexp_extract(record, "UTCTime \"([^\"]*)\"", 1)).as("utc_time"),
+        nullable(F.regexp_extract(record, "Termination \"([^\"]*)\"", 1)).as("termination"),
+        nullable(F.regexp_extract(record, "ECO \"([^\"]*)\"", 1)).as("eco"),
+      )
+      .filter((F.col("white_id") =!= "").and(F.col("black_id") =!= ""))
+
+  /** Turns an http(s)/ftp URL into a path readable by all executors.
+    *
+    * Downloads the file once on the driver, decompresses `.zst` if needed, then writes the result to
+    * `NOWCHESS_PGN_CACHE_DIR` (default `/tmp`). That directory must be on a filesystem shared between the driver pod
+    * and all executor pods — in the k8s deployment this is the `spark-analytics-output` PVC mounted at
+    * `/spark-output`, so set `NOWCHESS_PGN_CACHE_DIR=/spark-output/.pgn-cache`.
+    *
+    * Skips download if the destination file already exists (cache-friendly for repeated runs).
+    * Non-URL paths are returned unchanged.
     */
   private def resolvePath(spark: SparkSession, path: String): String =
     if !path.matches("^(https?|ftp)://.*") then path
     else
-      spark.sparkContext.addFile(path)
-      val local = SparkFiles.get(baseName(path))
-      if !local.endsWith(".zst") then "file://" + local
-      else distribute(spark, decompressZstd(local))
+      val cacheDir = sys.env.getOrElse("NOWCHESS_PGN_CACHE_DIR", "/tmp")
+      val destName = baseName(path).stripSuffix(".zst")
+      val destPath = s"$cacheDir/$destName"
+      if !java.io.File(destPath).exists() then
+        spark.sparkContext.addFile(path)
+        val downloaded = SparkFiles.get(baseName(path))
+        if downloaded.endsWith(".zst") then decompressZstd(downloaded, destPath)
+        else
+          java.io.File(destPath).getParentFile.mkdirs()
+          java.nio.file.Files.copy(
+            java.nio.file.Paths.get(downloaded),
+            java.io.File(destPath).toPath,
+            java.nio.file.StandardCopyOption.REPLACE_EXISTING,
+          )
+      "file://" + destPath
 
   private def baseName(path: String): String = path.substring(path.lastIndexOf('/') + 1)
 
-  private def distribute(spark: SparkSession, localPath: String): String =
-    spark.sparkContext.addFile("file://" + localPath)
-    "file://" + SparkFiles.get(baseName(localPath))
-
-  /** Decompresses a `.zst` file to a temp `.pgn` using zstd-jni (bundled with Spark at runtime). */
-  private def decompressZstd(srcPath: String): String =
-    val out = java.io.File.createTempFile("lichess-", ".pgn")
-    out.deleteOnExit()
+  /** Decompresses a `.zst` file to `destPath` using zstd-jni (bundled with Spark at runtime). */
+  private def decompressZstd(srcPath: String, destPath: String): Unit =
+    java.io.File(destPath).getParentFile.mkdirs()
     val in = com.github.luben.zstd.ZstdInputStream(
       java.io.BufferedInputStream(java.io.FileInputStream(srcPath)),
     )
-    try java.nio.file.Files.copy(in, out.toPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING)
+    try java.nio.file.Files.copy(in, java.io.File(destPath).toPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING)
     finally in.close()
-    out.getAbsolutePath

modules/analytics/src/main/scala/de/nowchess/analytics/OpeningBookJob.scala

@@ -72,16 +72,15 @@ object OpeningBookJob:
       .option("header", "true")
       .csv(s"$outputDir/opening_book_top1000")
 
-    if !GameSource.isPgnMode then
-      top1000.write
-        .mode("overwrite")
-        .format("jdbc")
-        .option("url", jdbcUrl)
-        .option("dbtable", "analytics_opening_stats")
-        .option("user", dbUser)
-        .option("password", dbPass)
-        .option("driver", "org.postgresql.Driver")
-        .save()
+    top1000.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_opening_stats")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
 
   /** Extracts the first `maxPlies` moves from a PGN column as a space-separated string.
     *

modules/analytics/src/main/scala/de/nowchess/analytics/PlayerClusteringJob.scala

@@ -119,26 +119,25 @@ object PlayerClusteringJob:
       .option("header", "true")
       .csv(s"$outputDir/cluster_archetypes")
 
-    if !GameSource.isPgnMode then
-      clustersDf.write
-        .mode("overwrite")
-        .format("jdbc")
-        .option("url", jdbcUrl)
-        .option("dbtable", "analytics_player_clusters")
-        .option("user", dbUser)
-        .option("password", dbPass)
-        .option("driver", "org.postgresql.Driver")
-        .save()
+    clustersDf.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_player_clusters")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
 
-      archetypes.write
-        .mode("overwrite")
-        .format("jdbc")
-        .option("url", jdbcUrl)
-        .option("dbtable", "analytics_cluster_archetypes")
-        .option("user", dbUser)
-        .option("password", dbPass)
-        .option("driver", "org.postgresql.Driver")
-        .save()
+    archetypes.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_cluster_archetypes")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
 
   private def buildPlayerStats(games: org.apache.spark.sql.DataFrame): org.apache.spark.sql.DataFrame =
     val asWhite = games.select(

modules/analytics/src/main/scala/de/nowchess/analytics/PlayerGraphJob.scala

@@ -109,16 +109,15 @@ object PlayerGraphJob:
       .mode("overwrite")
       .parquet(s"$outputDir/player_graph")
 
-    if !GameSource.isPgnMode then
-      result.write
-        .mode("overwrite")
-        .format("jdbc")
-        .option("url", jdbcUrl)
-        .option("dbtable", "analytics_player_graph")
-        .option("user", dbUser)
-        .option("password", dbPass)
-        .option("driver", "org.postgresql.Driver")
-        .save()
+    result.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_player_graph")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
 
     // How many players belong to each connected component?
     // A large dominant component + many singletons is the expected shape.
@@ -135,6 +134,16 @@ object PlayerGraphJob:
       .option("header", "true")
       .csv(s"$outputDir/component_sizes")
 
+    componentSizes.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_component_sizes")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()
+
   // Build a two-column DataFrame (vertex_id: Long, valueCol: valueType) from an RDD.
   // Used to bridge GraphX RDD results into the DataFrame API without implicits.
   private def rddToFrame[T](

modules/analytics/src/main/scala/de/nowchess/analytics/PlayerStatsJob.scala

@@ -77,13 +77,17 @@ object PlayerStatsJob:
       .mode("overwrite")
       .parquet(s"$outputDir/player_stats")
 
-    if !GameSource.isPgnMode then
-      stats.write
-        .mode("overwrite")
-        .format("jdbc")
-        .option("url", jdbcUrl)
-        .option("dbtable", "analytics_player_stats")
-        .option("user", dbUser)
-        .option("password", dbPass)
-        .option("driver", "org.postgresql.Driver")
-        .save()
+    stats.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/player_stats_csv")
+
+    stats.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_player_stats")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/RatingMismatchJob.scala

@@ -0,0 +1,75 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+
+object RatingMismatchJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-rating-mismatch"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Rating Mismatch")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .loadExtended(spark, jdbcUrl, dbUser, dbPass)
+      .select("result", "white_elo", "black_elo")
+      .filter(F.col("white_elo").isNotNull.and(F.col("black_elo").isNotNull))
+
+    val eloDiff = F.col("white_elo") - F.col("black_elo")
+    val bracket = F
+      .when(eloDiff < -200, "Black +200")
+      .when(eloDiff < -100, "Black +100–200")
+      .when(eloDiff < -50, "Black +50–100")
+      .when(eloDiff <= 50, "Even (±50)")
+      .when(eloDiff <= 100, "White +50–100")
+      .when(eloDiff <= 200, "White +100–200")
+      .otherwise("White +200")
+    val bracketOrder = F
+      .when(eloDiff < -200, 1)
+      .when(eloDiff < -100, 2)
+      .when(eloDiff < -50, 3)
+      .when(eloDiff <= 50, 4)
+      .when(eloDiff <= 100, 5)
+      .when(eloDiff <= 200, 6)
+      .otherwise(7)
+
+    val stats = games
+      .withColumn("elo_diff", eloDiff)
+      .withColumn("bracket", bracket)
+      .withColumn("bracket_order", bracketOrder)
+      .groupBy("bracket", "bracket_order")
+      .agg(
+        F.count("*").as("total_games"),
+        F.sum(F.when(F.col("result") === "white", 1).otherwise(0)).as("white_wins"),
+        F.sum(F.when(F.col("result") === "black", 1).otherwise(0)).as("black_wins"),
+        F.sum(F.when(F.col("result") === "draw", 1).otherwise(0)).as("draws"),
+      )
+      .withColumn("white_win_rate", F.round(F.col("white_wins") / F.col("total_games").cast("double"), 3))
+      .orderBy(F.asc("bracket_order"))
+      .drop("bracket_order")
+      .select("bracket", "total_games", "white_wins", "black_wins", "draws", "white_win_rate")
+
+    stats.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/rating_mismatch")
+
+    stats.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_rating_mismatch")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/TerminationStatsJob.scala

@@ -0,0 +1,54 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+
+object TerminationStatsJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-termination-stats"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Termination Stats")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .loadExtended(spark, jdbcUrl, dbUser, dbPass)
+      .select("result", "termination")
+      .filter(F.col("termination").isNotNull.and(F.col("termination") =!= ""))
+
+    val stats = games
+      .groupBy("termination")
+      .agg(
+        F.count("*").as("total_games"),
+        F.sum(F.when(F.col("result") === "white", 1).otherwise(0)).as("white_wins"),
+        F.sum(F.when(F.col("result") === "black", 1).otherwise(0)).as("black_wins"),
+        F.sum(F.when(F.col("result") === "draw", 1).otherwise(0)).as("draws"),
+      )
+      .withColumn("draw_rate", F.round(F.col("draws") / F.col("total_games").cast("double"), 3))
+      .withColumnRenamed("termination", "termination_type")
+      .orderBy(F.desc("total_games"))
+      .select("termination_type", "total_games", "white_wins", "black_wins", "draws", "draw_rate")
+
+    stats.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/termination_stats")
+
+    stats.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_termination_stats")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/src/main/scala/de/nowchess/analytics/TimeControlJob.scala

@@ -0,0 +1,68 @@
+package de.nowchess.analytics
+
+import org.apache.spark.sql.SparkSession
+import org.apache.spark.sql.functions as F
+
+object TimeControlJob:
+
+  def main(args: Array[String]): Unit =
+    val jdbcUrl   = sys.env.getOrElse("NOWCHESS_JDBC_URL", "jdbc:postgresql://localhost:5432/nowchess")
+    val dbUser    = sys.env.getOrElse("NOWCHESS_DB_USER", "nowchess")
+    val dbPass    = sys.env.getOrElse("NOWCHESS_DB_PASS", "nowchess")
+    val outputDir = if args.length > 0 then args(0) else "/tmp/nowchess-time-control"
+
+    val spark = SparkSession
+      .builder()
+      .appName("NowChess Time Control")
+      .getOrCreate()
+
+    run(spark, jdbcUrl, dbUser, dbPass, outputDir)
+    spark.stop()
+
+  def run(spark: SparkSession, jdbcUrl: String, dbUser: String, dbPass: String, outputDir: String): Unit =
+    val games = GameSource
+      .loadExtended(spark, jdbcUrl, dbUser, dbPass)
+      .select("result", "time_control")
+      .filter(
+        F.col("time_control").isNotNull
+          .and(F.col("time_control") =!= "")
+          .and(F.col("time_control") =!= "-"),
+      )
+
+    val baseSeconds = F.regexp_extract(F.col("time_control"), "^(?:\\d+/)?(\\d+)", 1).cast("int")
+    val category = F
+      .when(baseSeconds < 30, "UltraBullet")
+      .when(baseSeconds < 180, "Bullet")
+      .when(baseSeconds < 480, "Blitz")
+      .when(baseSeconds < 1500, "Rapid")
+      .when(baseSeconds < 86400, "Classical")
+      .otherwise("Correspondence")
+
+    val stats = games
+      .withColumn("category", category)
+      .groupBy("category")
+      .agg(
+        F.count("*").as("total_games"),
+        F.sum(F.when(F.col("result") === "white", 1).otherwise(0)).as("white_wins"),
+        F.sum(F.when(F.col("result") === "black", 1).otherwise(0)).as("black_wins"),
+        F.sum(F.when(F.col("result") === "draw", 1).otherwise(0)).as("draws"),
+      )
+      .withColumn("white_win_rate", F.round(F.col("white_wins") / F.col("total_games").cast("double"), 3))
+      .withColumn("draw_rate", F.round(F.col("draws") / F.col("total_games").cast("double"), 3))
+      .orderBy(F.desc("total_games"))
+      .select("category", "total_games", "white_wins", "black_wins", "draws", "white_win_rate", "draw_rate")
+
+    stats.write
+      .mode("overwrite")
+      .option("header", "true")
+      .csv(s"$outputDir/time_control_stats")
+
+    stats.write
+      .mode("overwrite")
+      .format("jdbc")
+      .option("url", jdbcUrl)
+      .option("dbtable", "analytics_time_control_stats")
+      .option("user", dbUser)
+      .option("password", dbPass)
+      .option("driver", "org.postgresql.Driver")
+      .save()

modules/analytics/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=3
+MINOR=7
 PATCH=0

modules/api/CHANGELOG.md

@@ -205,3 +205,25 @@
 
 * **dependencies:** correct Jackson databind dependency group ID ([008d72d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/008d72d826707c04205bac7de25170fae5fed861))
 * IO microservice ([#38](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/38)) ([a386f57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a386f57c21d34ead6cc6f92836c52b714597e289))
+##  (2026-06-21)
+
+### Features
+
+* **api:** define shared EventEnvelope and EventType for Redis EventBus ([#61](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/61)) ([595c172](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/595c172900da99de367c274488c3ccbeaef55882))
+* **core:** publish GameOver event to Redis Streams ([#64](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/64)) ([676e411](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/676e4110c0893917d8bc7f836db6a19c69c5e9a5))
+* **dto:** update GameWritebackEventDto for JSON deserialization and remove unused mixin ([576e3fe](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/576e3fea9bf1082549ea53efd3288474c42be93d))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* **game:** add GET /{gameId}/fen-history endpoint ([fba324a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fba324a5b01c23f97e28621ad8b72265701e0f11))
+* NCS-13 Implement Threefold Repetition ([#31](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/31)) ([767d305](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/767d3051a76c266050b6335774d66e2db2273c16))
+* NCS-14 implemented insufficient moves rule ([#30](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/30)) ([b0399a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/b0399a4e489950083066c9538df9a84dcc7a4613))
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+* NCS-25 Add linters to keep quality up ([#27](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/27)) ([fd4e67d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fd4e67d4f782a7e955822d90cb909d0a81676fb2))
+* NCS-37 Quarkus integration ([#35](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/35)) ([f088c4e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f088c4e9ffcc498d3d1b6f01e8f50042d5830d55))
+* NCS-41 Bot Platform ([#33](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/33)) ([8744bee](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8744bee2dd20966dae90a09c21a43d5b06f59e00))
+* **rule:** Rules as a microservice ([#39](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/39)) ([093134d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/093134d36c6844ba02a36a28d5d044f09291cd1d))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+
+### Bug Fixes
+
+* **dependencies:** correct Jackson databind dependency group ID ([008d72d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/008d72d826707c04205bac7de25170fae5fed861))
+* IO microservice ([#38](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/38)) ([a386f57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a386f57c21d34ead6cc6f92836c52b714597e289))

modules/api/src/main/scala/de/nowchess/api/dto/FenHistoryDto.scala

@@ -0,0 +1,3 @@
+package de.nowchess.api.dto
+
+final case class FenHistoryDto(fens: List[String])

modules/api/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=17
+MINOR=18
 PATCH=0

modules/core/CHANGELOG.md

@@ -2109,3 +2109,149 @@
 
 * Revert "feat: add authentication permissions for metrics endpoints in application.yml" ([a298417](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a298417b9e4d68dc73bbf40be63d9484536e9f83))
 * Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
+##  (2026-06-21)
+
+### Features
+
+* add authentication permissions for metrics endpoints in application.yml ([04edd4d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/04edd4d6fd8a63196c36f6d67992832febc9bebb))
+* add CORS configuration and reorder JWT settings in application.yml ([a49f9be](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a49f9be146f04c14561c305d980846a92f8c12b2))
+* add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
+* add initialization metrics for various services ([d438e97](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d438e97f32bdde0bfc63c1b4a8cc810cdd093166))
+* add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
+* add OpenTelemetry trace configuration with parentbased sampler ([3904d5a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3904d5ad8ad4930ddee65287a7bfab785a6148f5))
+* **config:** add GameWritebackEventDto to reflection targets ([87f29a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/87f29a720422f538ef70699533500e060337b8ea))
+* **config:** update application.yml for PostgreSQL and remove staging/production configurations ([2404e61](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2404e6164c3b50ffccbea5238d636060d6abe4d6))
+* **config:** update application.yml for staging and production environments ([6113432](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6113432a14c476a3a0dfc0d449e17d023697f2ba))
+* configure logging and add OpenTelemetry support ([#49](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/49)) ([d57c488](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d57c4886612d1d92da0e1b79209fc83e6ef537a1))
+* **core:** publish GameOver event to Redis Streams ([#64](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/64)) ([676e411](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/676e4110c0893917d8bc7f836db6a19c69c5e9a5))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* **game:** add GET /{gameId}/fen-history endpoint ([fba324a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fba324a5b01c23f97e28621ad8b72265701e0f11))
+* implement clock expiry scanning and handling for game records ([#53](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/53)) ([8f9eb12](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8f9eb12f663efabe4dc72b94394438652ad0ef02))
+* implement GameRules with isInCheck, legalMoves, gameStatus ([94a02ff](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/94a02ff6849436d9496c70a0f16c21666dae8e4e))
+* implement legal castling ([#1](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/1)) ([00d326c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/00d326c1ba67711fbe180f04e1100c3f01dd0254))
+* implement periodic scaling checks and enhance instance management in AutoScaler ([3f12f69](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3f12f695f132b92f634d98df2c037292498b6e86))
+* **logging:** add DEBUG/INFO/WARN logging across services (NCS-72) ([#41](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/41)) ([804a4bf](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/804a4bf179e3dfb19e2be4390e7e543caf5237c6))
+* NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
+* NCS-11 50-move rule ([#9](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/9)) ([412ed98](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/412ed986a95703a3b282276540153480ceed229d))
+* NCS-13 Implement Threefold Repetition ([#31](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/31)) ([767d305](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/767d3051a76c266050b6335774d66e2db2273c16))
+* NCS-14 implemented insufficient moves rule ([#30](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/30)) ([b0399a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/b0399a4e489950083066c9538df9a84dcc7a4613))
+* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
+* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+* NCS-25 Add linters to keep quality up ([#27](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/27)) ([fd4e67d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fd4e67d4f782a7e955822d90cb909d0a81676fb2))
+* NCS-37 Quarkus integration ([#35](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/35)) ([f088c4e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f088c4e9ffcc498d3d1b6f01e8f50042d5830d55))
+* NCS-40 Rework Draw System ([#34](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/34)) ([33e785d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/33e785d22af87724839b62ae91dfe74a05b398c3))
+* NCS-41 Bot Platform ([#33](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/33)) ([8744bee](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8744bee2dd20966dae90a09c21a43d5b06f59e00))
+* NCS-53 changed IO to MicroService for easier scaling ([#37](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/37)) ([b5a2966](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/b5a2966adafa9650f0f7d601bdeb8fdd13710327))
+* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
+* NCS-78 Add Traceability to the Applications ([#48](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/48)) ([c96a09b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c96a09bb5cee59fc23205bb63baa8b217a7e1b00))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
+* **redis:** implement game writeback stream processing with error handling and retries ([ae3ef76](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/ae3ef766e8b7596a09e466cd4fb386119f17ca5c))
+* **reflection:** add native reflection configuration for tournament classes ([e318250](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e31825021c0fca7cbe7d9f85755646114c83cf0c))
+* **rule:** Rules as a microservice ([#39](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/39)) ([093134d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/093134d36c6844ba02a36a28d5d044f09291cd1d))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+* update application.yml with new API root paths and add Micrometer and OpenTelemetry dependencies ([72ce262](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/72ce262bc491f94297700e6002fb5d0812e2cc2a))
+* wire check/checkmate/stalemate into processMove and gameLoop ([5264a22](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5264a225418b885c5e6ea6411b96f85e38837f6c))
+
+### Bug Fixes
+
+* add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
+* **auth:** change InternalAuthFilter to use @Singleton and add HTTP tests for secret validation ([c08d530](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c08d5303eb9e70d36c8eebf6a061ccb71e118fe5))
+* **auth:** update InternalAuthFilter to use @ApplicationScoped and add index-dependency configuration ([6e0fd95](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6e0fd9523e001756ce7109e639ebb54be4fcdabf))
+* **core:** add logs to trace subscribeGame call in createGame ([f5614c3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f5614c358255598ba1230e42a56b22934d79183c))
+* correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
+* **heartbeat:** inject ObjectMapper into InstanceHeartbeatService ([#42](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/42)) ([0c98151](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0c981517da1f94cd10ae396e47bde2b35d0b3ba0))
+* IO microservice ([#38](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/38)) ([a386f57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a386f57c21d34ead6cc6f92836c52b714597e289))
+* Lints ([dc224ab](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/dc224abe26acf5361c56956006e1cc51b75b0b7e))
+* NCS-84 More Verbose Logging ([#51](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/51)) ([4ad92ab](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/4ad92ab23698267f8faa59c4e18388d4a0042cca))
+* NCS-85 Database Writeback fails without Logs ([#52](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/52)) ([7323908](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/73239088d985f01aa6b1067ed9097a845e471d4f))
+* **pgn:** add SAN disambiguation and check/checkmate suffixes [NCS-42] ([#56](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/56)) ([2579539](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2579539084152178f4482ddb7b84b7f1162f10da))
+* **redis:** add max pool wait time and switch to ReactiveRedisDataSource for heartbeat updates ([33e5017](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/33e5017f51a998327b180f778f73964cc10c05d3))
+* **redis:** enhance GameRedisSubscriberManager to use ReactiveRedisDataSource and improve subscription handling ([0eb752d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0eb752d4935377f75aab710b7f4eda4b29098e6a))
+* **redis:** prevent concurrent Redis heartbeat refreshes using AtomicBoolean ([847b132](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/847b13202cb909d18ca3304c27ebe17ce2312b8e))
+* **redis:** simplify refreshRedisHeartbeat logic and ensure proper error handling ([1813ea1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1813ea1d2d5d093f7925f87371b5e29820bf1136))
+* **redis:** update Redis configuration with max pool size and waiting parameters ([5baf6a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5baf6a7cdbea484fc49c02e2b5a1c3919b7fa2c4))
+* remove unused HTTP root-path configurations from application.yml ([3ed3e59](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ed3e59ee456d54cd3d65ece4f36623e256b9736))
+* resolve 6 coordinator bugs (cache eviction, rebalance race, pod matching, lookup inefficiency) ([5619c82](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5619c8223ad7091706909eda8c907a29d215fd30))
+* update documentation to reflect new functions in CoordinatorGrpcServer and InstanceRegistry ([f7ce4df](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f7ce4df595cbdc2ef84122781f4851ff140c0f44))
+* update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
+* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
+
+### Reverts
+
+* Revert "feat: add authentication permissions for metrics endpoints in application.yml" ([a298417](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a298417b9e4d68dc73bbf40be63d9484536e9f83))
+* Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
+##  (2026-06-21)
+
+### Features
+
+* add authentication permissions for metrics endpoints in application.yml ([04edd4d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/04edd4d6fd8a63196c36f6d67992832febc9bebb))
+* add CORS configuration and reorder JWT settings in application.yml ([a49f9be](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a49f9be146f04c14561c305d980846a92f8c12b2))
+* add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
+* add initialization metrics for various services ([d438e97](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d438e97f32bdde0bfc63c1b4a8cc810cdd093166))
+* add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
+* add OpenTelemetry trace configuration with parentbased sampler ([3904d5a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3904d5ad8ad4930ddee65287a7bfab785a6148f5))
+* **config:** add GameWritebackEventDto to reflection targets ([87f29a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/87f29a720422f538ef70699533500e060337b8ea))
+* **config:** update application.yml for PostgreSQL and remove staging/production configurations ([2404e61](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2404e6164c3b50ffccbea5238d636060d6abe4d6))
+* **config:** update application.yml for staging and production environments ([6113432](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6113432a14c476a3a0dfc0d449e17d023697f2ba))
+* configure logging and add OpenTelemetry support ([#49](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/49)) ([d57c488](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d57c4886612d1d92da0e1b79209fc83e6ef537a1))
+* **core:** publish GameOver event to Redis Streams ([#64](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/64)) ([676e411](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/676e4110c0893917d8bc7f836db6a19c69c5e9a5))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* **game:** add GET /{gameId}/fen-history endpoint ([fba324a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fba324a5b01c23f97e28621ad8b72265701e0f11))
+* implement clock expiry scanning and handling for game records ([#53](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/53)) ([8f9eb12](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8f9eb12f663efabe4dc72b94394438652ad0ef02))
+* implement GameRules with isInCheck, legalMoves, gameStatus ([94a02ff](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/94a02ff6849436d9496c70a0f16c21666dae8e4e))
+* implement legal castling ([#1](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/1)) ([00d326c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/00d326c1ba67711fbe180f04e1100c3f01dd0254))
+* implement periodic scaling checks and enhance instance management in AutoScaler ([3f12f69](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3f12f695f132b92f634d98df2c037292498b6e86))
+* **logging:** add DEBUG/INFO/WARN logging across services (NCS-72) ([#41](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/41)) ([804a4bf](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/804a4bf179e3dfb19e2be4390e7e543caf5237c6))
+* NCS-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
+* NCS-11 50-move rule ([#9](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/9)) ([412ed98](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/412ed986a95703a3b282276540153480ceed229d))
+* NCS-13 Implement Threefold Repetition ([#31](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/31)) ([767d305](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/767d3051a76c266050b6335774d66e2db2273c16))
+* NCS-14 implemented insufficient moves rule ([#30](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/30)) ([b0399a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/b0399a4e489950083066c9538df9a84dcc7a4613))
+* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
+* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
+* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
+* NCS-25 Add linters to keep quality up ([#27](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/27)) ([fd4e67d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/fd4e67d4f782a7e955822d90cb909d0a81676fb2))
+* NCS-37 Quarkus integration ([#35](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/35)) ([f088c4e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f088c4e9ffcc498d3d1b6f01e8f50042d5830d55))
+* NCS-40 Rework Draw System ([#34](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/34)) ([33e785d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/33e785d22af87724839b62ae91dfe74a05b398c3))
+* NCS-41 Bot Platform ([#33](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/33)) ([8744bee](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8744bee2dd20966dae90a09c21a43d5b06f59e00))
+* NCS-53 changed IO to MicroService for easier scaling ([#37](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/37)) ([b5a2966](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/b5a2966adafa9650f0f7d601bdeb8fdd13710327))
+* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
+* NCS-78 Add Traceability to the Applications ([#48](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/48)) ([c96a09b](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c96a09bb5cee59fc23205bb63baa8b217a7e1b00))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
+* **redis:** implement game writeback stream processing with error handling and retries ([ae3ef76](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/ae3ef766e8b7596a09e466cd4fb386119f17ca5c))
+* **reflection:** add native reflection configuration for tournament classes ([e318250](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e31825021c0fca7cbe7d9f85755646114c83cf0c))
+* **rule:** Rules as a microservice ([#39](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/39)) ([093134d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/093134d36c6844ba02a36a28d5d044f09291cd1d))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+* update application.yml with new API root paths and add Micrometer and OpenTelemetry dependencies ([72ce262](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/72ce262bc491f94297700e6002fb5d0812e2cc2a))
+* wire check/checkmate/stalemate into processMove and gameLoop ([5264a22](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5264a225418b885c5e6ea6411b96f85e38837f6c))
+
+### Bug Fixes
+
+* add missing kings to gameLoop capture test board ([aedd787](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/aedd787b77203c2af934751dba7b784eaf165032))
+* **auth:** change InternalAuthFilter to use @Singleton and add HTTP tests for secret validation ([c08d530](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c08d5303eb9e70d36c8eebf6a061ccb71e118fe5))
+* **auth:** update InternalAuthFilter to use @ApplicationScoped and add index-dependency configuration ([6e0fd95](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6e0fd9523e001756ce7109e639ebb54be4fcdabf))
+* **core:** add logs to trace subscribeGame call in createGame ([f5614c3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f5614c358255598ba1230e42a56b22934d79183c))
+* correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
+* **heartbeat:** inject ObjectMapper into InstanceHeartbeatService ([#42](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/42)) ([0c98151](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0c981517da1f94cd10ae396e47bde2b35d0b3ba0))
+* IO microservice ([#38](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/38)) ([a386f57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a386f57c21d34ead6cc6f92836c52b714597e289))
+* Lints ([dc224ab](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/dc224abe26acf5361c56956006e1cc51b75b0b7e))
+* NCS-84 More Verbose Logging ([#51](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/51)) ([4ad92ab](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/4ad92ab23698267f8faa59c4e18388d4a0042cca))
+* NCS-85 Database Writeback fails without Logs ([#52](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/52)) ([7323908](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/73239088d985f01aa6b1067ed9097a845e471d4f))
+* **pgn:** add SAN disambiguation and check/checkmate suffixes [NCS-42] ([#56](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/56)) ([2579539](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2579539084152178f4482ddb7b84b7f1162f10da))
+* **redis:** add max pool wait time and switch to ReactiveRedisDataSource for heartbeat updates ([33e5017](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/33e5017f51a998327b180f778f73964cc10c05d3))
+* **redis:** enhance GameRedisSubscriberManager to use ReactiveRedisDataSource and improve subscription handling ([0eb752d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/0eb752d4935377f75aab710b7f4eda4b29098e6a))
+* **redis:** prevent concurrent Redis heartbeat refreshes using AtomicBoolean ([847b132](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/847b13202cb909d18ca3304c27ebe17ce2312b8e))
+* **redis:** simplify refreshRedisHeartbeat logic and ensure proper error handling ([1813ea1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1813ea1d2d5d093f7925f87371b5e29820bf1136))
+* **redis:** update Redis configuration with max pool size and waiting parameters ([5baf6a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5baf6a7cdbea484fc49c02e2b5a1c3919b7fa2c4))
+* remove unused HTTP root-path configurations from application.yml ([3ed3e59](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ed3e59ee456d54cd3d65ece4f36623e256b9736))
+* resolve 6 coordinator bugs (cache eviction, rebalance race, pod matching, lookup inefficiency) ([5619c82](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5619c8223ad7091706909eda8c907a29d215fd30))
+* update documentation to reflect new functions in CoordinatorGrpcServer and InstanceRegistry ([f7ce4df](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f7ce4df595cbdc2ef84122781f4851ff140c0f44))
+* update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
+* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
+
+### Reverts
+
+* Revert "feat: add authentication permissions for metrics endpoints in application.yml" ([a298417](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a298417b9e4d68dc73bbf40be63d9484536e9f83))
+* Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))

modules/core/src/main/scala/de/nowchess/chess/resource/GameResource.scala

@@ -339,6 +339,18 @@ class GameResource:
     log.infof("Imported PGN game %s", entry.gameId)
     created(GameDtoMapper.toGameFullDto(entry, ioClient))
 
+  @GET
+  @Path("/{gameId}/fen-history")
+  @Produces(Array(MediaType.APPLICATION_JSON))
+  def getFenHistory(@PathParam("gameId") gameId: String): Response =
+    val entry    = registry.get(gameId).getOrElse(throw GameNotFoundException(gameId))
+    val engine   = entry.engine
+    val initial  = engine.initialContext
+    val moves    = engine.context.moves
+    val contexts = moves.scanLeft(initial)((ctx, move) => engine.ruleSet.applyMove(ctx)(move))
+    val fens     = contexts.map(ctx => ioClient.exportFen(ctx))
+    ok(FenHistoryDto(fens))
+
   @GET
   @Path("/{gameId}/export/fen")
   @Produces(Array(MediaType.TEXT_PLAIN))

modules/core/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=51
+MINOR=53
 PATCH=0

modules/official-bots/CHANGELOG.md

@@ -340,3 +340,98 @@
 ### Reverts
 
 * Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
+##  (2026-06-21)
+
+### Features
+
+* add initialization metrics for various services ([d438e97](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d438e97f32bdde0bfc63c1b4a8cc810cdd093166))
+* add OpenTelemetry trace configuration with parentbased sampler ([3904d5a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3904d5ad8ad4930ddee65287a7bfab785a6148f5))
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* **config:** update application.yml for PostgreSQL and remove staging/production configurations ([2404e61](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2404e6164c3b50ffccbea5238d636060d6abe4d6))
+* **config:** update application.yml for staging and production environments ([6113432](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6113432a14c476a3a0dfc0d449e17d023697f2ba))
+* configure logging and add OpenTelemetry support ([#49](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/49)) ([d57c488](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d57c4886612d1d92da0e1b79209fc83e6ef537a1))
+* **docker:** add .dockerignore and .gitignore files for build exclusions ([c987d8e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c987d8e258c0e6c4cfbdaa8381c64c410d7a2b83))
+* **docker:** add Dockerfiles for building Quarkus application in native and JVM modes ([3f2d2bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3f2d2bb4c97fa8cddba66e1da4427c54236dfeed))
+* **docker:** add Dockerfiles for Quarkus application in JVM and native modes ([34b9933](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/34b993304670cf2aa62cd2f6460cee7b9864b08e))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* NCS-78 Add Traceability to the Applications ([#46](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/46)) ([649566e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/649566eb3fcf38f91c8896a739f74ea318af312d))
+* NCS-78 Add Traceability to the Applications ([#47](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/47)) ([87dfc6c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/87dfc6c2bcce7f7d58fc641bd8d468a2e584c108))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **official-bots:** consume GameOver stream for bot cleanup ([#67](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/67)) ([db9d153](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/db9d1533912f4b41c4d1ca80ccffdde5d23d6ff6))
+* **official-bots:** park expert bot on tournament server at startup ([#75](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/75)) ([30295a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/30295a4bb95855ee8261c92278bb9ebc80ee12ee))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+
+### Bug Fixes
+
+* enable official bots to connect to external tournament server ([#71](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/71)) ([688d30e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/688d30e2b10026923372be5fca3c63eaaee2de2a))
+* **official-bots:** configure JWT verification ([#72](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/72)) ([98c64fc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/98c64fc0d56dc542beb31c75f4b9056d91de03cd))
+* **official-bots:** NCS-70-auto-register official bots with account service ([#59](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/59)) ([7117a93](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7117a93376272094d0b1a6abf2121254ce396684))
+
+### Reverts
+
+* Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
+##  (2026-06-21)
+
+### Features
+
+* add initialization metrics for various services ([d438e97](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d438e97f32bdde0bfc63c1b4a8cc810cdd093166))
+* add OpenTelemetry trace configuration with parentbased sampler ([3904d5a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3904d5ad8ad4930ddee65287a7bfab785a6148f5))
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* **config:** update application.yml for PostgreSQL and remove staging/production configurations ([2404e61](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2404e6164c3b50ffccbea5238d636060d6abe4d6))
+* **config:** update application.yml for staging and production environments ([6113432](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6113432a14c476a3a0dfc0d449e17d023697f2ba))
+* configure logging and add OpenTelemetry support ([#49](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/49)) ([d57c488](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d57c4886612d1d92da0e1b79209fc83e6ef537a1))
+* **docker:** add .dockerignore and .gitignore files for build exclusions ([c987d8e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c987d8e258c0e6c4cfbdaa8381c64c410d7a2b83))
+* **docker:** add Dockerfiles for building Quarkus application in native and JVM modes ([3f2d2bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3f2d2bb4c97fa8cddba66e1da4427c54236dfeed))
+* **docker:** add Dockerfiles for Quarkus application in JVM and native modes ([34b9933](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/34b993304670cf2aa62cd2f6460cee7b9864b08e))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* NCS-78 Add Traceability to the Applications ([#46](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/46)) ([649566e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/649566eb3fcf38f91c8896a739f74ea318af312d))
+* NCS-78 Add Traceability to the Applications ([#47](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/47)) ([87dfc6c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/87dfc6c2bcce7f7d58fc641bd8d468a2e584c108))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **official-bots:** consume GameOver stream for bot cleanup ([#67](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/67)) ([db9d153](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/db9d1533912f4b41c4d1ca80ccffdde5d23d6ff6))
+* **official-bots:** park expert bot on tournament server at startup ([#75](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/75)) ([30295a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/30295a4bb95855ee8261c92278bb9ebc80ee12ee))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+
+### Bug Fixes
+
+* enable official bots to connect to external tournament server ([#71](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/71)) ([688d30e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/688d30e2b10026923372be5fca3c63eaaee2de2a))
+* **official-bots:** configure JWT verification ([#72](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/72)) ([98c64fc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/98c64fc0d56dc542beb31c75f4b9056d91de03cd))
+* **official-bots:** make botToken optional, fall back to env, fix 502 status ([f43d193](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f43d1930d80670d810c57b54eaa3789854fa082c))
+* **official-bots:** NCS-70-auto-register official bots with account service ([#59](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/59)) ([7117a93](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7117a93376272094d0b1a6abf2121254ce396684))
+
+### Reverts
+
+* Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))
+##  (2026-06-21)
+
+### Features
+
+* add initialization metrics for various services ([d438e97](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d438e97f32bdde0bfc63c1b4a8cc810cdd093166))
+* add OpenTelemetry trace configuration with parentbased sampler ([3904d5a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3904d5ad8ad4930ddee65287a7bfab785a6148f5))
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* **config:** update application.yml for PostgreSQL and remove staging/production configurations ([2404e61](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/2404e6164c3b50ffccbea5238d636060d6abe4d6))
+* **config:** update application.yml for staging and production environments ([6113432](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6113432a14c476a3a0dfc0d449e17d023697f2ba))
+* configure logging and add OpenTelemetry support ([#49](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/49)) ([d57c488](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/d57c4886612d1d92da0e1b79209fc83e6ef537a1))
+* **docker:** add .dockerignore and .gitignore files for build exclusions ([c987d8e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c987d8e258c0e6c4cfbdaa8381c64c410d7a2b83))
+* **docker:** add Dockerfiles for building Quarkus application in native and JVM modes ([3f2d2bb](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3f2d2bb4c97fa8cddba66e1da4427c54236dfeed))
+* **docker:** add Dockerfiles for Quarkus application in JVM and native modes ([34b9933](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/34b993304670cf2aa62cd2f6460cee7b9864b08e))
+* **events:** migrate game-creation and bot flows to Redis Streams NCS-89 ([#62](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/62)) ([a24924c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a24924c23057db3d700a75dbc4333557789cd991))
+* NCS-78 Add Traceability to the Applications ([#46](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/46)) ([649566e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/649566eb3fcf38f91c8896a739f74ea318af312d))
+* NCS-78 Add Traceability to the Applications ([#47](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/47)) ([87dfc6c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/87dfc6c2bcce7f7d58fc641bd8d468a2e584c108))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **official-bots:** consume GameOver stream for bot cleanup ([#67](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/67)) ([db9d153](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/db9d1533912f4b41c4d1ca80ccffdde5d23d6ff6))
+* **official-bots:** park expert bot on tournament server at startup ([#75](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/75)) ([30295a4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/30295a4bb95855ee8261c92278bb9ebc80ee12ee))
+* **tournament:** federate tournaments across clusters with DB replication ([5b000a6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5b000a6e5f04ea6770d1c7ab6bfdaded77a99172))
+* **tournament:** seed external server registry from env var on startup ([845dc9c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/845dc9c2935c8bc1be42541dfaf31c9a861d3272))
+* true-microservices ([#40](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/40)) ([5909242](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/590924254e8a2754de661a57a03e43f89ceb6299))
+
+### Bug Fixes
+
+* enable official bots to connect to external tournament server ([#71](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/71)) ([688d30e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/688d30e2b10026923372be5fca3c63eaaee2de2a))
+* **official-bots:** configure JWT verification ([#72](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/72)) ([98c64fc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/98c64fc0d56dc542beb31c75f4b9056d91de03cd))
+* **official-bots:** correct parkOn path from /api/bots to /api/account/bots ([1be9949](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1be9949c0b5c6a1db535696620d77735050d6c93))
+* **official-bots:** make botToken optional, fall back to env, fix 502 status ([f43d193](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f43d1930d80670d810c57b54eaa3789854fa082c))
+* **official-bots:** NCS-70-auto-register official bots with account service ([#59](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/59)) ([7117a93](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7117a93376272094d0b1a6abf2121254ce396684))
+
+### Reverts
+
+* Revert "refactor: update metrics paths formatting in application.yml for clarity" ([3870566](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/38705663498d5f47c40dafe2f26198589ede8656))

modules/official-bots/src/main/resources/application.yml

@@ -26,6 +26,8 @@ nowchess:
     prefix: nowchess
   internal:
     secret: 123abc
+  tournament:
+    service-url: http://localhost:8088
 
 "%deployed":
   quarkus:
@@ -49,3 +51,5 @@ nowchess:
       prefix: ${REDIS_PREFIX:nowchess}
     internal:
       secret: ${INTERNAL_SECRET}
+    tournament:
+      service-url: ${TOURNAMENT_SERVICE_URL:http://localhost:8088}

modules/official-bots/src/main/scala/de/nowchess/bot/resource/JoinTournamentRequest.scala

@@ -2,7 +2,7 @@ package de.nowchess.bot.resource
 
 case class JoinTournamentRequest(
     tournamentId: String,
-    botToken: String,
+    botToken: Option[String],
     difficulty: String,
     serverUrl: Option[String],
 )

modules/official-bots/src/main/scala/de/nowchess/bot/resource/TournamentJoinResource.scala

@@ -25,20 +25,18 @@ class TournamentJoinResource:
   @POST
   @Path("/join-tournament")
   def joinTournament(req: JoinTournamentRequest): Response =
-    val serverUrl  = req.serverUrl.filter(_.nonEmpty).getOrElse(player.defaultServerUrl)
     val difficulty = if req.difficulty.nonEmpty then req.difficulty else "medium"
     log.infof(
-      "Official bot join requested — tournament=%s difficulty=%s server=%s",
+      "Official bot join requested — tournament=%s difficulty=%s",
       req.tournamentId,
       difficulty,
-      serverUrl,
     )
-    player.joinTournament(req.tournamentId, req.botToken, difficulty, serverUrl) match
+    player.joinTournament(req.tournamentId, req.botToken, difficulty) match
       case Right(botId) =>
         val resp = JoinTournamentResponse(botId, difficulty, "joining")
         Response.ok(resp).build()
       case Left(err) =>
         Response
-          .status(Response.Status.BAD_GATEWAY)
+          .status(Response.Status.BAD_REQUEST)
           .entity(s"""{"error":"$err"}""")
           .build()

modules/official-bots/src/main/scala/de/nowchess/bot/service/TournamentBotConfig.scala

@@ -20,7 +20,7 @@ object TournamentBotConfig:
       tournamentId <- env.get("TOURNAMENT_ID").filter(_.nonEmpty)
       token        <- env.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty)
       botId        <- jwtSubject(token)
-      serverUrl  = env.getOrElse("TOURNAMENT_SERVER_URL", "http://141.37.123.132:8086")
+      serverUrl  = env.getOrElse("TOURNAMENT_SERVICE_URL", "http://localhost:8086")
       difficulty = env.getOrElse("TOURNAMENT_BOT_DIFFICULTY", "medium")
     yield TournamentBotConfig(serverUrl, tournamentId, token, botId, difficulty)
 

modules/official-bots/src/main/scala/de/nowchess/bot/service/TournamentBotGamePlayer.scala

@@ -38,8 +38,8 @@ class TournamentBotGamePlayer:
   @volatile private var running = true
   // scalafix:on DisableSyntax.var
 
-  val defaultServerUrl: String =
-    System.getenv().asScala.getOrElse("TOURNAMENT_SERVER_URL", "http://141.37.123.132:8086")
+  val tournamentServiceUrl: String =
+    System.getenv().asScala.getOrElse("TOURNAMENT_SERVICE_URL", "http://localhost:8086")
 
   @PostConstruct
   def initialize(): Unit =
@@ -52,45 +52,62 @@ class TournamentBotGamePlayer:
         startAsync(cfg)
 
   private def parkOnStartup(): Unit =
-    park(defaultServerUrl, "expert") match
-      case Some(id) => log.infof("Parked expert bot on %s as id %s", defaultServerUrl, id)
-      case None     => log.warnf("Failed to park expert bot on %s", defaultServerUrl)
+    val token = System.getenv().asScala.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty)
+    token match
+      case None => log.warn("TOURNAMENT_BOT_TOKEN not set — skipping park")
+      case Some(tok) =>
+        val localAccountUrl = System.getenv().asScala.getOrElse("ACCOUNT_SERVICE_URL", "http://localhost:8083")
+        BotController.listBots.foreach(diff => parkOn(localAccountUrl, diff, tok))
+        fetchRemoteServers().foreach { serverUrl =>
+          BotController.listBots.foreach(diff => parkOn(serverUrl, diff, tok))
+        }
 
-  private def park(serverUrl: String, difficulty: String): Option[String] =
-    System.getenv().asScala.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty).flatMap { token =>
-      Try {
-        val body = s"""{"name":"${botName(difficulty)}"}"""
-        val response = client
-          .target(serverUrl)
-          .path("api")
-          .path("bots")
-          .request(MediaType.APPLICATION_JSON)
-          .header("Authorization", s"Bearer $token")
-          .post(Entity.entity(body, MediaType.APPLICATION_JSON))
-        if response.getStatus == 201 || response.getStatus == 200 then
-          val id = objectMapper.readTree(response.readEntity(classOf[String])).path("id").asText()
-          response.close()
-          Option(id).filter(_.nonEmpty)
-        else { log.warnf("Parking bot %s returned status %d", botName(difficulty), response.getStatus); response.close(); None }
-      }.getOrElse(None)
-    }
+  private def fetchRemoteServers(): List[String] =
+    Try {
+      val response = client.target(tournamentServiceUrl)
+        .path("api").path("tournament").path("servers")
+        .request(MediaType.APPLICATION_JSON).get()
+      if response.getStatus == 200 then
+        val node = objectMapper.readTree(response.readEntity(classOf[String]))
+        response.close()
+        node.path("servers").elements().asScala.toList.map(_.path("url").asText()).filter(_.nonEmpty)
+      else { response.close(); Nil }
+    }.getOrElse(Nil)
+
+  private def parkOn(serverUrl: String, difficulty: String, token: String): Unit =
+    Try {
+      val body = s"""{"name":"${botName(difficulty)}"}"""
+      val response = client.target(serverUrl).path("api").path("account").path("bots")
+        .request(MediaType.APPLICATION_JSON)
+        .header("Authorization", s"Bearer $token")
+        .post(Entity.entity(body, MediaType.APPLICATION_JSON))
+      if response.getStatus == 201 || response.getStatus == 200 then
+        val id = objectMapper.readTree(response.readEntity(classOf[String])).path("id").asText()
+        log.infof("Parked bot %s on %s as id %s", botName(difficulty), serverUrl, id)
+      else log.warnf("Park %s on %s returned status %d", botName(difficulty), serverUrl, response.getStatus)
+      response.close()
+    }.failed.foreach(ex => log.warnf(ex, "Failed to park %s on %s", botName(difficulty), serverUrl))
 
   private def botName(difficulty: String): String = s"NowChess ${difficulty.capitalize}"
 
   def joinTournament(
       tournamentId: String,
-      botToken: String,
+      botToken: Option[String],
       difficulty: String,
-      serverUrl: String,
   ): Either[String, String] =
-    TournamentBotConfig.jwtSubject(botToken) match
-      case None => Left("Invalid bot token — could not extract subject")
-      case Some(botId) =>
-        val cfg = TournamentBotConfig(serverUrl, tournamentId, botToken, botId, difficulty)
-        if join(cfg) then
-          startAsync(cfg)
-          Right(botId)
-        else Left("Failed to join tournament")
+    val resolvedToken = botToken.filter(_.nonEmpty)
+      .orElse(System.getenv().asScala.get("TOURNAMENT_BOT_TOKEN").filter(_.nonEmpty))
+    resolvedToken match
+      case None => Left("No bot token provided and TOURNAMENT_BOT_TOKEN not configured")
+      case Some(token) =>
+        TournamentBotConfig.jwtSubject(token) match
+          case None => Left("Invalid bot token — could not extract subject")
+          case Some(botId) =>
+            val cfg = TournamentBotConfig(tournamentServiceUrl, tournamentId, token, botId, difficulty)
+            if join(cfg) then
+              startAsync(cfg)
+              Right(botId)
+            else Left("Failed to join tournament")
 
   private def startAsync(cfg: TournamentBotConfig): Unit =
     val thread = new Thread(() => streamLoop(cfg), s"TournamentBot-${cfg.tournamentId}")

modules/official-bots/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=20
+MINOR=23
 PATCH=0

modules/tournament/CHANGELOG.md

@@ -23,3 +23,35 @@
 ### Bug Fixes
 
 * **tournament:** replace scala.util.Random singleton with UUID for native image ([a50884a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a50884a11b1de500e74c18fd08d2d102d53cc3e9))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* NCS-121 pipeline for tournament ([#68](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/68)) ([145f467](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/145f4676483f92bfe6f2d9ca40e2cb4200982e87))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **reflection:** add GameWritebackEventDto to native reflection configuration ([1aee39c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1aee39c1ad286984501ac4b47da2b72d60b58a6f))
+* **reflection:** add native reflection configuration for tournament classes ([65bc6a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/65bc6a759937543df2d29905688bfa9e68d0c9d4))
+
+### Bug Fixes
+
+* **tournament:** replace scala.util.Random singleton with UUID for native image ([a50884a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a50884a11b1de500e74c18fd08d2d102d53cc3e9))
+* wrap server list response in ExternalTournamentServerList ([f2d79e4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f2d79e4952aea6bde762c294eb202474b7827054))
+##  (2026-06-21)
+
+### Features
+
+* **analytics:** add Spark batch analytics module ([#70](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/70)) ([39f1657](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/39f1657e1db6e84889af338c43be8cb5c03c3ec3))
+* NCS-121 pipeline for tournament ([#68](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/68)) ([145f467](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/145f4676483f92bfe6f2d9ca40e2cb4200982e87))
+* NCS-82 add Swiss-system tournament module ([#55](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/55)) ([c5661de](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/c5661de4a0ebf4b33211f5a391840dcf744656b7))
+* **reflection:** add GameWritebackEventDto to native reflection configuration ([1aee39c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1aee39c1ad286984501ac4b47da2b72d60b58a6f))
+* **reflection:** add native reflection configuration for tournament classes ([65bc6a7](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/65bc6a759937543df2d29905688bfa9e68d0c9d4))
+* **tournament:** federate tournaments across clusters with DB replication ([5b000a6](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/5b000a6e5f04ea6770d1c7ab6bfdaded77a99172))
+* **tournament:** remove dynamic server add/remove endpoints ([6d06edd](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/6d06edda69a50de65cd9efa27f26a4cc6b437f9d))
+* **tournament:** seed external server registry from env var on startup ([845dc9c](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/845dc9c2935c8bc1be42541dfaf31c9a861d3272))
+
+### Bug Fixes
+
+* **tournament:** replace scala.util.Random singleton with UUID for native image ([a50884a](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/a50884a11b1de500e74c18fd08d2d102d53cc3e9))
+* **tournament:** use Optional[String] for selfUrl ConfigProperty to avoid startup failure ([28cbc2e](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/28cbc2e18447aa8a04a5868889a49b555075d0c6))
+* wrap server list response in ExternalTournamentServerList ([f2d79e4](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f2d79e4952aea6bde762c294eb202474b7827054))

modules/tournament/src/main/resources/application.yml

@@ -27,6 +27,9 @@ nowchess:
     prefix: ${REDIS_PREFIX:nowchess}
   internal:
     secret: ${INTERNAL_SECRET:123abc}
+  tournament:
+    self-url: ""
+    external-servers: ""
 
 mp:
   jwt:
@@ -46,6 +49,10 @@ mp:
     hibernate-orm:
       schema-management:
         strategy: update
+  nowchess:
+    tournament:
+      self-url: ${TOURNAMENT_SELF_URL:}
+      external-servers: ${TOURNAMENT_EXTERNAL_SERVERS:}
 
 "%test":
   quarkus:

modules/tournament/src/main/scala/de/nowchess/tournament/config/NativeReflectionConfig.scala

@@ -26,13 +26,13 @@ import io.quarkus.runtime.annotations.RegisterForReflection
     classOf[RoundPairingsDto],
     classOf[ErrorDto],
     classOf[OkDto],
+    classOf[ReplicateTournamentRequest],
     classOf[CorePlayerInfo],
     classOf[CoreTimeControl],
     classOf[CoreCreateGameRequest],
     classOf[CoreGameResponse],
     classOf[GameWritebackEventDto],
     classOf[ExternalTournamentServer],
-    classOf[RegisterServerRequest],
     classOf[ExternalTournamentServerList],
   ),
 )

modules/tournament/src/main/scala/de/nowchess/tournament/domain/Tournament.scala

@@ -30,4 +30,7 @@ class Tournament:
   var startsAt: Instant  = uninitialized
   var winnerId: String   = uninitialized
   var winnerName: String = uninitialized
+
+  @Column(nullable = true)
+  var originServerUrl: String = null
   // scalafix:on

modules/tournament/src/main/scala/de/nowchess/tournament/dto/Dtos.scala

@@ -1,5 +1,7 @@
 package de.nowchess.tournament.dto
 
+import java.time.Instant
+
 case class BotRef(id: String, name: String)
 
 case class Clock(limit: Int, increment: Int)
@@ -72,3 +74,15 @@ case class RoundPairingsDto(round: Int, pairings: List[PairingDto])
 case class ErrorDto(error: String)
 
 case class OkDto(ok: Boolean = true)
+
+case class ReplicateTournamentRequest(
+    id: String,
+    fullName: String,
+    nbRounds: Int,
+    clockLimit: Int,
+    clockIncrement: Int,
+    rated: Boolean,
+    createdBy: String,
+    startsAt: Instant,
+    status: String,
+)

modules/tournament/src/main/scala/de/nowchess/tournament/dto/ExternalServer.scala

@@ -1,5 +1,4 @@
 package de.nowchess.tournament.dto
 
 case class ExternalTournamentServer(id: String, label: String, url: String)
-case class RegisterServerRequest(label: String, url: String)
 case class ExternalTournamentServerList(servers: List[ExternalTournamentServer])

modules/tournament/src/main/scala/de/nowchess/tournament/resource/TournamentResource.scala

@@ -9,13 +9,14 @@ import de.nowchess.tournament.service.{
   TournamentService,
   TournamentStreamManager,
 }
-import io.smallrye.mutiny.Multi
 import jakarta.annotation.security.{PermitAll, RolesAllowed}
 import jakarta.enterprise.context.ApplicationScoped
 import jakarta.inject.Inject
 import jakarta.ws.rs.*
 import jakarta.ws.rs.core.{Context, HttpHeaders, MediaType, Response, StreamingOutput}
+import org.eclipse.microprofile.config.inject.ConfigProperty
 import org.eclipse.microprofile.jwt.JsonWebToken
+import java.util.Optional
 import org.jboss.logging.Logger
 import scala.compiletime.uninitialized
 import scala.jdk.CollectionConverters.*
@@ -36,6 +37,9 @@ class TournamentResource:
   @Inject var externalClient: ExternalTournamentClient = uninitialized
   @Inject var objectMapper: ObjectMapper               = uninitialized
   @Context var headers: HttpHeaders                    = uninitialized
+
+  @ConfigProperty(name = "nowchess.tournament.self-url")
+  var selfUrl: Optional[String] = uninitialized
   // scalafix:on
 
   @GET
@@ -85,6 +89,12 @@ class TournamentResource:
     val userId = Option(jwt.getSubject).getOrElse("")
     val form   = CreateTournamentForm(name, nbRounds, clockLimit, clockIncrement, rated)
     val t      = tournamentService.create(userId, form)
+    selfUrl.ifPresent { url =>
+      registry.serverUrls().foreach { remoteUrl =>
+        if !externalClient.replicateTournament(remoteUrl, toReplicateRequest(t), url) then
+          log.warnf("Failed to replicate tournament %s to %s", t.id, remoteUrl)
+      }
+    }
     Response.status(Response.Status.CREATED).entity(tournamentService.toDto(t)).build()
 
   @GET
@@ -100,33 +110,59 @@ class TournamentResource:
           .flatMap(url => externalClient.fetch(url, id).map(node => Response.ok(node).build()))
           .getOrElse(Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Tournament $id not found")).build())
 
+  @POST
+  @Path("/replicate")
+  @PermitAll
+  def replicate(req: ReplicateTournamentRequest): Response =
+    val originUrl = Option(headers.getHeaderString("X-Origin-Url")).getOrElse("")
+    if originUrl.isEmpty then
+      Response.status(Response.Status.BAD_REQUEST).entity(ErrorDto("Missing X-Origin-Url header")).build()
+    else
+      tournamentService.get(req.id) match
+        case Some(_) => Response.status(Response.Status.CONFLICT).entity(ErrorDto("Tournament already exists")).build()
+        case None =>
+          tournamentService.replicate(req, originUrl)
+          Response.status(Response.Status.CREATED).build()
+
   @DELETE
   @Path("/{id}")
   @RolesAllowed(Array("**"))
   def terminate(@PathParam("id") id: String): Response =
     val userId = Option(jwt.getSubject).getOrElse("")
-    tournamentService.terminate(id, userId) match
-      case Right(_)    => Response.noContent().build()
-      case Left(error) => errorResponse(error)
+    tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+      case Some(originUrl) =>
+        val auth           = Option(headers.getHeaderString("Authorization"))
+        val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id", auth)
+        Response.status(status).entity(body).build()
+      case None =>
+        tournamentService.terminate(id, userId) match
+          case Right(_)    => Response.noContent().build()
+          case Left(error) => errorResponse(error)
 
   @POST
   @Path("/{id}/start")
   @RolesAllowed(Array("**"))
   def start(@PathParam("id") id: String): Response =
     val userId = Option(jwt.getSubject).getOrElse("")
-    tournamentService.start(id, userId) match
-      case Right(t) => Response.ok(tournamentService.toDto(t)).build()
-      case Left(error) =>
-        error match
-          case TournamentError.NotFound(_) =>
-            val auth = Option(headers.getHeaderString("Authorization"))
-            resolveServer(id)
-              .map { url =>
-                val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/start", auth)
-                Response.status(status).entity(body).build()
-              }
-              .getOrElse(errorResponse(error))
-          case _ => errorResponse(error)
+    tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+      case Some(originUrl) =>
+        val auth           = Option(headers.getHeaderString("Authorization"))
+        val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id/start", auth)
+        Response.status(status).entity(body).build()
+      case None =>
+        tournamentService.start(id, userId) match
+          case Right(t) => Response.ok(tournamentService.toDto(t)).build()
+          case Left(error) =>
+            error match
+              case TournamentError.NotFound(_) =>
+                val auth = Option(headers.getHeaderString("Authorization"))
+                resolveServer(id)
+                  .map { url =>
+                    val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/start", auth)
+                    Response.status(status).entity(body).build()
+                  }
+                  .getOrElse(errorResponse(error))
+              case _ => errorResponse(error)
 
   @POST
   @Path("/{id}/join")
@@ -136,21 +172,27 @@ class TournamentResource:
     if tokenType != "bot" then
       Response.status(Response.Status.FORBIDDEN).entity(ErrorDto("Only bots can join tournaments")).build()
     else
-      val botId   = Option(jwt.getSubject).getOrElse("")
-      val botName = Option(jwt.getClaim[AnyRef]("name")).map(_.toString).getOrElse(botId)
-      tournamentService.join(id, botId, botName) match
-        case Right(_) => Response.ok(OkDto()).build()
-        case Left(error) =>
-          error match
-            case TournamentError.NotFound(_) =>
-              val auth = Option(headers.getHeaderString("Authorization"))
-              resolveServer(id)
-                .map { url =>
-                  val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/join", auth)
-                  Response.status(status).entity(body).build()
-                }
-                .getOrElse(errorResponse(error))
-            case _ => errorResponse(error)
+      tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+        case Some(originUrl) =>
+          val auth           = Option(headers.getHeaderString("Authorization"))
+          val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id/join", auth)
+          Response.status(status).entity(body).build()
+        case None =>
+          val botId   = Option(jwt.getSubject).getOrElse("")
+          val botName = Option(jwt.getClaim[AnyRef]("name")).map(_.toString).getOrElse(botId)
+          tournamentService.join(id, botId, botName) match
+            case Right(_) => Response.ok(OkDto()).build()
+            case Left(error) =>
+              error match
+                case TournamentError.NotFound(_) =>
+                  val auth = Option(headers.getHeaderString("Authorization"))
+                  resolveServer(id)
+                    .map { url =>
+                      val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/join", auth)
+                      Response.status(status).entity(body).build()
+                    }
+                    .getOrElse(errorResponse(error))
+                case _ => errorResponse(error)
 
   @POST
   @Path("/{id}/withdraw")
@@ -160,20 +202,26 @@ class TournamentResource:
     if tokenType != "bot" then
       Response.status(Response.Status.FORBIDDEN).entity(ErrorDto("Only bots can withdraw")).build()
     else
-      val botId = Option(jwt.getSubject).getOrElse("")
-      tournamentService.withdraw(id, botId) match
-        case Right(_) => Response.ok(OkDto()).build()
-        case Left(error) =>
-          error match
-            case TournamentError.NotFound(_) =>
-              val auth = Option(headers.getHeaderString("Authorization"))
-              resolveServer(id)
-                .map { url =>
-                  val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/withdraw", auth)
-                  Response.status(status).entity(body).build()
-                }
-                .getOrElse(errorResponse(error))
-            case _ => errorResponse(error)
+      tournamentService.get(id).flatMap(t => Option(t.originServerUrl)) match
+        case Some(originUrl) =>
+          val auth           = Option(headers.getHeaderString("Authorization"))
+          val (status, body) = externalClient.proxyPost(originUrl, s"api/tournament/$id/withdraw", auth)
+          Response.status(status).entity(body).build()
+        case None =>
+          val botId = Option(jwt.getSubject).getOrElse("")
+          tournamentService.withdraw(id, botId) match
+            case Right(_) => Response.ok(OkDto()).build()
+            case Left(error) =>
+              error match
+                case TournamentError.NotFound(_) =>
+                  val auth = Option(headers.getHeaderString("Authorization"))
+                  resolveServer(id)
+                    .map { url =>
+                      val (status, body) = externalClient.proxyPost(url, s"api/tournament/$id/withdraw", auth)
+                      Response.status(status).entity(body).build()
+                    }
+                    .getOrElse(errorResponse(error))
+                case _ => errorResponse(error)
 
   @GET
   @Path("/{id}/results")
@@ -236,15 +284,81 @@ class TournamentResource:
   @Path("/{id}/stream")
   @RolesAllowed(Array("**"))
   @Produces(Array("application/x-ndjson"))
-  def stream(@PathParam("id") id: String): Multi[String] =
+  def stream(@PathParam("id") id: String): Response =
     tournamentService.get(id) match
-      case None => Multi.createFrom().failure(new NotFoundException(s"Tournament $id not found"))
+      case Some(t) if Option(t.originServerUrl).isDefined =>
+        val auth = Option(headers.getHeaderString("Authorization"))
+        externalClient.proxyGetStream(t.originServerUrl, s"api/tournament/$id/stream", auth)
+          .map { inputStream =>
+            Response
+              .ok(new StreamingOutput {
+                def write(output: java.io.OutputStream): Unit =
+                  val buf = new Array[Byte](4096)
+                  // scalafix:off DisableSyntax.var
+                  var n = inputStream.read(buf)
+                  while n >= 0 do
+                    output.write(buf, 0, n)
+                    output.flush()
+                    n = inputStream.read(buf)
+                // scalafix:on
+              })
+              .`type`("application/x-ndjson")
+              .build()
+          }
+          .getOrElse(Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Tournament $id stream unavailable")).build())
       case Some(_) =>
         val botId = Option(jwt.getSubject).getOrElse("")
-        Multi.createFrom().emitter[String] { emitter =>
-          streamManager.register(id, botId, emitter)
-          emitter.onTermination(() => streamManager.unregister(id, botId, emitter))
+        val queue   = new java.util.concurrent.LinkedBlockingQueue[Option[String]]()
+        val emitter = new io.smallrye.mutiny.subscription.MultiEmitter[String] {
+          def emit(item: String): io.smallrye.mutiny.subscription.MultiEmitter[String] =
+            queue.put(Some(item)); this
+          def fail(failure: Throwable): Unit = queue.put(None)
+          def complete(): Unit               = queue.put(None)
+          def requested(): Long              = Long.MaxValue
+          def isCancelled: Boolean           = false
+          def onTermination(
+              onTermination: java.lang.Runnable,
+          ): io.smallrye.mutiny.subscription.MultiEmitter[String] = this
         }
+        streamManager.register(id, botId, emitter)
+        Response
+          .ok(new StreamingOutput {
+            def write(output: java.io.OutputStream): Unit =
+              try
+                // scalafix:off DisableSyntax.var
+                var cont = true
+                while cont do
+                  queue.take() match
+                    case None       => cont = false
+                    case Some(line) =>
+                      output.write((line + "\n").getBytes("UTF-8"))
+                      output.flush()
+                // scalafix:on
+              finally streamManager.unregister(id, botId, emitter)
+          })
+          .`type`("application/x-ndjson")
+          .build()
+      case None =>
+        val auth = Option(headers.getHeaderString("Authorization"))
+        resolveServer(id)
+          .flatMap(url => externalClient.proxyGetStream(url, s"api/tournament/$id/stream", auth))
+          .map { inputStream =>
+            Response
+              .ok(new StreamingOutput {
+                def write(output: java.io.OutputStream): Unit =
+                  val buf = new Array[Byte](4096)
+                  // scalafix:off DisableSyntax.var
+                  var n = inputStream.read(buf)
+                  while n >= 0 do
+                    output.write(buf, 0, n)
+                    output.flush()
+                    n = inputStream.read(buf)
+                // scalafix:on
+              })
+              .`type`("application/x-ndjson")
+              .build()
+          }
+          .getOrElse(Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Tournament $id not found")).build())
 
   @GET
   @Path("/{id}/game/{gameId}")
@@ -297,15 +411,31 @@ class TournamentResource:
       .getOrElse(Response.status(Response.Status.NOT_FOUND).build())
 
   private def resolveServer(tournamentId: String): Option[String] =
-    registry.findServerUrl(tournamentId).orElse {
-      registry
-        .serverUrls()
-        .find(url => externalClient.fetch(url, tournamentId).isDefined)
-        .map { url =>
-          registry.bindTournament(tournamentId, url)
-          url
-        }
-    }
+    tournamentService.get(tournamentId)
+      .flatMap(t => Option(t.originServerUrl))
+      .orElse(registry.findServerUrl(tournamentId))
+      .orElse {
+        registry
+          .serverUrls()
+          .find(url => externalClient.fetch(url, tournamentId).isDefined)
+          .map { url =>
+            registry.bindTournament(tournamentId, url)
+            url
+          }
+      }
+
+  private def toReplicateRequest(t: de.nowchess.tournament.domain.Tournament): ReplicateTournamentRequest =
+    ReplicateTournamentRequest(
+      id = t.id,
+      fullName = t.fullName,
+      nbRounds = t.nbRounds,
+      clockLimit = t.clockLimit,
+      clockIncrement = t.clockIncrement,
+      rated = t.rated,
+      createdBy = t.createdBy,
+      startsAt = Option(t.startsAt).getOrElse(java.time.Instant.now()),
+      status = t.status,
+    )
 
   private def errorResponse(error: TournamentError): Response =
     val status = error match

modules/tournament/src/main/scala/de/nowchess/tournament/resource/TournamentServerResource.scala

@@ -1,6 +1,6 @@
 package de.nowchess.tournament.resource
 
-import de.nowchess.tournament.dto.{ErrorDto, RegisterServerRequest}
+import de.nowchess.tournament.dto.ExternalTournamentServerList
 import de.nowchess.tournament.service.TournamentServerRegistry
 import jakarta.annotation.security.RolesAllowed
 import jakarta.enterprise.context.ApplicationScoped
@@ -22,14 +22,4 @@ class TournamentServerResource:
 
   @GET
   def list(): Response =
-    Response.ok(registry.list()).build()
-
-  @POST
-  def register(req: RegisterServerRequest): Response =
-    Response.status(201).entity(registry.register(req.label, req.url)).build()
-
-  @DELETE
-  @Path("/{id}")
-  def remove(@PathParam("id") id: String): Response =
-    if registry.remove(id) then Response.noContent().build()
-    else Response.status(Response.Status.NOT_FOUND).entity(ErrorDto(s"Server $id not found")).build()
+    Response.ok(ExternalTournamentServerList(registry.list())).build()

modules/tournament/src/main/scala/de/nowchess/tournament/service/ExternalTournamentClient.scala

@@ -1,6 +1,7 @@
 package de.nowchess.tournament.service
 
 import com.fasterxml.jackson.databind.{JsonNode, ObjectMapper}
+import de.nowchess.tournament.dto.ReplicateTournamentRequest
 import jakarta.enterprise.context.ApplicationScoped
 import jakarta.inject.Inject
 import jakarta.ws.rs.client.{Client, ClientBuilder, Entity}
@@ -66,6 +67,21 @@ class ExternalTournamentClient:
         client.close()
     }.getOrElse((502, """{"error":"External server unreachable"}"""))
 
+  def replicateTournament(serverUrl: String, req: ReplicateTournamentRequest, selfUrl: String): Boolean =
+    Try {
+      val client  = buildClient()
+      val body    = objectMapper.writeValueAsString(req)
+      val response = client
+        .target(s"$serverUrl/api/tournament/replicate")
+        .request(MediaType.APPLICATION_JSON)
+        .header("X-Origin-Url", selfUrl)
+        .post(Entity.entity(body, MediaType.APPLICATION_JSON))
+      try response.getStatus / 100 == 2
+      finally
+        response.close()
+        client.close()
+    }.getOrElse(false)
+
   def proxyGetStream(serverUrl: String, path: String, authHeader: Option[String]): Option[java.io.InputStream] =
     Try {
       val client   = buildClient()

modules/tournament/src/main/scala/de/nowchess/tournament/service/TournamentServerRegistry.scala

@@ -1,17 +1,29 @@
 package de.nowchess.tournament.service
 
 import de.nowchess.tournament.dto.ExternalTournamentServer
+import jakarta.annotation.PostConstruct
 import jakarta.enterprise.context.ApplicationScoped
-import java.util.UUID
+import org.eclipse.microprofile.config.inject.ConfigProperty
+import java.util.{Optional, UUID}
 import java.util.concurrent.ConcurrentHashMap
 import scala.jdk.CollectionConverters.*
 
 @ApplicationScoped
 class TournamentServerRegistry:
 
+  @ConfigProperty(name = "nowchess.tournament.external-servers")
+  var externalServers: Optional[String] = scala.compiletime.uninitialized
+
   private val servers     = new ConcurrentHashMap[String, ExternalTournamentServer]()
   private val tournaments = new ConcurrentHashMap[String, String]()
 
+  @PostConstruct
+  def init(): Unit =
+    if externalServers.isPresent then
+      externalServers.get().split(",").map(_.trim).filter(_.nonEmpty).foreach { url =>
+        register(url, url)
+      }
+
   def register(label: String, url: String): ExternalTournamentServer =
     val id     = UUID.randomUUID().toString
     val server = ExternalTournamentServer(id, label, url.stripSuffix("/"))

modules/tournament/src/main/scala/de/nowchess/tournament/service/TournamentService.scala

@@ -9,6 +9,7 @@ import de.nowchess.tournament.dto.{
   Clock,
   CreateTournamentForm,
   PairingDto,
+  ReplicateTournamentRequest,
   ResultDto,
   Standing,
   TournamentDto,
@@ -61,6 +62,23 @@ class TournamentService:
     tournamentRepository.persist(t)
     t
 
+  @Transactional
+  def replicate(req: ReplicateTournamentRequest, originServerUrl: String): Tournament =
+    val t = new Tournament()
+    t.id = req.id
+    t.fullName = req.fullName
+    t.nbRounds = req.nbRounds
+    t.clockLimit = req.clockLimit
+    t.clockIncrement = req.clockIncrement
+    t.rated = req.rated
+    t.status = req.status
+    t.currentRound = 0
+    t.createdBy = req.createdBy
+    t.startsAt = req.startsAt
+    t.originServerUrl = originServerUrl
+    tournamentRepository.persist(t)
+    t
+
   def get(id: String): Option[Tournament] =
     tournamentRepository.findOptById(id)
 

modules/tournament/versions.env

@@ -1,3 +1,3 @@
 MAJOR=0
-MINOR=3
+MINOR=5
 PATCH=0