refactor: update CLAUDE.md for improved structure and clarity

.claude/agents/test-writer.md

@@ -12,7 +12,7 @@ You write tests for Scala 3 + Quarkus services.
 - Unit tests: `extends AnyFunSuite with Matchers` — use `test("description") { ... }` DSL, no `@Test` annotation, no `: Unit` return type needed.
 - Integration tests: `@QuarkusTest` with JUnit 5 — `@Test` methods MUST be explicitly typed `: Unit`.
 
-Target 100% conditional coverage if possible.
+Target 95%+ conditional coverage.
 
 When invoked BEFORE scala-implementer (no implementation exists yet):
   Use the contract-first-test-writing skill — write failing tests from docs/api/{service}.yaml.

.claude/memory/MEMORY.md

@@ -1,9 +0,0 @@
-# Memory Index
-
-## Feedback
-- [feedback_keep_structure_updated.md](feedback_keep_structure_updated.md) — Update structure memory files whenever source files are added, removed, or changed
-
-## Project Structure
-- [project_structure_root.md](project_structure_root.md) — Top-level layout, modules list, VERSIONS map, navigation rules (skip `build/`, `.gradle/`, `.idea/`)
-- [project_structure_api.md](project_structure_api.md) — `modules/api`: all files and types (Board, Piece, Square, GameState, Move, ApiResponse, PlayerInfo)
-- [project_structure_core.md](project_structure_core.md) — `modules/core`: all files and types (GameContext, GameRules, MoveValidator, GameController, Parser, Renderer)

.claude/memory/feedback_keep_structure_updated.md

@@ -1,16 +0,0 @@
----
-name: keep-structure-memory-updated
-description: Always update the project structure memory files when adding, removing, or changing source files
-type: feedback
----
-
-After any change that adds, removes, renames, or significantly alters a source file, update the relevant structure memory file:
-
-- New/renamed/deleted file in `modules/api` → update `project_structure_api.md`
-- New/renamed/deleted file in `modules/core` → update `project_structure_core.md`
-- New module, dependency version change, or new top-level directory → update `project_structure_root.md`
-- New module added → create a new `project_structure_<module>.md` and add it to `MEMORY.md`
-
-**Why:** Structure memories are the primary navigation aid. Stale entries cause wasted exploration.
-
-**How to apply:** Treat the structure memory update as part of completing any implementation task — do it in the same session, not as a follow-up.

.claude/memory/project_structure_api.md

@@ -1,51 +0,0 @@
----
-name: module-api-structure
-description: File and type overview for the modules/api module (shared domain types)
-type: project
----
-
-# Module: `modules/api`
-
-**Purpose:** Shared domain model — pure data types with no game logic. Depended on by `modules/core`.
-
-**Gradle:** `id("scala")`, no `application` plugin. No Quarkus. Uses scoverage plugin.
-
-**Package root:** `de.nowchess.api`
-
-## Source files (`src/main/scala/de/nowchess/api/`)
-
-### `board/`
-| File | Contents |
-|------|----------|
-| `Board.scala` | `opaque type Board = Map[Square, Piece]` — extensions: `pieceAt`, `withMove`, `pieces`; `Board.initial` sets up start position |
-| `Color.scala` | `enum Color { White, Black }` — `.opposite`, `.label` |
-| `Piece.scala` | `case class Piece(color, pieceType)` — convenience vals `WhitePawn`…`BlackKing` |
-| `PieceType.scala` | `enum PieceType { Pawn, Knight, Bishop, Rook, Queen, King }` — `.label` |
-| `Square.scala` | `enum File { A–H }`, `enum Rank { R1–R8 }`, `case class Square(file, rank)` — `.toString` algebraic, `Square.fromAlgebraic(s)` |
-
-### `game/`
-| File | Contents |
-|------|----------|
-| `GameState.scala` | `case class CastlingRights(kingSide, queenSide)` + `.None`/`.Both`; `enum GameResult { WhiteWins, BlackWins, Draw }`; `enum GameStatus { NotStarted, InProgress, Finished(result) }`; `case class GameState(piecePlacement, activeColor, castlingWhite, castlingBlack, enPassantTarget, halfMoveClock, fullMoveNumber, status)` — FEN-compatible snapshot |
-
-### `move/`
-| File | Contents |
-|------|----------|
-| `Move.scala` | `enum PromotionPiece { Knight, Bishop, Rook, Queen }`; `enum MoveType { Normal, CastleKingside, CastleQueenside, EnPassant, Promotion(piece) }`; `case class Move(from, to, moveType = Normal)` |
-
-### `player/`
-| File | Contents |
-|------|----------|
-| `PlayerInfo.scala` | `opaque type PlayerId = String`; `case class PlayerInfo(id: PlayerId, displayName: String)` |
-
-### `response/`
-| File | Contents |
-|------|----------|
-| `ApiResponse.scala` | `sealed trait ApiResponse[+A]` → `Success[A](data)` / `Failure(errors)`; `case class ApiError(code, message, field?)`; `case class Pagination(page, pageSize, totalItems)` + `.totalPages`; `case class PagedResponse[A](items, pagination)` |
-
-## Test files (`src/test/scala/de/nowchess/api/`)
-Mirror of main structure — one `*Test.scala` per source file using `AnyFunSuite with Matchers`.
-
-## Notes
-- `GameState` is FEN-style but `Board` (in `core`) is a `Map[Square,Piece]` — the two are separate representations
-- `CastlingRights` is defined here in `api`; the castling logic lives in `core`

.claude/memory/project_structure_core.md

@@ -1,48 +0,0 @@
----
-name: module-core-structure
-description: File and type overview for the modules/core module (TUI chess engine)
-type: project
----
-
-# Module: `modules/core`
-
-**Purpose:** Standalone TUI chess application. All game logic, move validation, rendering. Depends on `modules/api`.
-
-**Gradle:** `id("scala")` + `application` plugin. Main class: `de.nowchess.chess.Main`. Uses scoverage plugin.
-
-**Package root:** `de.nowchess.chess`
-
-## Source files (`src/main/scala/de/nowchess/chess/`)
-
-### Root
-| File | Contents |
-|------|----------|
-| `Main.scala` | Entry point — prints welcome, starts `GameController.gameLoop(GameContext.initial, Color.White)` |
-
-### `controller/`
-| File | Contents |
-|------|----------|
-| `GameController.scala` | `sealed trait MoveResult` ADT: `Quit`, `InvalidFormat`, `NoPiece`, `WrongColor`, `IllegalMove`, `Moved`, `MovedInCheck`, `Checkmate`, `Stalemate`; `object GameController` — `processMove(ctx, turn, raw): MoveResult` (pure), `gameLoop(ctx, turn)` (I/O loop), `applyRightsRevocation(...)` (castling rights bookkeeping) |
-| `Parser.scala` | `object Parser` — `parseMove(input): Option[(Square, Square)]` parses coordinate notation e.g. `"e2e4"` |
-
-### `logic/`
-| File | Contents |
-|------|----------|
-| `GameContext.scala` | `enum CastleSide { Kingside, Queenside }`; `case class GameContext(board, whiteCastling, blackCastling)` — `.castlingFor(color)`, `.withUpdatedRights(color, rights)`; `GameContext.initial`; `extension (Board).withCastle(color, side)` moves king+rook atomically |
-| `GameRules.scala` | `enum PositionStatus { Normal, InCheck, Mated, Drawn }`; `object GameRules` — `isInCheck(board, color)`, `legalMoves(ctx, color): Set[(Square,Square)]`, `gameStatus(ctx, color): PositionStatus` |
-| `MoveValidator.scala` | `object MoveValidator` — `isLegal(board, from, to)`, `legalTargets(board, from): Set[Square]` (board-only, no castling), `legalTargets(ctx, from)` (context-aware, includes castling), `isCastle`, `castleSide`, `castlingTargets(ctx, color)` — full castling legality (empty squares, no check through transit) |
-
-### `view/`
-| File | Contents |
-|------|----------|
-| `Renderer.scala` | `object Renderer` — `render(board): String` outputs ANSI-colored board with file/rank labels |
-| `PieceUnicode.scala` | `extension (Piece).unicode: String` maps each piece to its Unicode chess symbol |
-
-## Test files (`src/test/scala/de/nowchess/chess/`)
-Mirror of main structure — one `*Test.scala` per source file using `AnyFunSuite with Matchers`.
-
-## Key design notes
-- `MoveValidator` has two overloaded `legalTargets`: one takes `Board` (geometry only), one takes `GameContext` (adds castling)
-- `GameRules.legalMoves` filters by check — it calls `MoveValidator.legalTargets(ctx, from)` then simulates each move
-- Castling rights revocation is in `GameController.applyRightsRevocation`, triggered after every move
-- No `@QuarkusTest` — this module is a plain Scala application, not a Quarkus service

.claude/memory/project_structure_root.md

@@ -1,55 +0,0 @@
----
-name: project-root-structure
-description: Top-level project structure, modules list, and navigation notes for NowChessSystems
-type: project
----
-
-# NowChessSystems — Root Structure
-
-## Directory layout (skip `build/`, `.gradle/`, `.idea/`)
-
-```
-NowChessSystems/
-├── build.gradle.kts          # Root: sonarqube plugin, VERSIONS map
-├── settings.gradle.kts       # include(":modules:core", ":modules:api")
-├── gradlew / gradlew.bat
-├── CLAUDE.md                 # Project instructions for Claude Code
-├── .claude/
-│   ├── CLAUDE.MD             # Working agreement (plan/verify/unresolved)
-│   ├── settings.json
-│   └── agents/               # architect, code-reviewer, gradle-builder, scala-implementer, test-writer
-├── docs/
-│   ├── Claude-Skills.md
-│   ├── Security.md
-│   └── unresolved.md
-├── jacoco-reporter/          # Python scripts for coverage gap reporting
-└── modules/
-    ├── api/                  # Shared domain types (no logic)
-    └── core/                 # TUI chess engine + game logic
-```
-
-## Modules
-
-| Module | Gradle path | Purpose |
-|--------|-------------|---------|
-| `api` | `:modules:api` | Shared domain model: Board, Piece, Move, GameState, ApiResponse |
-| `core` | `:modules:core` | TUI chess app: game logic, move validation, rendering |
-
-`core` depends on `api` via `implementation(project(":modules:api"))`.
-
-## VERSIONS (root `build.gradle.kts`)
-
-| Key | Value |
-|-----|-------|
-| `QUARKUS_SCALA3` | 1.0.0 |
-| `SCALA3` | 3.5.1 |
-| `SCALA_LIBRARY` | 2.13.18 |
-| `SCALATEST` | 3.2.19 |
-| `SCALATEST_JUNIT` | 0.1.11 |
-| `SCOVERAGE` | 2.1.1 |
-
-## Navigation rules
-- **Always skip** `build/`, `.gradle/`, `.idea/` when exploring — they are generated artifacts
-- Tests use `AnyFunSuite with Matchers` (ScalaTest), not JUnit `@Test`
-- No Quarkus in current modules — Quarkus is planned for future services
-- Agent workflow: architect → scala-implementer → test-writer → gradle-builder → code-reviewer

CLAUDE.md

@@ -3,10 +3,6 @@
 ## Stack
 Scala 3.5.x · Quarkus + quarkus-scala3 · Hibernate/Jakarta · Lanterna TUI · K8s + ArgoCD + Kargo · Frontend TBD (Vite/React/Angular/Vue)
 
-### Memory
-
-Your memory is saved under .claude/memory/MEMORY.md.
-
 ## Structure
 ```
 build.gradle.kts / settings.gradle.kts   # root; include(":modules:<svc>") per service
@@ -36,7 +32,7 @@ Versions in root `extra["VERSIONS"]`; modules read via `rootProject.extra["VERSI
 - Integration tests: `@QuarkusTest` + JUnit 5 — `@Test` methods need explicit `: Unit`
 
 ## Coverage
-Line = 100% · Branch = 100% · Method = 100% · Regression tests · document exceptions
+Line ≥ 95% · Branch ≥ 90% · Method ≥ 90% (document exceptions)
 Check: `jacoco-reporter/scoverage_coverage_gaps.py modules/{svc}/build/reports/scoverageTest/scoverage.xml`
 ⚠️ Use `scoverageTest/`, NOT `scoverage/`.
 

modules/api/CHANGELOG.md

@@ -1,3 +0,0 @@
-##  (2026-03-27)
-##  (2026-03-28)
-##  (2026-03-28)

modules/api/build.gradle.kts

@@ -49,10 +49,9 @@ dependencies {
 
     testImplementation(platform("org.junit:junit-bom:5.13.4"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     testImplementation("org.scalatest:scalatest_3:${versions["SCALATEST"]!!}")
     testImplementation("co.helmethair:scalatest-junit-runner:${versions["SCALATEST_JUNIT"]!!}")
-
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 tasks.test {

modules/api/src/main/scala/de/nowchess/api/board/Board.scala

@@ -8,12 +8,10 @@ object Board:
 
   extension (b: Board)
     def pieceAt(sq: Square): Option[Piece] = b.get(sq)
-    def updated(sq: Square, piece: Piece): Board = b.updated(sq, piece)
-    def removed(sq: Square): Board = b.removed(sq)
     def withMove(from: Square, to: Square): (Board, Option[Piece]) =
       val captured = b.get(to)
-      val updatedBoard = b.removed(from).updated(to, b(from))
-      (updatedBoard, captured)
+      val updated  = b.removed(from).updated(to, b(from))
+      (updated, captured)
     def pieces: Map[Square, Piece] = b
 
   val initial: Board =

modules/api/src/test/scala/de/nowchess/api/board/BoardTest.scala

@@ -1,122 +0,0 @@
-package de.nowchess.api.board
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class BoardTest extends AnyFunSuite with Matchers:
-
-  private val e2 = Square(File.E, Rank.R2)
-  private val e4 = Square(File.E, Rank.R4)
-  private val d7 = Square(File.D, Rank.R7)
-
-  test("pieceAt returns Some for occupied square") {
-    Board.initial.pieceAt(e2) shouldBe Some(Piece.WhitePawn)
-  }
-
-  test("pieceAt returns None for empty square") {
-    Board.initial.pieceAt(e4) shouldBe None
-  }
-
-  test("withMove moves piece and vacates origin") {
-    val (board, captured) = Board.initial.withMove(e2, e4)
-    captured shouldBe None
-    board.pieceAt(e4) shouldBe Some(Piece.WhitePawn)
-    board.pieceAt(e2) shouldBe None
-  }
-
-  test("withMove returns captured piece when destination is occupied") {
-    val from = Square(File.A, Rank.R1)
-    val to   = Square(File.A, Rank.R8)
-    val b    = Board(Map(from -> Piece.WhiteRook, to -> Piece.BlackRook))
-    val (board, captured) = b.withMove(from, to)
-    captured shouldBe Some(Piece.BlackRook)
-    board.pieceAt(to) shouldBe Some(Piece.WhiteRook)
-    board.pieceAt(from) shouldBe None
-  }
-
-  test("pieces returns the underlying map") {
-    val map = Map(e2 -> Piece.WhitePawn)
-    val b   = Board(map)
-    b.pieces shouldBe map
-  }
-
-  test("Board.apply constructs board from map") {
-    val map = Map(e2 -> Piece.WhitePawn)
-    val b   = Board(map)
-    b.pieceAt(e2) shouldBe Some(Piece.WhitePawn)
-  }
-
-  test("initial board has 32 pieces") {
-    Board.initial.pieces should have size 32
-  }
-
-  test("initial board has 16 white pieces") {
-    Board.initial.pieces.values.count(_.color == Color.White) shouldBe 16
-  }
-
-  test("initial board has 16 black pieces") {
-    Board.initial.pieces.values.count(_.color == Color.Black) shouldBe 16
-  }
-
-  test("initial board white pawns on rank 2") {
-    File.values.foreach { file =>
-      Board.initial.pieceAt(Square(file, Rank.R2)) shouldBe Some(Piece.WhitePawn)
-    }
-  }
-
-  test("initial board black pawns on rank 7") {
-    File.values.foreach { file =>
-      Board.initial.pieceAt(Square(file, Rank.R7)) shouldBe Some(Piece.BlackPawn)
-    }
-  }
-
-  test("initial board white back rank") {
-    val expectedBackRank = Vector(
-      PieceType.Rook, PieceType.Knight, PieceType.Bishop, PieceType.Queen,
-      PieceType.King, PieceType.Bishop, PieceType.Knight, PieceType.Rook
-    )
-    File.values.zipWithIndex.foreach { (file, i) =>
-      Board.initial.pieceAt(Square(file, Rank.R1)) shouldBe
-        Some(Piece(Color.White, expectedBackRank(i)))
-    }
-  }
-
-  test("initial board black back rank") {
-    val expectedBackRank = Vector(
-      PieceType.Rook, PieceType.Knight, PieceType.Bishop, PieceType.Queen,
-      PieceType.King, PieceType.Bishop, PieceType.Knight, PieceType.Rook
-    )
-    File.values.zipWithIndex.foreach { (file, i) =>
-      Board.initial.pieceAt(Square(file, Rank.R8)) shouldBe
-        Some(Piece(Color.Black, expectedBackRank(i)))
-    }
-  }
-
-  test("ranks 3-6 are empty on initial board") {
-    val emptyRanks = Seq(Rank.R3, Rank.R4, Rank.R5, Rank.R6)
-    for
-      rank <- emptyRanks
-      file <- File.values
-    do
-      Board.initial.pieceAt(Square(file, rank)) shouldBe None
-  }
-
-  test("updated adds or replaces piece at square") {
-    val b = Board(Map(e2 -> Piece.WhitePawn))
-    val updated = b.updated(e4, Piece.WhiteKnight)
-    updated.pieceAt(e2) shouldBe Some(Piece.WhitePawn)
-    updated.pieceAt(e4) shouldBe Some(Piece.WhiteKnight)
-  }
-
-  test("updated replaces existing piece") {
-    val b = Board(Map(e2 -> Piece.WhitePawn))
-    val updated = b.updated(e2, Piece.WhiteKnight)
-    updated.pieceAt(e2) shouldBe Some(Piece.WhiteKnight)
-  }
-
-  test("removed deletes piece from board") {
-    val b = Board(Map(e2 -> Piece.WhitePawn, e4 -> Piece.WhiteKnight))
-    val removed = b.removed(e2)
-    removed.pieceAt(e2) shouldBe None
-    removed.pieceAt(e4) shouldBe Some(Piece.WhiteKnight)
-  }

modules/api/src/test/scala/de/nowchess/api/board/ColorTest.scala

@@ -1,22 +0,0 @@
-package de.nowchess.api.board
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class ColorTest extends AnyFunSuite with Matchers:
-
-  test("White.opposite returns Black") {
-    Color.White.opposite shouldBe Color.Black
-  }
-
-  test("Black.opposite returns White") {
-    Color.Black.opposite shouldBe Color.White
-  }
-
-  test("White.label returns 'White'") {
-    Color.White.label shouldBe "White"
-  }
-
-  test("Black.label returns 'Black'") {
-    Color.Black.label shouldBe "Black"
-  }

modules/api/src/test/scala/de/nowchess/api/board/PieceTest.scala

@@ -1,60 +0,0 @@
-package de.nowchess.api.board
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class PieceTest extends AnyFunSuite with Matchers:
-
-  test("Piece holds color and pieceType") {
-    val p = Piece(Color.White, PieceType.Queen)
-    p.color    shouldBe Color.White
-    p.pieceType shouldBe PieceType.Queen
-  }
-
-  test("WhitePawn convenience constant") {
-    Piece.WhitePawn shouldBe Piece(Color.White, PieceType.Pawn)
-  }
-
-  test("WhiteKnight convenience constant") {
-    Piece.WhiteKnight shouldBe Piece(Color.White, PieceType.Knight)
-  }
-
-  test("WhiteBishop convenience constant") {
-    Piece.WhiteBishop shouldBe Piece(Color.White, PieceType.Bishop)
-  }
-
-  test("WhiteRook convenience constant") {
-    Piece.WhiteRook shouldBe Piece(Color.White, PieceType.Rook)
-  }
-
-  test("WhiteQueen convenience constant") {
-    Piece.WhiteQueen shouldBe Piece(Color.White, PieceType.Queen)
-  }
-
-  test("WhiteKing convenience constant") {
-    Piece.WhiteKing shouldBe Piece(Color.White, PieceType.King)
-  }
-
-  test("BlackPawn convenience constant") {
-    Piece.BlackPawn shouldBe Piece(Color.Black, PieceType.Pawn)
-  }
-
-  test("BlackKnight convenience constant") {
-    Piece.BlackKnight shouldBe Piece(Color.Black, PieceType.Knight)
-  }
-
-  test("BlackBishop convenience constant") {
-    Piece.BlackBishop shouldBe Piece(Color.Black, PieceType.Bishop)
-  }
-
-  test("BlackRook convenience constant") {
-    Piece.BlackRook shouldBe Piece(Color.Black, PieceType.Rook)
-  }
-
-  test("BlackQueen convenience constant") {
-    Piece.BlackQueen shouldBe Piece(Color.Black, PieceType.Queen)
-  }
-
-  test("BlackKing convenience constant") {
-    Piece.BlackKing shouldBe Piece(Color.Black, PieceType.King)
-  }

modules/api/src/test/scala/de/nowchess/api/board/PieceTypeTest.scala

@@ -1,30 +0,0 @@
-package de.nowchess.api.board
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class PieceTypeTest extends AnyFunSuite with Matchers:
-
-  test("Pawn.label returns 'Pawn'") {
-    PieceType.Pawn.label shouldBe "Pawn"
-  }
-
-  test("Knight.label returns 'Knight'") {
-    PieceType.Knight.label shouldBe "Knight"
-  }
-
-  test("Bishop.label returns 'Bishop'") {
-    PieceType.Bishop.label shouldBe "Bishop"
-  }
-
-  test("Rook.label returns 'Rook'") {
-    PieceType.Rook.label shouldBe "Rook"
-  }
-
-  test("Queen.label returns 'Queen'") {
-    PieceType.Queen.label shouldBe "Queen"
-  }
-
-  test("King.label returns 'King'") {
-    PieceType.King.label shouldBe "King"
-  }

modules/api/src/test/scala/de/nowchess/api/board/SquareTest.scala

@@ -1,62 +0,0 @@
-package de.nowchess.api.board
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class SquareTest extends AnyFunSuite with Matchers:
-
-  test("Square.toString produces lowercase file and rank number") {
-    Square(File.E, Rank.R4).toString shouldBe "e4"
-  }
-
-  test("Square.toString for a1") {
-    Square(File.A, Rank.R1).toString shouldBe "a1"
-  }
-
-  test("Square.toString for h8") {
-    Square(File.H, Rank.R8).toString shouldBe "h8"
-  }
-
-  test("fromAlgebraic parses valid square e4") {
-    Square.fromAlgebraic("e4") shouldBe Some(Square(File.E, Rank.R4))
-  }
-
-  test("fromAlgebraic parses valid square a1") {
-    Square.fromAlgebraic("a1") shouldBe Some(Square(File.A, Rank.R1))
-  }
-
-  test("fromAlgebraic parses valid square h8") {
-    Square.fromAlgebraic("h8") shouldBe Some(Square(File.H, Rank.R8))
-  }
-
-  test("fromAlgebraic is case-insensitive for file") {
-    Square.fromAlgebraic("E4") shouldBe Some(Square(File.E, Rank.R4))
-  }
-
-  test("fromAlgebraic returns None for empty string") {
-    Square.fromAlgebraic("") shouldBe None
-  }
-
-  test("fromAlgebraic returns None for string too short") {
-    Square.fromAlgebraic("e") shouldBe None
-  }
-
-  test("fromAlgebraic returns None for string too long") {
-    Square.fromAlgebraic("e42") shouldBe None
-  }
-
-  test("fromAlgebraic returns None for invalid file character") {
-    Square.fromAlgebraic("z4") shouldBe None
-  }
-
-  test("fromAlgebraic returns None for non-digit rank") {
-    Square.fromAlgebraic("ex") shouldBe None
-  }
-
-  test("fromAlgebraic returns None for rank 0") {
-    Square.fromAlgebraic("e0") shouldBe None
-  }
-
-  test("fromAlgebraic returns None for rank 9") {
-    Square.fromAlgebraic("e9") shouldBe None
-  }

modules/api/src/test/scala/de/nowchess/api/game/GameStateTest.scala

@@ -1,77 +0,0 @@
-package de.nowchess.api.game
-
-import de.nowchess.api.board.Color
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class GameStateTest extends AnyFunSuite with Matchers:
-
-  test("CastlingRights.None has both flags false") {
-    CastlingRights.None.kingSide  shouldBe false
-    CastlingRights.None.queenSide shouldBe false
-  }
-
-  test("CastlingRights.Both has both flags true") {
-    CastlingRights.Both.kingSide  shouldBe true
-    CastlingRights.Both.queenSide shouldBe true
-  }
-
-  test("CastlingRights constructor sets fields") {
-    val cr = CastlingRights(kingSide = true, queenSide = false)
-    cr.kingSide  shouldBe true
-    cr.queenSide shouldBe false
-  }
-
-  test("GameResult cases exist") {
-    GameResult.WhiteWins shouldBe GameResult.WhiteWins
-    GameResult.BlackWins shouldBe GameResult.BlackWins
-    GameResult.Draw      shouldBe GameResult.Draw
-  }
-
-  test("GameStatus.NotStarted") {
-    GameStatus.NotStarted shouldBe GameStatus.NotStarted
-  }
-
-  test("GameStatus.InProgress") {
-    GameStatus.InProgress shouldBe GameStatus.InProgress
-  }
-
-  test("GameStatus.Finished carries result") {
-    val status = GameStatus.Finished(GameResult.Draw)
-    status shouldBe GameStatus.Finished(GameResult.Draw)
-    status match
-      case GameStatus.Finished(r) => r shouldBe GameResult.Draw
-      case _                      => fail("expected Finished")
-  }
-
-  test("GameState.initial has standard FEN piece placement") {
-    GameState.initial.piecePlacement shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
-  }
-
-  test("GameState.initial active color is White") {
-    GameState.initial.activeColor shouldBe Color.White
-  }
-
-  test("GameState.initial white has full castling rights") {
-    GameState.initial.castlingWhite shouldBe CastlingRights.Both
-  }
-
-  test("GameState.initial black has full castling rights") {
-    GameState.initial.castlingBlack shouldBe CastlingRights.Both
-  }
-
-  test("GameState.initial en-passant target is None") {
-    GameState.initial.enPassantTarget shouldBe None
-  }
-
-  test("GameState.initial half-move clock is 0") {
-    GameState.initial.halfMoveClock shouldBe 0
-  }
-
-  test("GameState.initial full-move number is 1") {
-    GameState.initial.fullMoveNumber shouldBe 1
-  }
-
-  test("GameState.initial status is InProgress") {
-    GameState.initial.status shouldBe GameStatus.InProgress
-  }

modules/api/src/test/scala/de/nowchess/api/move/MoveTest.scala

@@ -1,56 +0,0 @@
-package de.nowchess.api.move
-
-import de.nowchess.api.board.{File, Rank, Square}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class MoveTest extends AnyFunSuite with Matchers:
-
-  private val e2 = Square(File.E, Rank.R2)
-  private val e4 = Square(File.E, Rank.R4)
-
-  test("Move defaults moveType to Normal") {
-    val m = Move(e2, e4)
-    m.moveType shouldBe MoveType.Normal
-  }
-
-  test("Move stores from and to squares") {
-    val m = Move(e2, e4)
-    m.from shouldBe e2
-    m.to   shouldBe e4
-  }
-
-  test("Move with CastleKingside moveType") {
-    val m = Move(e2, e4, MoveType.CastleKingside)
-    m.moveType shouldBe MoveType.CastleKingside
-  }
-
-  test("Move with CastleQueenside moveType") {
-    val m = Move(e2, e4, MoveType.CastleQueenside)
-    m.moveType shouldBe MoveType.CastleQueenside
-  }
-
-  test("Move with EnPassant moveType") {
-    val m = Move(e2, e4, MoveType.EnPassant)
-    m.moveType shouldBe MoveType.EnPassant
-  }
-
-  test("Move with Promotion to Queen") {
-    val m = Move(e2, e4, MoveType.Promotion(PromotionPiece.Queen))
-    m.moveType shouldBe MoveType.Promotion(PromotionPiece.Queen)
-  }
-
-  test("Move with Promotion to Knight") {
-    val m = Move(e2, e4, MoveType.Promotion(PromotionPiece.Knight))
-    m.moveType shouldBe MoveType.Promotion(PromotionPiece.Knight)
-  }
-
-  test("Move with Promotion to Bishop") {
-    val m = Move(e2, e4, MoveType.Promotion(PromotionPiece.Bishop))
-    m.moveType shouldBe MoveType.Promotion(PromotionPiece.Bishop)
-  }
-
-  test("Move with Promotion to Rook") {
-    val m = Move(e2, e4, MoveType.Promotion(PromotionPiece.Rook))
-    m.moveType shouldBe MoveType.Promotion(PromotionPiece.Rook)
-  }

modules/api/src/test/scala/de/nowchess/api/player/PlayerInfoTest.scala

@@ -1,23 +0,0 @@
-package de.nowchess.api.player
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class PlayerInfoTest extends AnyFunSuite with Matchers:
-
-  test("PlayerId.apply wraps a string") {
-    val id = PlayerId("player-123")
-    id.value shouldBe "player-123"
-  }
-
-  test("PlayerId.value unwraps to original string") {
-    val raw = "abc-456"
-    PlayerId(raw).value shouldBe raw
-  }
-
-  test("PlayerInfo holds id and displayName") {
-    val id   = PlayerId("p1")
-    val info = PlayerInfo(id, "Magnus")
-    info.id.value      shouldBe "p1"
-    info.displayName   shouldBe "Magnus"
-  }

modules/api/src/test/scala/de/nowchess/api/response/ApiResponseTest.scala

@@ -1,62 +0,0 @@
-package de.nowchess.api.response
-
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class ApiResponseTest extends AnyFunSuite with Matchers:
-
-  test("ApiResponse.Success carries data") {
-    val r = ApiResponse.Success(42)
-    r.data shouldBe 42
-  }
-
-  test("ApiResponse.Failure carries error list") {
-    val err = ApiError("CODE", "msg")
-    val r   = ApiResponse.Failure(List(err))
-    r.errors shouldBe List(err)
-  }
-
-  test("ApiResponse.error creates single-error Failure") {
-    val err = ApiError("NOT_FOUND", "not found")
-    val f   = ApiResponse.error(err)
-    f shouldBe ApiResponse.Failure(List(err))
-  }
-
-  test("ApiError holds code and message") {
-    val e = ApiError("CODE", "message")
-    e.code    shouldBe "CODE"
-    e.message shouldBe "message"
-    e.field   shouldBe None
-  }
-
-  test("ApiError holds optional field") {
-    val e = ApiError("INVALID", "bad value", Some("email"))
-    e.field shouldBe Some("email")
-  }
-
-  test("Pagination.totalPages with exact division") {
-    Pagination(page = 0, pageSize = 10, totalItems = 30).totalPages shouldBe 3
-  }
-
-  test("Pagination.totalPages rounds up") {
-    Pagination(page = 0, pageSize = 10, totalItems = 25).totalPages shouldBe 3
-  }
-
-  test("Pagination.totalPages is 0 when totalItems is 0") {
-    Pagination(page = 0, pageSize = 10, totalItems = 0).totalPages shouldBe 0
-  }
-
-  test("Pagination.totalPages is 0 when pageSize is 0") {
-    Pagination(page = 0, pageSize = 0, totalItems = 100).totalPages shouldBe 0
-  }
-
-  test("Pagination.totalPages is 0 when pageSize is negative") {
-    Pagination(page = 0, pageSize = -1, totalItems = 100).totalPages shouldBe 0
-  }
-
-  test("PagedResponse holds items and pagination") {
-    val pagination = Pagination(page = 1, pageSize = 5, totalItems = 20)
-    val pr         = PagedResponse(List("a", "b"), pagination)
-    pr.items      shouldBe List("a", "b")
-    pr.pagination shouldBe pagination
-  }

modules/api/versions.env

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

modules/core/CHANGELOG.md

@@ -1,46 +0,0 @@
-##  (2026-03-27)
-
-### Features
-
-* add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
-* add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
-* 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))
-* 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))
-* correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
-* update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
-##  (2026-03-28)
-
-### Features
-
-* add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
-* add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
-* 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))
-* 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))
-* correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
-* update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))
-##  (2026-03-29)
-
-### Features
-
-* add GameRules stub with PositionStatus enum ([76d4168](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/76d4168038de23e5d6083d4e8f0504fbf31d15a3))
-* add MovedInCheck/Checkmate/Stalemate MoveResult variants (stub dispatch) ([8b7ec57](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/8b7ec57e5ea6ee1615a1883848a426dc07d26364))
-* 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))
-* 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))
-* 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))
-* correct test board positions and captureOutput/withInput interaction ([f0481e2](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f0481e2561b779df00925b46ee281dc36a795150))
-* update main class path in build configuration and adjust VCS directory mapping ([7b1f8b1](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/7b1f8b117623d327232a1a92a8a44d18582e0189))

modules/core/build.gradle.kts

@@ -52,10 +52,9 @@ dependencies {
 
     testImplementation(platform("org.junit:junit-bom:5.13.4"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     testImplementation("org.scalatest:scalatest_3:${versions["SCALATEST"]!!}")
     testImplementation("co.helmethair:scalatest-junit-runner:${versions["SCALATEST_JUNIT"]!!}")
-
-    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
 }
 
 tasks.test {

modules/core/src/main/scala/de/nowchess/chess/Main.scala

@@ -1,12 +1,11 @@
 package de.nowchess.chess
 
-import de.nowchess.api.board.Board
 import de.nowchess.api.board.Color
 import de.nowchess.chess.controller.GameController
-import de.nowchess.chess.logic.GameHistory
+import de.nowchess.chess.logic.GameContext
 
 object Main {
   def main(args: Array[String]): Unit =
     println("NowChess TUI — type moves in coordinate notation (e.g. e2e4). Type 'quit' to exit.")
-    GameController.gameLoop(Board.initial, GameHistory.empty, Color.White)
+    GameController.gameLoop(GameContext.initial, Color.White)
 }

modules/core/src/main/scala/de/nowchess/chess/controller/GameController.scala

@@ -2,7 +2,8 @@ package de.nowchess.chess.controller
 
 import scala.io.StdIn
 import de.nowchess.api.board.{Board, Color, File, Piece, Rank, Square}
-import de.nowchess.chess.logic.*
+import de.nowchess.api.game.CastlingRights
+import de.nowchess.chess.logic.{GameContext, MoveValidator, GameRules, PositionStatus, CastleSide, withCastle}
 import de.nowchess.chess.view.Renderer
 
 // ---------------------------------------------------------------------------
@@ -16,8 +17,8 @@ object MoveResult:
   case object NoPiece                                                                   extends MoveResult
   case object WrongColor                                                                extends MoveResult
   case object IllegalMove                                                               extends MoveResult
-  case class  Moved(newBoard: Board, newHistory: GameHistory, captured: Option[Piece], newTurn: Color)      extends MoveResult
-  case class  MovedInCheck(newBoard: Board, newHistory: GameHistory, captured: Option[Piece], newTurn: Color) extends MoveResult
+  case class  Moved(newCtx: GameContext, captured: Option[Piece], newTurn: Color)      extends MoveResult
+  case class  MovedInCheck(newCtx: GameContext, captured: Option[Piece], newTurn: Color) extends MoveResult
   case class  Checkmate(winner: Color)                                                  extends MoveResult
   case object Stalemate                                                                 extends MoveResult
 
@@ -30,7 +31,7 @@ object GameController:
   /** Pure function: interprets one raw input line against the current game context.
    *  Has no I/O side effects — all output must be handled by the caller.
    */
-  def processMove(board: Board, history: GameHistory, turn: Color, raw: String): MoveResult =
+  def processMove(ctx: GameContext, turn: Color, raw: String): MoveResult =
     raw.trim match
       case "quit" | "q" =>
         MoveResult.Quit
@@ -39,73 +40,97 @@ object GameController:
           case None =>
             MoveResult.InvalidFormat(trimmed)
           case Some((from, to)) =>
-            board.pieceAt(from) match
+            ctx.board.pieceAt(from) match
               case None =>
                 MoveResult.NoPiece
               case Some(piece) if piece.color != turn =>
                 MoveResult.WrongColor
               case Some(_) =>
-                if !MoveValidator.isLegal(board, history, from, to) then
+                if !MoveValidator.isLegal(ctx, from, to) then
                   MoveResult.IllegalMove
                 else
-                  val castleOpt = if MoveValidator.isCastle(board, from, to)
+                  val castleOpt = if MoveValidator.isCastle(ctx.board, from, to)
                                   then Some(MoveValidator.castleSide(from, to))
                                   else None
-                  val isEP = EnPassantCalculator.isEnPassant(board, history, from, to)
                   val (newBoard, captured) = castleOpt match
-                    case Some(side) => (board.withCastle(turn, side), None)
-                    case None =>
-                      val (b, cap) = board.withMove(from, to)
-                      if isEP then
-                        val capturedSq = EnPassantCalculator.capturedPawnSquare(to, turn)
-                        (b.removed(capturedSq), board.pieceAt(capturedSq))
-                      else (b, cap)
-                  val newHistory = history.addMove(from, to, castleOpt)
-                  GameRules.gameStatus(newBoard, newHistory, turn.opposite) match
-                    case PositionStatus.Normal  => MoveResult.Moved(newBoard, newHistory, captured, turn.opposite)
-                    case PositionStatus.InCheck => MoveResult.MovedInCheck(newBoard, newHistory, captured, turn.opposite)
+                    case Some(side) => (ctx.board.withCastle(turn, side), None)
+                    case None       => ctx.board.withMove(from, to)
+                  val newCtx = applyRightsRevocation(
+                    ctx.copy(board = newBoard), turn, from, to, castleOpt
+                  )
+                  GameRules.gameStatus(newCtx, turn.opposite) match
+                    case PositionStatus.Normal  => MoveResult.Moved(newCtx, captured, turn.opposite)
+                    case PositionStatus.InCheck => MoveResult.MovedInCheck(newCtx, captured, turn.opposite)
                     case PositionStatus.Mated   => MoveResult.Checkmate(turn)
                     case PositionStatus.Drawn   => MoveResult.Stalemate
 
+  private def applyRightsRevocation(
+    ctx: GameContext,
+    turn: Color,
+    from: Square,
+    to: Square,
+    castle: Option[CastleSide]
+  ): GameContext =
+    // Step 1: Revoke all rights for a castling move (idempotent with step 2)
+    val ctx0 = castle.fold(ctx)(_ => ctx.withUpdatedRights(turn, CastlingRights.None))
+
+    // Step 2: Source-square revocation
+    val ctx1 = from match
+      case Square(File.E, Rank.R1) => ctx0.withUpdatedRights(Color.White, CastlingRights.None)
+      case Square(File.E, Rank.R8) => ctx0.withUpdatedRights(Color.Black, CastlingRights.None)
+      case Square(File.A, Rank.R1) => ctx0.withUpdatedRights(Color.White, ctx0.whiteCastling.copy(queenSide = false))
+      case Square(File.H, Rank.R1) => ctx0.withUpdatedRights(Color.White, ctx0.whiteCastling.copy(kingSide  = false))
+      case Square(File.A, Rank.R8) => ctx0.withUpdatedRights(Color.Black, ctx0.blackCastling.copy(queenSide = false))
+      case Square(File.H, Rank.R8) => ctx0.withUpdatedRights(Color.Black, ctx0.blackCastling.copy(kingSide  = false))
+      case _                       => ctx0
+
+    // Step 3: Destination-square revocation (enemy captures a rook on its home square)
+    to match
+      case Square(File.A, Rank.R1) => ctx1.withUpdatedRights(Color.White, ctx1.whiteCastling.copy(queenSide = false))
+      case Square(File.H, Rank.R1) => ctx1.withUpdatedRights(Color.White, ctx1.whiteCastling.copy(kingSide  = false))
+      case Square(File.A, Rank.R8) => ctx1.withUpdatedRights(Color.Black, ctx1.blackCastling.copy(queenSide = false))
+      case Square(File.H, Rank.R8) => ctx1.withUpdatedRights(Color.Black, ctx1.blackCastling.copy(kingSide  = false))
+      case _                       => ctx1
+
   /** Thin I/O shell: renders the board, reads a line, delegates to processMove,
    *  prints the outcome, and recurses until the game ends.
    */
-  def gameLoop(board: Board, history: GameHistory, turn: Color): Unit =
+  def gameLoop(ctx: GameContext, turn: Color): Unit =
     println()
-    print(Renderer.render(board))
+    print(Renderer.render(ctx.board))
     println(s"${turn.label}'s turn. Enter move: ")
     val input = Option(StdIn.readLine()).getOrElse("quit").trim
-    processMove(board, history, turn, input) match
+    processMove(ctx, turn, input) match
       case MoveResult.Quit =>
         println("Game over. Goodbye!")
       case MoveResult.InvalidFormat(raw) =>
         println(s"Invalid move format '$raw'. Use coordinate notation, e.g. e2e4.")
-        gameLoop(board, history, turn)
+        gameLoop(ctx, turn)
       case MoveResult.NoPiece =>
         println(s"No piece on ${Parser.parseMove(input).map(_._1).fold("?")(_.toString)}.")
-        gameLoop(board, history, turn)
+        gameLoop(ctx, turn)
       case MoveResult.WrongColor =>
         println(s"That is not your piece.")
-        gameLoop(board, history, turn)
+        gameLoop(ctx, turn)
       case MoveResult.IllegalMove =>
         println(s"Illegal move.")
-        gameLoop(board, history, turn)
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
+        gameLoop(ctx, turn)
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
         val prevTurn = newTurn.opposite
         captured.foreach: cap =>
           val toSq = Parser.parseMove(input).map(_._2).fold("?")(_.toString)
           println(s"${prevTurn.label} captures ${cap.color.label} ${cap.pieceType.label} on $toSq")
-        gameLoop(newBoard, newHistory, newTurn)
-      case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
+        gameLoop(newCtx, newTurn)
+      case MoveResult.MovedInCheck(newCtx, captured, newTurn) =>
         val prevTurn = newTurn.opposite
         captured.foreach: cap =>
           val toSq = Parser.parseMove(input).map(_._2).fold("?")(_.toString)
           println(s"${prevTurn.label} captures ${cap.color.label} ${cap.pieceType.label} on $toSq")
         println(s"${newTurn.label} is in check!")
-        gameLoop(newBoard, newHistory, newTurn)
+        gameLoop(newCtx, newTurn)
       case MoveResult.Checkmate(winner) =>
         println(s"Checkmate! ${winner.label} wins.")
-        gameLoop(Board.initial, GameHistory.empty, Color.White)
+        gameLoop(GameContext.initial, Color.White)
       case MoveResult.Stalemate =>
         println("Stalemate! The game is a draw.")
-        gameLoop(Board.initial, GameHistory.empty, Color.White)
+        gameLoop(GameContext.initial, Color.White)

modules/core/src/main/scala/de/nowchess/chess/logic/CastleSide.scala

@@ -1,23 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.*
-
-enum CastleSide:
-  case Kingside, Queenside
-
-extension (b: Board)
-  def withCastle(color: Color, side: CastleSide): Board =
-    val rank = if color == Color.White then Rank.R1 else Rank.R8
-    val kingFrom = Square(File.E, rank)
-    val (kingTo, rookFrom, rookTo) = side match
-      case CastleSide.Kingside =>
-        (Square(File.G, rank), Square(File.H, rank), Square(File.F, rank))
-      case CastleSide.Queenside =>
-        (Square(File.C, rank), Square(File.A, rank), Square(File.D, rank))
-
-    val king = b.pieceAt(kingFrom).get
-    val rook = b.pieceAt(rookFrom).get
-
-    b.removed(kingFrom).removed(rookFrom)
-      .updated(kingTo, king)
-      .updated(rookTo, rook)

modules/core/src/main/scala/de/nowchess/chess/logic/CastlingRightsCalculator.scala

@@ -1,31 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.{Color, File, Rank, Square}
-import de.nowchess.api.game.CastlingRights
-
-/** Derives castling rights from move history. */
-object CastlingRightsCalculator:
-
-  def deriveCastlingRights(history: GameHistory, color: Color): CastlingRights =
-    val (kingRow, kingsideRookFile, queensideRookFile) = color match
-      case Color.White => (Rank.R1, File.H, File.A)
-      case Color.Black => (Rank.R8, File.H, File.A)
-
-    // Check if king has moved
-    val kingHasMoved = history.moves.exists: move =>
-      move.from == Square(File.E, kingRow) || move.castleSide.isDefined
-
-    if kingHasMoved then
-      CastlingRights.None
-    else
-      // Check if kingside rook has moved or was captured
-      val kingsideLost = history.moves.exists: move =>
-        move.from == Square(kingsideRookFile, kingRow) ||
-        move.to == Square(kingsideRookFile, kingRow)
-
-      // Check if queenside rook has moved or was captured
-      val queensideLost = history.moves.exists: move =>
-        move.from == Square(queensideRookFile, kingRow) ||
-        move.to == Square(queensideRookFile, kingRow)
-
-      CastlingRights(kingSide = !kingsideLost, queenSide = !queensideLost)

modules/core/src/main/scala/de/nowchess/chess/logic/EnPassantCalculator.scala

@@ -1,32 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.*
-
-object EnPassantCalculator:
-
-  /** Returns the en passant target square if the last move was a double pawn push.
-   *  The target is the square the pawn passed through (e.g. e2→e4 yields e3).
-   */
-  def enPassantTarget(board: Board, history: GameHistory): Option[Square] =
-    history.moves.lastOption.flatMap: move =>
-      val rankDiff = move.to.rank.ordinal - move.from.rank.ordinal
-      val isDoublePush = math.abs(rankDiff) == 2
-      val isPawn = board.pieceAt(move.to).exists(_.pieceType == PieceType.Pawn)
-      if isDoublePush && isPawn then
-        val midRankIdx = move.from.rank.ordinal + rankDiff / 2
-        Some(Square(move.to.file, Rank.values(midRankIdx)))
-      else None
-
-  /** True if moving from→to is an en passant capture. */
-  def isEnPassant(board: Board, history: GameHistory, from: Square, to: Square): Boolean =
-    board.pieceAt(from).exists(_.pieceType == PieceType.Pawn) &&
-    enPassantTarget(board, history).contains(to) &&
-    math.abs(to.file.ordinal - from.file.ordinal) == 1
-
-  /** Returns the square of the pawn to remove when an en passant capture lands on `to`.
-   *  White captures upward → captured pawn is one rank below `to`.
-   *  Black captures downward → captured pawn is one rank above `to`.
-   */
-  def capturedPawnSquare(to: Square, color: Color): Square =
-    val capturedRankIdx = to.rank.ordinal + (if color == Color.White then -1 else 1)
-    Square(to.file, Rank.values(capturedRankIdx))

modules/core/src/main/scala/de/nowchess/chess/logic/GameContext.scala

@@ -0,0 +1,47 @@
+package de.nowchess.chess.logic
+
+import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
+import de.nowchess.api.game.CastlingRights
+
+enum CastleSide:
+  case Kingside, Queenside
+
+case class GameContext(
+  board: Board,
+  whiteCastling: CastlingRights,
+  blackCastling: CastlingRights
+):
+  def castlingFor(color: Color): CastlingRights =
+    if color == Color.White then whiteCastling else blackCastling
+
+  def withUpdatedRights(color: Color, rights: CastlingRights): GameContext =
+    if color == Color.White then copy(whiteCastling = rights)
+    else copy(blackCastling = rights)
+
+object GameContext:
+  /** Convenience constructor for test boards: no castling rights on either side. */
+  def apply(board: Board): GameContext =
+    GameContext(board, CastlingRights.None, CastlingRights.None)
+
+  val initial: GameContext =
+    GameContext(Board.initial, CastlingRights.Both, CastlingRights.Both)
+
+extension (b: Board)
+  def withCastle(color: Color, side: CastleSide): Board =
+    val (kingFrom, kingTo, rookFrom, rookTo) = (color, side) match
+      case (Color.White, CastleSide.Kingside)  =>
+        (Square(File.E, Rank.R1), Square(File.G, Rank.R1),
+         Square(File.H, Rank.R1), Square(File.F, Rank.R1))
+      case (Color.White, CastleSide.Queenside) =>
+        (Square(File.E, Rank.R1), Square(File.C, Rank.R1),
+         Square(File.A, Rank.R1), Square(File.D, Rank.R1))
+      case (Color.Black, CastleSide.Kingside)  =>
+        (Square(File.E, Rank.R8), Square(File.G, Rank.R8),
+         Square(File.H, Rank.R8), Square(File.F, Rank.R8))
+      case (Color.Black, CastleSide.Queenside) =>
+        (Square(File.E, Rank.R8), Square(File.C, Rank.R8),
+         Square(File.A, Rank.R8), Square(File.D, Rank.R8))
+    val king = Piece(color, PieceType.King)
+    val rook = Piece(color, PieceType.Rook)
+    Board(b.pieces.removed(kingFrom).removed(rookFrom)
+                  .updated(kingTo, king).updated(rookTo, rook))

modules/core/src/main/scala/de/nowchess/chess/logic/GameHistory.scala

@@ -1,24 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.Square
-
-/** A single move recorded in the game history. Distinct from api.move.Move which represents user intent. */
-case class HistoryMove(
-  from: Square,
-  to: Square,
-  castleSide: Option[CastleSide]
-)
-
-/** Complete game history: ordered list of moves. */
-case class GameHistory(moves: List[HistoryMove] = List.empty):
-  def addMove(move: HistoryMove): GameHistory =
-    GameHistory(moves :+ move)
-
-  def addMove(from: Square, to: Square): GameHistory =
-    addMove(HistoryMove(from, to, None))
-
-  def addMove(from: Square, to: Square, castleSide: Option[CastleSide]): GameHistory =
-    addMove(HistoryMove(from, to, castleSide))
-
-object GameHistory:
-  val empty: GameHistory = GameHistory()

modules/core/src/main/scala/de/nowchess/chess/logic/GameRules.scala

@@ -1,7 +1,7 @@
 package de.nowchess.chess.logic
 
 import de.nowchess.api.board.*
-import de.nowchess.chess.logic.GameHistory
+import de.nowchess.chess.logic.GameContext
 
 enum PositionStatus:
   case Normal, InCheck, Mated, Drawn
@@ -20,17 +20,17 @@ object GameRules:
       }
 
   /** All (from, to) moves for `color` that do not leave their own king in check. */
-  def legalMoves(board: Board, history: GameHistory, color: Color): Set[(Square, Square)] =
-    board.pieces
+  def legalMoves(ctx: GameContext, color: Color): Set[(Square, Square)] =
+    ctx.board.pieces
       .collect { case (from, piece) if piece.color == color => from }
       .flatMap { from =>
-        MoveValidator.legalTargets(board, history, from)           // context-aware: includes castling
+        MoveValidator.legalTargets(ctx, from)           // context-aware: includes castling
           .filter { to =>
             val newBoard =
-              if MoveValidator.isCastle(board, from, to) then
-                board.withCastle(color, MoveValidator.castleSide(from, to))
+              if MoveValidator.isCastle(ctx.board, from, to) then
+                ctx.board.withCastle(color, MoveValidator.castleSide(from, to))
               else
-                board.withMove(from, to)._1
+                ctx.board.withMove(from, to)._1
             !isInCheck(newBoard, color)
           }
           .map(to => from -> to)
@@ -38,9 +38,9 @@ object GameRules:
       .toSet
 
   /** Position status for the side whose turn it is (`color`). */
-  def gameStatus(board: Board, history: GameHistory, color: Color): PositionStatus =
-    val moves   = legalMoves(board, history, color)
-    val inCheck = isInCheck(board, color)
+  def gameStatus(ctx: GameContext, color: Color): PositionStatus =
+    val moves   = legalMoves(ctx, color)
+    val inCheck = isInCheck(ctx.board, color)
     if moves.isEmpty && inCheck then PositionStatus.Mated
     else if moves.isEmpty       then PositionStatus.Drawn
     else if inCheck             then PositionStatus.InCheck

modules/core/src/main/scala/de/nowchess/chess/logic/MoveValidator.scala

@@ -1,7 +1,7 @@
 package de.nowchess.chess.logic
 
 import de.nowchess.api.board.*
-import de.nowchess.chess.logic.{CastleSide, GameHistory}
+import de.nowchess.chess.logic.{GameContext, CastleSide}
 
 object MoveValidator:
 
@@ -126,50 +126,37 @@ object MoveValidator:
   def castleSide(from: Square, to: Square): CastleSide =
     if to.file.ordinal > from.file.ordinal then CastleSide.Kingside else CastleSide.Queenside
 
-  def castlingTargets(board: Board, history: GameHistory, color: Color): Set[Square] =
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, color)
+  def castlingTargets(ctx: GameContext, color: Color): Set[Square] =
+    val rights = ctx.castlingFor(color)
     val rank   = if color == Color.White then Rank.R1 else Rank.R8
     val kingSq = Square(File.E, rank)
     val enemy  = color.opposite
 
-    if !board.pieceAt(kingSq).contains(Piece(color, PieceType.King)) ||
-       GameRules.isInCheck(board, color) then Set.empty
+    if !ctx.board.pieceAt(kingSq).contains(Piece(color, PieceType.King)) ||
+       GameRules.isInCheck(ctx.board, color) then Set.empty
     else
       val kingsideSq = Option.when(
         rights.kingSide &&
-        board.pieceAt(Square(File.H, rank)).contains(Piece(color, PieceType.Rook)) &&
-        List(Square(File.F, rank), Square(File.G, rank)).forall(s => board.pieceAt(s).isEmpty) &&
-        !List(Square(File.F, rank), Square(File.G, rank)).exists(s => isAttackedBy(board, s, enemy))
+        ctx.board.pieceAt(Square(File.H, rank)).contains(Piece(color, PieceType.Rook)) &&
+        List(Square(File.F, rank), Square(File.G, rank)).forall(s => ctx.board.pieceAt(s).isEmpty) &&
+        !List(Square(File.F, rank), Square(File.G, rank)).exists(s => isAttackedBy(ctx.board, s, enemy))
       )(Square(File.G, rank))
 
       val queensideSq = Option.when(
         rights.queenSide &&
-        board.pieceAt(Square(File.A, rank)).contains(Piece(color, PieceType.Rook)) &&
-        List(Square(File.B, rank), Square(File.C, rank), Square(File.D, rank)).forall(s => board.pieceAt(s).isEmpty) &&
-        !List(Square(File.D, rank), Square(File.C, rank)).exists(s => isAttackedBy(board, s, enemy))
+        ctx.board.pieceAt(Square(File.A, rank)).contains(Piece(color, PieceType.Rook)) &&
+        List(Square(File.B, rank), Square(File.C, rank), Square(File.D, rank)).forall(s => ctx.board.pieceAt(s).isEmpty) &&
+        !List(Square(File.D, rank), Square(File.C, rank)).exists(s => isAttackedBy(ctx.board, s, enemy))
       )(Square(File.C, rank))
 
       kingsideSq.toSet ++ queensideSq.toSet
 
-  def legalTargets(board: Board, history: GameHistory, from: Square): Set[Square] =
-    board.pieceAt(from) match
+  def legalTargets(ctx: GameContext, from: Square): Set[Square] =
+    ctx.board.pieceAt(from) match
       case Some(piece) if piece.pieceType == PieceType.King =>
-        legalTargets(board, from) ++ castlingTargets(board, history, piece.color)
-      case Some(piece) if piece.pieceType == PieceType.Pawn =>
-        pawnTargets(board, history, from, piece.color)
+        legalTargets(ctx.board, from) ++ castlingTargets(ctx, piece.color)
       case _ =>
-        legalTargets(board, from)
+        legalTargets(ctx.board, from)
 
-  private def pawnTargets(board: Board, history: GameHistory, from: Square, color: Color): Set[Square] =
-    val existing = pawnTargets(board, from, color)
-    val fi  = from.file.ordinal
-    val ri  = from.rank.ordinal
-    val dir = if color == Color.White then 1 else -1
-    val epCapture: Set[Square] =
-      EnPassantCalculator.enPassantTarget(board, history).filter: target =>
-        squareAt(fi - 1, ri + dir).contains(target) || squareAt(fi + 1, ri + dir).contains(target)
-      .toSet
-    existing ++ epCapture
-
-  def isLegal(board: Board, history: GameHistory, from: Square, to: Square): Boolean =
-    legalTargets(board, history, from).contains(to)
+  def isLegal(ctx: GameContext, from: Square, to: Square): Boolean =
+    legalTargets(ctx, from).contains(to)

modules/core/src/main/scala/de/nowchess/chess/notation/FenExporter.scala

@@ -1,60 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.api.game.{CastlingRights, GameState}
-import de.nowchess.api.board.Color
-
-object FenExporter:
-
-  /** Convert a Board to FEN piece-placement string (rank 8 to rank 1, separated by '/'). */
-  def boardToFen(board: Board): String =
-    Rank.values.reverse
-      .map(rank => buildRankString(board, rank))
-      .mkString("/")
-
-  /** Build the FEN representation for a single rank. */
-  private def buildRankString(board: Board, rank: Rank): String =
-    val rankSquares = File.values.map(file => Square(file, rank))
-    val rankChars = scala.collection.mutable.ListBuffer[Char]()
-    var emptyCount = 0
-
-    for square <- rankSquares do
-      board.pieceAt(square) match
-        case Some(piece) =>
-          if emptyCount > 0 then
-            rankChars += emptyCount.toString.charAt(0)
-            emptyCount = 0
-          rankChars += pieceToPgnChar(piece)
-        case None =>
-          emptyCount += 1
-
-    if emptyCount > 0 then rankChars += emptyCount.toString.charAt(0)
-    rankChars.mkString
-
-  /** Convert a GameState to a complete FEN string. */
-  def gameStateToFen(state: GameState): String =
-    val piecePlacement = state.piecePlacement
-    val activeColor = if state.activeColor == Color.White then "w" else "b"
-    val castling = castlingString(state.castlingWhite, state.castlingBlack)
-    val enPassant = state.enPassantTarget.map(_.toString).getOrElse("-")
-    s"$piecePlacement $activeColor $castling $enPassant ${state.halfMoveClock} ${state.fullMoveNumber}"
-
-  /** Convert castling rights to FEN notation. */
-  private def castlingString(white: CastlingRights, black: CastlingRights): String =
-    val wk = if white.kingSide then "K" else ""
-    val wq = if white.queenSide then "Q" else ""
-    val bk = if black.kingSide then "k" else ""
-    val bq = if black.queenSide then "q" else ""
-    val result = s"$wk$wq$bk$bq"
-    if result.isEmpty then "-" else result
-
-  /** Convert a Piece to its FEN character (uppercase = White, lowercase = Black). */
-  private def pieceToPgnChar(piece: Piece): Char =
-    val base = piece.pieceType match
-      case PieceType.Pawn   => 'p'
-      case PieceType.Knight => 'n'
-      case PieceType.Bishop => 'b'
-      case PieceType.Rook   => 'r'
-      case PieceType.Queen  => 'q'
-      case PieceType.King   => 'k'
-    if piece.color == Color.White then base.toUpper else base

modules/core/src/main/scala/de/nowchess/chess/notation/FenParser.scala

@@ -1,103 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.api.game.{CastlingRights, GameState, GameStatus}
-
-object FenParser:
-
-  /** Parse a complete FEN string into a GameState.
-   *  Returns None if the format is invalid. */
-  def parseFen(fen: String): Option[GameState] =
-    val parts = fen.trim.split("\\s+")
-    Option.when(parts.length == 6)(parts).flatMap: parts =>
-      for
-        _ <- parseBoard(parts(0))
-        activeColor <- parseColor(parts(1))
-        castlingRights <- parseCastling(parts(2))
-        enPassant <- parseEnPassant(parts(3))
-        halfMoveClock <- parts(4).toIntOption
-        fullMoveNumber <- parts(5).toIntOption
-        if halfMoveClock >= 0 && fullMoveNumber >= 1
-      yield GameState(
-        piecePlacement = parts(0),
-        activeColor = activeColor,
-        castlingWhite = castlingRights._1,
-        castlingBlack = castlingRights._2,
-        enPassantTarget = enPassant,
-        halfMoveClock = halfMoveClock,
-        fullMoveNumber = fullMoveNumber,
-        status = GameStatus.InProgress
-      )
-
-  /** Parse active color ("w" or "b"). */
-  private def parseColor(s: String): Option[Color] =
-    if s == "w" then Some(Color.White)
-    else if s == "b" then Some(Color.Black)
-    else None
-
-  /** Parse castling rights string (e.g. "KQkq", "K", "-") into rights for White and Black. */
-  private def parseCastling(s: String): Option[(CastlingRights, CastlingRights)] =
-    if s == "-" then
-      Some((CastlingRights.None, CastlingRights.None))
-    else if s.length <= 4 && s.forall(c => "KQkq".contains(c)) then
-      val white = CastlingRights(kingSide = s.contains('K'), queenSide = s.contains('Q'))
-      val black = CastlingRights(kingSide = s.contains('k'), queenSide = s.contains('q'))
-      Some((white, black))
-    else
-      None
-
-  /** Parse en passant target square ("-" for none, or algebraic like "e3"). */
-  private def parseEnPassant(s: String): Option[Option[Square]] =
-    if s == "-" then Some(None)
-    else Square.fromAlgebraic(s).map(Some(_))
-
-  /** Parses a FEN piece-placement string (rank 8 to rank 1, separated by '/') into a Board.
-   *  Returns None if the format is invalid. */
-  def parseBoard(fen: String): Option[Board] =
-    val rankStrings = fen.split("/", -1)
-    if rankStrings.length != 8 then None
-    else
-      // Parse each rank, collecting all (Square, Piece) pairs or failing on the first error
-      val parsedRanks: Option[List[List[(Square, Piece)]]] =
-        rankStrings.zipWithIndex.foldLeft(Option(List.empty[List[(Square, Piece)]])):
-          case (None, _) => None
-          case (Some(acc), (rankStr, rankIdx)) =>
-            val rank = Rank.values(7 - rankIdx) // ranks go 8→1, so reverse
-            parsePieceRank(rankStr, rank).map(squares => acc :+ squares)
-      parsedRanks.map(ranks => Board(ranks.flatten.toMap))
-
-  /** Parse a single rank string (e.g. "rnbqkbnr" or "p3p3") into a list of (Square, Piece) pairs.
-   *  Returns None if the rank string contains invalid characters or the wrong number of files. */
-  private def parsePieceRank(rankStr: String, rank: Rank): Option[List[(Square, Piece)]] =
-    var fileIdx = 0
-    val squares = scala.collection.mutable.ListBuffer[(Square, Piece)]()
-    var failed = false
-
-    for c <- rankStr if !failed do
-      if fileIdx > 7 then
-        failed = true
-      else if c.isDigit then
-        fileIdx += c.asDigit
-      else
-        charToPiece(c) match
-          case None => failed = true
-          case Some(piece) =>
-            val file = File.values(fileIdx)
-            squares += (Square(file, rank) -> piece)
-            fileIdx += 1
-
-    if failed || fileIdx != 8 then None
-    else Some(squares.toList)
-
-  /** Convert a FEN piece character to a Piece. Uppercase = White, lowercase = Black. */
-  private def charToPiece(c: Char): Option[Piece] =
-    val color = if Character.isUpperCase(c) then Color.White else Color.Black
-    val pieceTypeOpt = c.toLower match
-      case 'p' => Some(PieceType.Pawn)
-      case 'n' => Some(PieceType.Knight)
-      case 'b' => Some(PieceType.Bishop)
-      case 'r' => Some(PieceType.Rook)
-      case 'q' => Some(PieceType.Queen)
-      case 'k' => Some(PieceType.King)
-      case _   => None
-    pieceTypeOpt.map(pt => Piece(color, pt))

modules/core/src/main/scala/de/nowchess/chess/notation/PgnExporter.scala

@@ -1,35 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.chess.logic.{CastleSide, GameHistory, HistoryMove}
-
-object PgnExporter:
-
-  /** Export a game with headers and history to PGN format. */
-  def exportGame(headers: Map[String, String], history: GameHistory): String =
-    val headerLines = headers.map { case (key, value) =>
-      s"""[$key "$value"]"""
-    }.mkString("\n")
-
-    val moveText = if history.moves.isEmpty then ""
-    else
-      val groupedMoves = history.moves.zipWithIndex.groupBy(_._2 / 2)
-      val moveLines = for (moveNumber, movePairs) <- groupedMoves.toList.sortBy(_._1) yield
-        val moveNum = moveNumber + 1
-        val whiteMoveStr = movePairs.find(_._2 % 2 == 0).map(p => moveToAlgebraic(p._1)).getOrElse("")
-        val blackMoveStr = movePairs.find(_._2 % 2 == 1).map(p => moveToAlgebraic(p._1)).getOrElse("")
-        if blackMoveStr.isEmpty then s"$moveNum. $whiteMoveStr"
-        else s"$moveNum. $whiteMoveStr $blackMoveStr"
-
-      moveLines.mkString(" ") + " *"
-
-    if headerLines.isEmpty then moveText
-    else if moveText.isEmpty then headerLines
-    else s"$headerLines\n\n$moveText"
-
-  /** Convert a HistoryMove to algebraic notation. */
-  private def moveToAlgebraic(move: HistoryMove): String =
-    move.castleSide match
-      case Some(CastleSide.Kingside)  => "O-O"
-      case Some(CastleSide.Queenside) => "O-O-O"
-      case None => s"${move.from}${move.to}"

modules/core/src/main/scala/de/nowchess/chess/notation/PgnParser.scala

@@ -1,150 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.chess.logic.{CastleSide, GameHistory, HistoryMove, GameRules, MoveValidator, withCastle}
-
-/** A parsed PGN game containing headers and the resolved move list. */
-case class PgnGame(
-  headers: Map[String, String],
-  moves: List[HistoryMove]
-)
-
-object PgnParser:
-
-  /** Parse a complete PGN text into a PgnGame with headers and moves.
-   *  Always succeeds (returns Some); malformed tokens are silently skipped. */
-  def parsePgn(pgn: String): Option[PgnGame] =
-    val lines = pgn.split("\n").map(_.trim)
-    val (headerLines, rest) = lines.span(_.startsWith("["))
-
-    val headers  = parseHeaders(headerLines)
-    val moveText = rest.mkString(" ")
-    val moves    = parseMovesText(moveText)
-
-    Some(PgnGame(headers, moves))
-
-  /** Parse PGN header lines of the form [Key "Value"]. */
-  private def parseHeaders(lines: Array[String]): Map[String, String] =
-    val pattern = """^\[(\w+)\s+"([^"]*)"\s*\]$""".r
-    lines.flatMap(line => pattern.findFirstMatchIn(line).map(m => m.group(1) -> m.group(2))).toMap
-
-  /** Parse the move-text section (e.g. "1. e4 e5 2. Nf3") into resolved HistoryMoves. */
-  private def parseMovesText(moveText: String): List[HistoryMove] =
-    val tokens = moveText.split("\\s+").filter(_.nonEmpty)
-
-    // Fold over tokens, threading (board, history, currentColor, accumulator)
-    val (_, _, _, moves) = tokens.foldLeft(
-      (Board.initial, GameHistory.empty, Color.White, List.empty[HistoryMove])
-    ):
-      case (state @ (board, history, color, acc), token) =>
-        // Skip move-number markers (e.g. "1.", "2.") and result tokens
-        if isMoveNumberOrResult(token) then state
-        else
-          parseAlgebraicMove(token, board, history, color) match
-            case None => state  // unrecognised token — skip silently
-            case Some(move) =>
-              val newBoard = move.castleSide match
-                case Some(side) => board.withCastle(color, side)
-                case None       => board.withMove(move.from, move.to)._1
-              val newHistory = history.addMove(move)
-              (newBoard, newHistory, color.opposite, acc :+ move)
-
-    moves
-
-  /** True for move-number tokens ("1.", "12.") and PGN result tokens. */
-  private def isMoveNumberOrResult(token: String): Boolean =
-    token.matches("""\d+\.""") ||
-    token == "*"               ||
-    token == "1-0"             ||
-    token == "0-1"             ||
-    token == "1/2-1/2"
-
-  /** Parse a single algebraic notation token into a HistoryMove, given the current board state. */
-  def parseAlgebraicMove(notation: String, board: Board, history: GameHistory, color: Color): Option[HistoryMove] =
-    notation match
-      case "O-O" | "O-O+" | "O-O#" =>
-        val rank = if color == Color.White then Rank.R1 else Rank.R8
-        Some(HistoryMove(Square(File.E, rank), Square(File.G, rank), Some(CastleSide.Kingside)))
-
-      case "O-O-O" | "O-O-O+" | "O-O-O#" =>
-        val rank = if color == Color.White then Rank.R1 else Rank.R8
-        Some(HistoryMove(Square(File.E, rank), Square(File.C, rank), Some(CastleSide.Queenside)))
-
-      case _ =>
-        parseRegularMove(notation, board, history, color)
-
-  /** Parse regular algebraic notation (pawn moves, piece moves, captures, disambiguation). */
-  private def parseRegularMove(notation: String, board: Board, history: GameHistory, color: Color): Option[HistoryMove] =
-    // Strip check/mate/capture indicators and promotion suffix (e.g. =Q)
-    val clean = notation
-      .replace("+", "")
-      .replace("#", "")
-      .replace("x", "")
-      .replaceAll("=[NBRQ]$", "")
-
-    // The destination square is always the last two characters
-    if clean.length < 2 then None
-    else
-      val destStr = clean.takeRight(2)
-      Square.fromAlgebraic(destStr).flatMap: toSquare =>
-        val disambig = clean.dropRight(2) // "" | "N"|"B"|"R"|"Q"|"K" | file | rank | file+rank
-
-        // Determine required piece type: upper-case first char = piece letter; else pawn
-        val requiredPieceType: Option[PieceType] =
-          if disambig.nonEmpty && disambig.head.isUpper then charToPieceType(disambig.head)
-          else if clean.head.isUpper then charToPieceType(clean.head)
-          else Some(PieceType.Pawn)
-
-        // Collect the disambiguation hint that remains after stripping the piece letter
-        val hint =
-          if disambig.nonEmpty && disambig.head.isUpper then disambig.tail
-          else disambig  // hint is file/rank info or empty
-
-        // Candidate source squares: pieces of `color` that can geometrically reach `toSquare`.
-        // We prefer pieces that can actually reach the target; if none can (positionally illegal
-        // PGN input), fall back to any piece of the matching type belonging to `color`.
-        val reachable: Set[Square] =
-          board.pieces.collect {
-            case (from, piece) if piece.color == color &&
-              MoveValidator.legalTargets(board, from).contains(toSquare) => from
-          }.toSet
-
-        val candidates: Set[Square] =
-          if reachable.nonEmpty then reachable
-          else
-            // Fallback for positionally-illegal but syntactically valid PGN notation:
-            // find any piece of `color` with the correct piece type on the board.
-            board.pieces.collect {
-              case (from, piece) if piece.color == color => from
-            }.toSet
-
-        // Filter by required piece type
-        val byPiece = candidates.filter(from =>
-          requiredPieceType.forall(pt => board.pieceAt(from).exists(_.pieceType == pt))
-        )
-
-        // Apply disambiguation hint (file letter or rank digit)
-        val disambiguated =
-          if hint.isEmpty then byPiece
-          else byPiece.filter(from => matchesHint(from, hint))
-
-        disambiguated.headOption.map(from => HistoryMove(from, toSquare, None))
-
-  /** True if `sq` matches a disambiguation hint (file letter, rank digit, or both). */
-  private def matchesHint(sq: Square, hint: String): Boolean =
-    hint.foldLeft(true): (ok, c) =>
-      ok && (
-        if c >= 'a' && c <= 'h' then sq.file.toString.equalsIgnoreCase(c.toString)
-        else if c >= '1' && c <= '8' then sq.rank.ordinal == (c - '1')
-        else true
-      )
-
-  /** Convert a piece-letter character to a PieceType. */
-  private def charToPieceType(c: Char): Option[PieceType] =
-    c match
-      case 'N' => Some(PieceType.Knight)
-      case 'B' => Some(PieceType.Bishop)
-      case 'R' => Some(PieceType.Rook)
-      case 'Q' => Some(PieceType.Queen)
-      case 'K' => Some(PieceType.King)
-      case _   => None

modules/core/src/test/scala/de/nowchess/chess/controller/GameControllerTest.scala

@@ -2,7 +2,7 @@ package de.nowchess.chess.controller
 
 import de.nowchess.api.board.*
 import de.nowchess.api.game.CastlingRights
-import de.nowchess.chess.logic.{CastleSide, GameHistory}
+import de.nowchess.chess.logic.{GameContext, CastleSide}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
@@ -11,61 +11,54 @@ import java.io.ByteArrayInputStream
 class GameControllerTest extends AnyFunSuite with Matchers:
 
   private def sq(f: File, r: Rank): Square = Square(f, r)
-  private def processMove(board: Board, history: GameHistory, turn: Color, raw: String): MoveResult =
-    GameController.processMove(board, history, turn, raw)
-
-  private def gameLoop(board: Board, history: GameHistory, turn: Color): Unit =
-    GameController.gameLoop(board, history, turn)
-
-  private def castlingRights(history: GameHistory, color: Color): CastlingRights =
-    de.nowchess.chess.logic.CastlingRightsCalculator.deriveCastlingRights(history, color)
+  private val initial = GameContext.initial
 
   // ──── processMove ────────────────────────────────────────────────────
 
   test("processMove: 'quit' input returns Quit"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "quit") shouldBe MoveResult.Quit
+    GameController.processMove(initial, Color.White, "quit") shouldBe MoveResult.Quit
 
   test("processMove: 'q' input returns Quit"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "q") shouldBe MoveResult.Quit
+    GameController.processMove(initial, Color.White, "q") shouldBe MoveResult.Quit
 
   test("processMove: quit with surrounding whitespace returns Quit"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "  quit  ") shouldBe MoveResult.Quit
+    GameController.processMove(initial, Color.White, "  quit  ") shouldBe MoveResult.Quit
 
   test("processMove: unparseable input returns InvalidFormat"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "xyz") shouldBe MoveResult.InvalidFormat("xyz")
+    GameController.processMove(initial, Color.White, "xyz") shouldBe MoveResult.InvalidFormat("xyz")
 
   test("processMove: valid format but empty square returns NoPiece"):
     // E3 is empty in the initial position
-    processMove(Board.initial, GameHistory.empty, Color.White, "e3e4") shouldBe MoveResult.NoPiece
+    GameController.processMove(initial, Color.White, "e3e4") shouldBe MoveResult.NoPiece
 
   test("processMove: piece of wrong color returns WrongColor"):
     // E7 has a Black pawn; it is White's turn
-    processMove(Board.initial, GameHistory.empty, Color.White, "e7e6") shouldBe MoveResult.WrongColor
+    GameController.processMove(initial, Color.White, "e7e6") shouldBe MoveResult.WrongColor
 
   test("processMove: geometrically illegal move returns IllegalMove"):
     // White pawn at E2 cannot jump three squares to E5
-    processMove(Board.initial, GameHistory.empty, Color.White, "e2e5") shouldBe MoveResult.IllegalMove
+    GameController.processMove(initial, Color.White, "e2e5") shouldBe MoveResult.IllegalMove
 
   test("processMove: legal pawn move returns Moved with updated board and flipped turn"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "e2e4") match
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
-        newBoard.pieceAt(sq(File.E, Rank.R4)) shouldBe Some(Piece.WhitePawn)
-        newBoard.pieceAt(sq(File.E, Rank.R2)) shouldBe None
+    GameController.processMove(initial, Color.White, "e2e4") match
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
+        newCtx.board.pieceAt(sq(File.E, Rank.R4)) shouldBe Some(Piece.WhitePawn)
+        newCtx.board.pieceAt(sq(File.E, Rank.R2)) shouldBe None
         captured shouldBe None
         newTurn shouldBe Color.Black
       case other => fail(s"Expected Moved, got $other")
 
   test("processMove: legal capture returns Moved with the captured piece"):
-    val board = Board(Map(
+    val captureCtx = GameContext(Board(Map(
       sq(File.E, Rank.R5) -> Piece.WhitePawn,
       sq(File.D, Rank.R6) -> Piece.BlackPawn,
       sq(File.H, Rank.R1) -> Piece.BlackKing,
       sq(File.H, Rank.R8) -> Piece.WhiteKing
-    ))
-    processMove(board, GameHistory.empty, Color.White, "e5d6") match
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
+    )))
+    GameController.processMove(captureCtx, Color.White, "e5d6") match
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
         captured shouldBe Some(Piece.BlackPawn)
-        newBoard.pieceAt(sq(File.D, Rank.R6)) shouldBe Some(Piece.WhitePawn)
+        newCtx.board.pieceAt(sq(File.D, Rank.R6)) shouldBe Some(Piece.WhitePawn)
         newTurn shouldBe Color.Black
       case other => fail(s"Expected Moved, got $other")
 
@@ -77,33 +70,33 @@ class GameControllerTest extends AnyFunSuite with Matchers:
 
   test("gameLoop: 'quit' exits cleanly without exception"):
     withInput("quit\n"):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: EOF (null readLine) exits via quit fallback"):
     withInput(""):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: invalid format prints message and recurses until quit"):
     withInput("badmove\nquit\n"):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: NoPiece prints message and recurses until quit"):
     // E3 is empty in the initial position
     withInput("e3e4\nquit\n"):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: WrongColor prints message and recurses until quit"):
     // E7 has a Black pawn; it is White's turn
     withInput("e7e6\nquit\n"):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: IllegalMove prints message and recurses until quit"):
     withInput("e2e5\nquit\n"):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: legal non-capture move recurses with new board then quits"):
     withInput("e2e4\nquit\n"):
-      gameLoop(Board.initial, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext.initial, Color.White)
 
   test("gameLoop: capture move prints capture message then recurses and quits"):
     val captureBoard = Board(Map(
@@ -113,7 +106,7 @@ class GameControllerTest extends AnyFunSuite with Matchers:
       sq(File.H, Rank.R8) -> Piece.WhiteKing
     ))
     withInput("e5d6\nquit\n"):
-      gameLoop(captureBoard, GameHistory.empty, Color.White)
+      GameController.gameLoop(GameContext(captureBoard), Color.White)
 
   // ──── helpers ────────────────────────────────────────────────────────
 
@@ -127,37 +120,37 @@ class GameControllerTest extends AnyFunSuite with Matchers:
   test("processMove: legal move that delivers check returns MovedInCheck"):
     // White Ra1, Ka3; Black Kh8 — White plays Ra1-Ra8, Ra8 attacks rank 8 putting Kh8 in check
     // Kh8 can escape to g7/g8/h7 so this is InCheck, not Mated
-    val b = Board(Map(
+    val ctx = GameContext(Board(Map(
       sq(File.A, Rank.R1) -> Piece.WhiteRook,
       sq(File.C, Rank.R3) -> Piece.WhiteKing,
       sq(File.H, Rank.R8) -> Piece.BlackKing
-    ))
-    processMove(b, GameHistory.empty, Color.White, "a1a8") match
-      case MoveResult.MovedInCheck(_, _, _, newTurn) => newTurn shouldBe Color.Black
+    )))
+    GameController.processMove(ctx, Color.White, "a1a8") match
+      case MoveResult.MovedInCheck(_, _, newTurn) => newTurn shouldBe Color.Black
       case other => fail(s"Expected MovedInCheck, got $other")
 
   test("processMove: legal move that results in checkmate returns Checkmate"):
     // White Qa1, Ka6; Black Ka8 — White plays Qa1-Qh8 (diagonal a1→h8)
     // After Qh8: White Qh8 + Ka6 vs Black Ka8 = checkmate (spec-verified position)
     // Qa1 does NOT currently attack Ka8 — path along file A is blocked by Ka6
-    val b = Board(Map(
+    val ctx = GameContext(Board(Map(
       sq(File.A, Rank.R1) -> Piece.WhiteQueen,
       sq(File.A, Rank.R6) -> Piece.WhiteKing,
       sq(File.A, Rank.R8) -> Piece.BlackKing
-    ))
-    processMove(b, GameHistory.empty, Color.White, "a1h8") match
+    )))
+    GameController.processMove(ctx, Color.White, "a1h8") match
       case MoveResult.Checkmate(winner) => winner shouldBe Color.White
       case other => fail(s"Expected Checkmate(White), got $other")
 
   test("processMove: legal move that results in stalemate returns Stalemate"):
     // White Qb1, Kc6; Black Ka8 — White plays Qb1-Qb6
     // After Qb6: White Qb6 + Kc6 vs Black Ka8 = stalemate (spec-verified position)
-    val b = Board(Map(
+    val ctx = GameContext(Board(Map(
       sq(File.B, Rank.R1) -> Piece.WhiteQueen,
       sq(File.C, Rank.R6) -> Piece.WhiteKing,
       sq(File.A, Rank.R8) -> Piece.BlackKing
-    ))
-    processMove(b, GameHistory.empty, Color.White, "b1b6") match
+    )))
+    GameController.processMove(ctx, Color.White, "b1b6") match
       case MoveResult.Stalemate => succeed
       case other => fail(s"Expected Stalemate, got $other")
 
@@ -172,7 +165,7 @@ class GameControllerTest extends AnyFunSuite with Matchers:
     ))
     val output = captureOutput:
       withInput("a1h8\nquit\n"):
-        gameLoop(b, GameHistory.empty, Color.White)
+        GameController.gameLoop(GameContext(b), Color.White)
     output should include("Checkmate! White wins.")
 
   test("gameLoop: stalemate prints draw message and resets to new game"):
@@ -183,7 +176,7 @@ class GameControllerTest extends AnyFunSuite with Matchers:
     ))
     val output = captureOutput:
       withInput("b1b6\nquit\n"):
-        gameLoop(b, GameHistory.empty, Color.White)
+        GameController.gameLoop(GameContext(b), Color.White)
     output should include("Stalemate! The game is a draw.")
 
   test("gameLoop: MovedInCheck without capture prints check message"):
@@ -194,7 +187,7 @@ class GameControllerTest extends AnyFunSuite with Matchers:
     ))
     val output = captureOutput:
       withInput("a1a8\nquit\n"):
-        gameLoop(b, GameHistory.empty, Color.White)
+        GameController.gameLoop(GameContext(b), Color.White)
     output should include("Black is in check!")
 
   test("gameLoop: MovedInCheck with capture prints both capture and check message"):
@@ -207,197 +200,208 @@ class GameControllerTest extends AnyFunSuite with Matchers:
     ))
     val output = captureOutput:
       withInput("a1a8\nquit\n"):
-        gameLoop(b, GameHistory.empty, Color.White)
+        GameController.gameLoop(GameContext(b), Color.White)
     output should include("captures")
     output should include("Black is in check!")
 
   // ──── castling execution ─────────────────────────────────────────────
 
   test("processMove: e1g1 returns Moved with king on g1 and rook on f1"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.White, "e1g1") match
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
-        newBoard.pieceAt(sq(File.G, Rank.R1)) shouldBe Some(Piece.WhiteKing)
-        newBoard.pieceAt(sq(File.F, Rank.R1)) shouldBe Some(Piece.WhiteRook)
-        newBoard.pieceAt(sq(File.E, Rank.R1)) shouldBe None
-        newBoard.pieceAt(sq(File.H, Rank.R1)) shouldBe None
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "e1g1") match
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
+        newCtx.board.pieceAt(sq(File.G, Rank.R1)) shouldBe Some(Piece.WhiteKing)
+        newCtx.board.pieceAt(sq(File.F, Rank.R1)) shouldBe Some(Piece.WhiteRook)
+        newCtx.board.pieceAt(sq(File.E, Rank.R1)) shouldBe None
+        newCtx.board.pieceAt(sq(File.H, Rank.R1)) shouldBe None
         captured shouldBe None
         newTurn shouldBe Color.Black
       case other => fail(s"Expected Moved, got $other")
 
   test("processMove: e1c1 returns Moved with king on c1 and rook on d1"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.A, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.White, "e1c1") match
-      case MoveResult.Moved(newBoard, _, _, _) =>
-        newBoard.pieceAt(sq(File.C, Rank.R1)) shouldBe Some(Piece.WhiteKing)
-        newBoard.pieceAt(sq(File.D, Rank.R1)) shouldBe Some(Piece.WhiteRook)
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "e1c1") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.board.pieceAt(sq(File.C, Rank.R1)) shouldBe Some(Piece.WhiteKing)
+        newCtx.board.pieceAt(sq(File.D, Rank.R1)) shouldBe Some(Piece.WhiteRook)
       case other => fail(s"Expected Moved, got $other")
 
   // ──── rights revocation ──────────────────────────────────────────────
 
   test("processMove: e1g1 revokes both white castling rights"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.White, "e1g1") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White) shouldBe CastlingRights.None
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "e1g1") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.whiteCastling shouldBe CastlingRights.None
       case other => fail(s"Expected Moved, got $other")
 
   test("processMove: moving rook from h1 revokes white kingside right"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.White, "h1h4") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White).kingSide  shouldBe false
-        castlingRights(newHistory, Color.White).queenSide shouldBe true
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White).kingSide  shouldBe false
-        castlingRights(newHistory, Color.White).queenSide shouldBe true
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "h1h4") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.whiteCastling.kingSide  shouldBe false
+        newCtx.whiteCastling.queenSide shouldBe true
+      case MoveResult.MovedInCheck(newCtx, _, _) =>
+        newCtx.whiteCastling.kingSide  shouldBe false
+        newCtx.whiteCastling.queenSide shouldBe true
       case other => fail(s"Expected Moved or MovedInCheck, got $other")
 
   test("processMove: moving king from e1 revokes both white rights"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.White, "e1e2") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White) shouldBe CastlingRights.None
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "e1e2") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.whiteCastling shouldBe CastlingRights.None
       case other => fail(s"Expected Moved, got $other")
 
   test("processMove: enemy capture on h1 revokes white kingside right"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R2) -> Piece.BlackRook,
         sq(File.A, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.Black, "h2h1") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White).kingSide shouldBe false
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White).kingSide shouldBe false
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.Black, "h2h1") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.whiteCastling.kingSide shouldBe false
+      case MoveResult.MovedInCheck(newCtx, _, _) =>
+        newCtx.whiteCastling.kingSide shouldBe false
       case other => fail(s"Expected Moved or MovedInCheck, got $other")
 
   test("processMove: castle attempt when rights revoked returns IllegalMove"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    val history = GameHistory.empty.addMove(sq(File.E, Rank.R1), sq(File.E, Rank.R2)).addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R1))
-    processMove(b, history, Color.White, "e1g1") shouldBe MoveResult.IllegalMove
+      )),
+      whiteCastling = CastlingRights.None,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "e1g1") shouldBe MoveResult.IllegalMove
 
   test("processMove: castle attempt when rook not on home square returns IllegalMove"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.G, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.White, "e1g1") shouldBe MoveResult.IllegalMove
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.White, "e1g1") shouldBe MoveResult.IllegalMove
 
   test("processMove: moving king from e8 revokes both black rights"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R8) -> Piece.BlackKing,
         sq(File.H, Rank.R1) -> Piece.WhiteKing
-      ))
-    processMove(b, GameHistory.empty, Color.Black, "e8e7") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.Black) shouldBe CastlingRights.None
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.Black) shouldBe CastlingRights.None
+      )),
+      whiteCastling = CastlingRights.None,
+      blackCastling = CastlingRights.Both
+    )
+    GameController.processMove(ctx, Color.Black, "e8e7") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.blackCastling shouldBe CastlingRights.None
+      case MoveResult.MovedInCheck(newCtx, _, _) =>
+        newCtx.blackCastling shouldBe CastlingRights.None
       case other => fail(s"Expected Moved or MovedInCheck, got $other")
 
   test("processMove: moving rook from a8 revokes black queenside right"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R8) -> Piece.BlackKing,
         sq(File.A, Rank.R8) -> Piece.BlackRook,
         sq(File.H, Rank.R1) -> Piece.WhiteKing
-      ))
-    processMove(b, GameHistory.empty, Color.Black, "a8a1") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.Black).queenSide shouldBe false
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe true
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.Black).queenSide shouldBe false
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe true
+      )),
+      whiteCastling = CastlingRights.None,
+      blackCastling = CastlingRights.Both
+    )
+    GameController.processMove(ctx, Color.Black, "a8a7") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.blackCastling.queenSide shouldBe false
+        newCtx.blackCastling.kingSide  shouldBe true
+      case MoveResult.MovedInCheck(newCtx, _, _) =>
+        newCtx.blackCastling.queenSide shouldBe false
+        newCtx.blackCastling.kingSide  shouldBe true
       case other => fail(s"Expected Moved or MovedInCheck, got $other")
 
   test("processMove: moving rook from h8 revokes black kingside right"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R8) -> Piece.BlackKing,
         sq(File.H, Rank.R8) -> Piece.BlackRook,
-        sq(File.A, Rank.R1) -> Piece.WhiteKing
-      ))
-    processMove(b, GameHistory.empty, Color.Black, "h8h4") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe false
-        castlingRights(newHistory, Color.Black).queenSide shouldBe true
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe false
-        castlingRights(newHistory, Color.Black).queenSide shouldBe true
+        sq(File.H, Rank.R1) -> Piece.WhiteKing
+      )),
+      whiteCastling = CastlingRights.None,
+      blackCastling = CastlingRights.Both
+    )
+    GameController.processMove(ctx, Color.Black, "h8h7") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.blackCastling.kingSide  shouldBe false
+        newCtx.blackCastling.queenSide shouldBe true
+      case MoveResult.MovedInCheck(newCtx, _, _) =>
+        newCtx.blackCastling.kingSide  shouldBe false
+        newCtx.blackCastling.queenSide shouldBe true
       case other => fail(s"Expected Moved or MovedInCheck, got $other")
 
   test("processMove: enemy capture on a1 revokes white queenside right"):
-    val b = Board(Map(
+    val ctx = GameContext(
+      board = Board(Map(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.A, Rank.R1) -> Piece.WhiteRook,
         sq(File.A, Rank.R2) -> Piece.BlackRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      ))
-    processMove(b, GameHistory.empty, Color.Black, "a2a1") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White).queenSide shouldBe false
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
-        castlingRights(newHistory, Color.White).queenSide shouldBe false
+      )),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameController.processMove(ctx, Color.Black, "a2a1") match
+      case MoveResult.Moved(newCtx, _, _) =>
+        newCtx.whiteCastling.queenSide shouldBe false
+      case MoveResult.MovedInCheck(newCtx, _, _) =>
+        newCtx.whiteCastling.queenSide shouldBe false
       case other => fail(s"Expected Moved or MovedInCheck, got $other")
-
-  // ──── en passant ────────────────────────────────────────────────────────
-
-  test("en passant capture removes the captured pawn from the board"):
-    // Setup: white pawn e5, black pawn just double-pushed to d5 (ep target = d6)
-    val b = Board(Map(
-      Square(File.E, Rank.R5) -> Piece.WhitePawn,
-      Square(File.D, Rank.R5) -> Piece.BlackPawn,
-      Square(File.E, Rank.R1) -> Piece.WhiteKing,
-      Square(File.E, Rank.R8) -> Piece.BlackKing
-    ))
-    val h = GameHistory.empty.addMove(Square(File.D, Rank.R7), Square(File.D, Rank.R5))
-    val result = GameController.processMove(b, h, Color.White, "e5d6")
-    result match
-      case MoveResult.Moved(newBoard, _, captured, _) =>
-        newBoard.pieceAt(Square(File.D, Rank.R5)) shouldBe None  // captured pawn removed
-        newBoard.pieceAt(Square(File.D, Rank.R6)) shouldBe Some(Piece.WhitePawn)  // capturing pawn placed
-        captured shouldBe Some(Piece.BlackPawn)
-      case other => fail(s"Expected Moved but got $other")
-
-  test("en passant capture by black removes the captured white pawn"):
-    // Setup: black pawn d4, white pawn just double-pushed to e4 (ep target = e3)
-    val b = Board(Map(
-      Square(File.D, Rank.R4) -> Piece.BlackPawn,
-      Square(File.E, Rank.R4) -> Piece.WhitePawn,
-      Square(File.E, Rank.R8) -> Piece.BlackKing,
-      Square(File.E, Rank.R1) -> Piece.WhiteKing
-    ))
-    val h = GameHistory.empty.addMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4))
-    val result = GameController.processMove(b, h, Color.Black, "d4e3")
-    result match
-      case MoveResult.Moved(newBoard, _, captured, _) =>
-        newBoard.pieceAt(Square(File.E, Rank.R4)) shouldBe None  // captured pawn removed
-        newBoard.pieceAt(Square(File.E, Rank.R3)) shouldBe Some(Piece.BlackPawn)  // capturing pawn placed
-        captured shouldBe Some(Piece.WhitePawn)
-      case other => fail(s"Expected Moved but got $other")

modules/core/src/test/scala/de/nowchess/chess/logic/CastlingRightsCalculatorTest.scala

@@ -1,70 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.*
-import de.nowchess.api.game.CastlingRights
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class CastlingRightsCalculatorTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  test("Empty history gives full castling rights"):
-    val rights = CastlingRightsCalculator.deriveCastlingRights(GameHistory.empty, Color.White)
-    rights shouldBe CastlingRights.Both
-
-  test("White loses kingside rights after h1 rook moves"):
-    val history = GameHistory.empty.addMove(sq(File.H, Rank.R1), sq(File.H, Rank.R2))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.White)
-    rights.kingSide shouldBe false
-    rights.queenSide shouldBe true
-
-  test("White loses queenside rights after a1 rook moves"):
-    val history = GameHistory.empty.addMove(sq(File.A, Rank.R1), sq(File.A, Rank.R2))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.White)
-    rights.queenSide shouldBe false
-    rights.kingSide shouldBe true
-
-  test("White loses all rights after king moves"):
-    val history = GameHistory.empty.addMove(sq(File.E, Rank.R1), sq(File.E, Rank.R2))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.White)
-    rights shouldBe CastlingRights.None
-
-  test("Black loses kingside rights after h8 rook moves"):
-    val history = GameHistory.empty.addMove(sq(File.H, Rank.R8), sq(File.H, Rank.R7))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.Black)
-    rights.kingSide shouldBe false
-    rights.queenSide shouldBe true
-
-  test("Black loses queenside rights after a8 rook moves"):
-    val history = GameHistory.empty.addMove(sq(File.A, Rank.R8), sq(File.A, Rank.R7))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.Black)
-    rights.queenSide shouldBe false
-    rights.kingSide shouldBe true
-
-  test("Black loses all rights after king moves"):
-    val history = GameHistory.empty.addMove(sq(File.E, Rank.R8), sq(File.E, Rank.R7))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.Black)
-    rights shouldBe CastlingRights.None
-
-  test("Castle move revokes all castling rights"):
-    val history = GameHistory.empty.addMove(
-      sq(File.E, Rank.R1),
-      sq(File.G, Rank.R1),
-      Some(CastleSide.Kingside)
-    )
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.White)
-    rights shouldBe CastlingRights.None
-
-  test("Other pieces moving does not revoke castling rights"):
-    val history = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.White)
-    rights shouldBe CastlingRights.Both
-
-  test("Multiple moves preserve white kingside but lose queenside"):
-    val history = GameHistory.empty
-      .addMove(sq(File.A, Rank.R1), sq(File.A, Rank.R2))  // White queenside rook moves
-      .addMove(sq(File.E, Rank.R7), sq(File.E, Rank.R5))  // Black pawn moves
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, Color.White)
-    rights.kingSide shouldBe true
-    rights.queenSide shouldBe false

modules/core/src/test/scala/de/nowchess/chess/logic/EnPassantCalculatorTest.scala

@@ -1,101 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.*
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class EnPassantCalculatorTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-  private def board(entries: (Square, Piece)*): Board = Board(entries.toMap)
-
-  // ──── enPassantTarget ────────────────────────────────────────────────
-
-  test("enPassantTarget returns None for empty history"):
-    val b = board(sq(File.E, Rank.R4) -> Piece.WhitePawn)
-    EnPassantCalculator.enPassantTarget(b, GameHistory.empty) shouldBe None
-
-  test("enPassantTarget returns None when last move was a single pawn push"):
-    val b = board(sq(File.E, Rank.R3) -> Piece.WhitePawn)
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R3))
-    EnPassantCalculator.enPassantTarget(b, h) shouldBe None
-
-  test("enPassantTarget returns None when last move was not a pawn"):
-    val b = board(sq(File.E, Rank.R4) -> Piece.WhiteRook)
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    EnPassantCalculator.enPassantTarget(b, h) shouldBe None
-
-  test("enPassantTarget returns e3 after white pawn double push e2-e4"):
-    val b = board(sq(File.E, Rank.R4) -> Piece.WhitePawn)
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    EnPassantCalculator.enPassantTarget(b, h) shouldBe Some(sq(File.E, Rank.R3))
-
-  test("enPassantTarget returns e6 after black pawn double push e7-e5"):
-    val b = board(sq(File.E, Rank.R5) -> Piece.BlackPawn)
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    EnPassantCalculator.enPassantTarget(b, h) shouldBe Some(sq(File.E, Rank.R6))
-
-  test("enPassantTarget returns d3 after white pawn double push d2-d4"):
-    val b = board(sq(File.D, Rank.R4) -> Piece.WhitePawn)
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R2), sq(File.D, Rank.R4))
-    EnPassantCalculator.enPassantTarget(b, h) shouldBe Some(sq(File.D, Rank.R3))
-
-  // ──── capturedPawnSquare ─────────────────────────────────────────────
-
-  test("capturedPawnSquare for white capturing on e6 returns e5"):
-    EnPassantCalculator.capturedPawnSquare(sq(File.E, Rank.R6), Color.White) shouldBe sq(File.E, Rank.R5)
-
-  test("capturedPawnSquare for black capturing on e3 returns e4"):
-    EnPassantCalculator.capturedPawnSquare(sq(File.E, Rank.R3), Color.Black) shouldBe sq(File.E, Rank.R4)
-
-  test("capturedPawnSquare for white capturing on d6 returns d5"):
-    EnPassantCalculator.capturedPawnSquare(sq(File.D, Rank.R6), Color.White) shouldBe sq(File.D, Rank.R5)
-
-  // ──── isEnPassant ────────────────────────────────────────────────────
-
-  test("isEnPassant returns true for valid white en passant capture"):
-    // White pawn on e5, black pawn just double-pushed to d5 (ep target = d6)
-    val b = board(
-      sq(File.E, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R7), sq(File.D, Rank.R5))
-    EnPassantCalculator.isEnPassant(b, h, sq(File.E, Rank.R5), sq(File.D, Rank.R6)) shouldBe true
-
-  test("isEnPassant returns true for valid black en passant capture"):
-    // Black pawn on d4, white pawn just double-pushed to e4 (ep target = e3)
-    val b = board(
-      sq(File.D, Rank.R4) -> Piece.BlackPawn,
-      sq(File.E, Rank.R4) -> Piece.WhitePawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    EnPassantCalculator.isEnPassant(b, h, sq(File.D, Rank.R4), sq(File.E, Rank.R3)) shouldBe true
-
-  test("isEnPassant returns false when no en passant target in history"):
-    val b = board(
-      sq(File.E, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R6), sq(File.D, Rank.R5))  // single push
-    EnPassantCalculator.isEnPassant(b, h, sq(File.E, Rank.R5), sq(File.D, Rank.R6)) shouldBe false
-
-  test("isEnPassant returns false when piece at from is not a pawn"):
-    val b = board(
-      sq(File.E, Rank.R5) -> Piece.WhiteRook,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R7), sq(File.D, Rank.R5))
-    EnPassantCalculator.isEnPassant(b, h, sq(File.E, Rank.R5), sq(File.D, Rank.R6)) shouldBe false
-
-  test("isEnPassant returns false when to does not match ep target"):
-    val b = board(
-      sq(File.E, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R7), sq(File.D, Rank.R5))
-    EnPassantCalculator.isEnPassant(b, h, sq(File.E, Rank.R5), sq(File.E, Rank.R6)) shouldBe false
-
-  test("isEnPassant returns false when from square is empty"):
-    val b = board(sq(File.D, Rank.R5) -> Piece.BlackPawn)
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R7), sq(File.D, Rank.R5))
-    EnPassantCalculator.isEnPassant(b, h, sq(File.E, Rank.R5), sq(File.D, Rank.R6)) shouldBe false

modules/core/src/test/scala/de/nowchess/chess/logic/GameContextTest.scala

@@ -0,0 +1,81 @@
+package de.nowchess.chess.logic
+
+import de.nowchess.api.board.*
+import de.nowchess.api.game.CastlingRights
+import org.scalatest.funsuite.AnyFunSuite
+import org.scalatest.matchers.should.Matchers
+
+class GameContextTest extends AnyFunSuite with Matchers:
+
+  private def sq(f: File, r: Rank): Square = Square(f, r)
+  private def board(entries: (Square, Piece)*): Board = Board(entries.toMap)
+
+  test("GameContext.initial has Board.initial and CastlingRights.Both for both sides"):
+    GameContext.initial.board         shouldBe Board.initial
+    GameContext.initial.whiteCastling shouldBe CastlingRights.Both
+    GameContext.initial.blackCastling shouldBe CastlingRights.Both
+
+  test("castlingFor returns white rights for Color.White"):
+    GameContext.initial.castlingFor(Color.White) shouldBe CastlingRights.Both
+
+  test("castlingFor returns black rights for Color.Black"):
+    GameContext.initial.castlingFor(Color.Black) shouldBe CastlingRights.Both
+
+  test("withUpdatedRights updates white castling without touching black"):
+    val ctx = GameContext.initial.withUpdatedRights(Color.White, CastlingRights.None)
+    ctx.whiteCastling shouldBe CastlingRights.None
+    ctx.blackCastling shouldBe CastlingRights.Both
+
+  test("withUpdatedRights updates black castling without touching white"):
+    val ctx = GameContext.initial.withUpdatedRights(Color.Black, CastlingRights.None)
+    ctx.blackCastling shouldBe CastlingRights.None
+    ctx.whiteCastling shouldBe CastlingRights.Both
+
+  test("withCastle: white kingside — king e1→g1, rook h1→f1"):
+    val b = board(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook
+    )
+    val after = b.withCastle(Color.White, CastleSide.Kingside)
+    after.pieceAt(sq(File.G, Rank.R1)) shouldBe Some(Piece.WhiteKing)
+    after.pieceAt(sq(File.F, Rank.R1)) shouldBe Some(Piece.WhiteRook)
+    after.pieceAt(sq(File.E, Rank.R1)) shouldBe None
+    after.pieceAt(sq(File.H, Rank.R1)) shouldBe None
+
+  test("withCastle: white queenside — king e1→c1, rook a1→d1"):
+    val b = board(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.A, Rank.R1) -> Piece.WhiteRook
+    )
+    val after = b.withCastle(Color.White, CastleSide.Queenside)
+    after.pieceAt(sq(File.C, Rank.R1)) shouldBe Some(Piece.WhiteKing)
+    after.pieceAt(sq(File.D, Rank.R1)) shouldBe Some(Piece.WhiteRook)
+    after.pieceAt(sq(File.E, Rank.R1)) shouldBe None
+    after.pieceAt(sq(File.A, Rank.R1)) shouldBe None
+
+  test("withCastle: black kingside — king e8→g8, rook h8→f8"):
+    val b = board(
+      sq(File.E, Rank.R8) -> Piece.BlackKing,
+      sq(File.H, Rank.R8) -> Piece.BlackRook
+    )
+    val after = b.withCastle(Color.Black, CastleSide.Kingside)
+    after.pieceAt(sq(File.G, Rank.R8)) shouldBe Some(Piece.BlackKing)
+    after.pieceAt(sq(File.F, Rank.R8)) shouldBe Some(Piece.BlackRook)
+    after.pieceAt(sq(File.E, Rank.R8)) shouldBe None
+    after.pieceAt(sq(File.H, Rank.R8)) shouldBe None
+
+  test("withCastle: black queenside — king e8→c8, rook a8→d8"):
+    val b = board(
+      sq(File.E, Rank.R8) -> Piece.BlackKing,
+      sq(File.A, Rank.R8) -> Piece.BlackRook
+    )
+    val after = b.withCastle(Color.Black, CastleSide.Queenside)
+    after.pieceAt(sq(File.C, Rank.R8)) shouldBe Some(Piece.BlackKing)
+    after.pieceAt(sq(File.D, Rank.R8)) shouldBe Some(Piece.BlackRook)
+    after.pieceAt(sq(File.E, Rank.R8)) shouldBe None
+    after.pieceAt(sq(File.A, Rank.R8)) shouldBe None
+
+  test("GameContext single-arg apply defaults to CastlingRights.None for both sides"):
+    val ctx = GameContext(Board.initial)
+    ctx.whiteCastling shouldBe CastlingRights.None
+    ctx.blackCastling shouldBe CastlingRights.None

modules/core/src/test/scala/de/nowchess/chess/logic/GameHistoryTest.scala

@@ -1,41 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.*
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class GameHistoryTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  test("GameHistory starts empty"):
-    val history = GameHistory.empty
-    history.moves shouldBe empty
-
-  test("GameHistory can add a move"):
-    val history = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    history.moves should have length 1
-    history.moves.head.from shouldBe sq(File.E, Rank.R2)
-    history.moves.head.to shouldBe sq(File.E, Rank.R4)
-    history.moves.head.castleSide shouldBe None
-
-  test("GameHistory can add multiple moves in order"):
-    val h1 = GameHistory.empty
-    val h2 = h1.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val h3 = h2.addMove(sq(File.C, Rank.R7), sq(File.C, Rank.R5))
-    h3.moves should have length 2
-    h3.moves(0).from shouldBe sq(File.E, Rank.R2)
-    h3.moves(1).from shouldBe sq(File.C, Rank.R7)
-
-  test("GameHistory can add a castle move"):
-    val history = GameHistory.empty.addMove(
-      sq(File.E, Rank.R1),
-      sq(File.G, Rank.R1),
-      Some(CastleSide.Kingside)
-    )
-    history.moves.head.castleSide shouldBe Some(CastleSide.Kingside)
-
-  test("GameHistory.addMove with two arguments uses None for castleSide default"):
-    val history = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    history.moves should have length 1
-    history.moves.head.castleSide shouldBe None

modules/core/src/test/scala/de/nowchess/chess/logic/GameRulesTest.scala

@@ -2,7 +2,7 @@ package de.nowchess.chess.logic
 
 import de.nowchess.api.board.*
 import de.nowchess.api.game.CastlingRights
-import de.nowchess.chess.logic.GameHistory
+import de.nowchess.chess.logic.GameContext
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
@@ -12,11 +12,7 @@ class GameRulesTest extends AnyFunSuite with Matchers:
   private def board(entries: (Square, Piece)*): Board = Board(entries.toMap)
 
   /** Wrap a board in a GameContext with no castling rights — for non-castling tests. */
-  private def testLegalMoves(entries: (Square, Piece)*)(color: Color): Set[(Square, Square)] =
-    GameRules.legalMoves(Board(entries.toMap), GameHistory.empty, color)
-
-  private def testGameStatus(entries: (Square, Piece)*)(color: Color): PositionStatus =
-    GameRules.gameStatus(Board(entries.toMap), GameHistory.empty, color)
+  private def ctx(entries: (Square, Piece)*): GameContext = GameContext(Board(entries.toMap))
 
   // ──── isInCheck ──────────────────────────────────────────────────────
 
@@ -45,20 +41,20 @@ class GameRulesTest extends AnyFunSuite with Matchers:
   test("legalMoves: move that exposes own king to rook is excluded"):
     // White King E1, White Rook E4 (pinned on E-file), Black Rook E8
     // Moving the White Rook off the E-file would expose the king
-    val moves = testLegalMoves(
+    val moves = GameRules.legalMoves(ctx(
       sq(File.E, Rank.R1) -> Piece.WhiteKing,
       sq(File.E, Rank.R4) -> Piece.WhiteRook,
       sq(File.E, Rank.R8) -> Piece.BlackRook
-    )(Color.White)
+    ), Color.White)
     moves should not contain (sq(File.E, Rank.R4) -> sq(File.D, Rank.R4))
 
   test("legalMoves: move that blocks check is included"):
     // White King E1 in check from Black Rook E8; White Rook A5 can interpose on E5
-    val moves = testLegalMoves(
+    val moves = GameRules.legalMoves(ctx(
       sq(File.E, Rank.R1) -> Piece.WhiteKing,
       sq(File.A, Rank.R5) -> Piece.WhiteRook,
       sq(File.E, Rank.R8) -> Piece.BlackRook
-    )(Color.White)
+    ), Color.White)
     moves should contain(sq(File.A, Rank.R5) -> sq(File.E, Rank.R5))
 
   // ──── gameStatus ──────────────────────────────────────────────────────
@@ -66,96 +62,70 @@ class GameRulesTest extends AnyFunSuite with Matchers:
   test("gameStatus: checkmate returns Mated"):
     // White Qh8, Ka6; Black Ka8
     // Qh8 attacks Ka8 along rank 8; all escape squares covered (spec-verified position)
-    testGameStatus(
+    GameRules.gameStatus(ctx(
       sq(File.H, Rank.R8) -> Piece.WhiteQueen,
       sq(File.A, Rank.R6) -> Piece.WhiteKing,
       sq(File.A, Rank.R8) -> Piece.BlackKing
-    )(Color.Black) shouldBe PositionStatus.Mated
+    ), Color.Black) shouldBe PositionStatus.Mated
 
   test("gameStatus: stalemate returns Drawn"):
     // White Qb6, Kc6; Black Ka8
     // Black king has no legal moves and is not in check (spec-verified position)
-    testGameStatus(
+    GameRules.gameStatus(ctx(
       sq(File.B, Rank.R6) -> Piece.WhiteQueen,
       sq(File.C, Rank.R6) -> Piece.WhiteKing,
       sq(File.A, Rank.R8) -> Piece.BlackKing
-    )(Color.Black) shouldBe PositionStatus.Drawn
+    ), Color.Black) shouldBe PositionStatus.Drawn
 
   test("gameStatus: king in check with legal escape returns InCheck"):
     // White Ra8 attacks Black Ke8 along rank 8; king can escape to d7, e7, f7
-    testGameStatus(
+    GameRules.gameStatus(ctx(
       sq(File.A, Rank.R8) -> Piece.WhiteRook,
       sq(File.E, Rank.R8) -> Piece.BlackKing
-    )(Color.Black) shouldBe PositionStatus.InCheck
+    ), Color.Black) shouldBe PositionStatus.InCheck
 
   test("gameStatus: normal starting position returns Normal"):
-    GameRules.gameStatus(Board.initial, GameHistory.empty, Color.White) shouldBe PositionStatus.Normal
+    GameRules.gameStatus(GameContext(Board.initial), Color.White) shouldBe PositionStatus.Normal
 
   test("legalMoves: includes castling destination when available"):
-    val b = board(
+    val c = GameContext(
+      board = board(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.H, Rank.R8) -> Piece.BlackKing
-      )
-    GameRules.legalMoves(b, GameHistory.empty, Color.White) should contain(sq(File.E, Rank.R1) -> sq(File.G, Rank.R1))
+      ),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameRules.legalMoves(c, Color.White) should contain(sq(File.E, Rank.R1) -> sq(File.G, Rank.R1))
 
   test("legalMoves: excludes castling when king is in check"):
-    val b = board(
+    val c = GameContext(
+      board = board(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.E, Rank.R8) -> Piece.BlackRook,
         sq(File.A, Rank.R8) -> Piece.BlackKing
-      )
-    GameRules.legalMoves(b, GameHistory.empty, Color.White) should not contain (sq(File.E, Rank.R1) -> sq(File.G, Rank.R1))
+      ),
+      whiteCastling = CastlingRights.Both,
+      blackCastling = CastlingRights.None
+    )
+    GameRules.legalMoves(c, Color.White) should not contain (sq(File.E, Rank.R1) -> sq(File.G, Rank.R1))
 
   test("gameStatus: returns Normal (not Drawn) when castling is the only legal move"):
     // White King e1, Rook h1 (kingside castling available).
     // Black Rooks d2 and f2 box the king: d1 attacked by d2, e2 attacked by both,
     // f1 attacked by f2. King cannot move to any adjacent square without entering
     // an attacked square or an enemy piece. Only legal move: castle to g1.
-    val b = board(
+    val c = GameContext(
+      board = board(
         sq(File.E, Rank.R1) -> Piece.WhiteKing,
         sq(File.H, Rank.R1) -> Piece.WhiteRook,
         sq(File.D, Rank.R2) -> Piece.BlackRook,
         sq(File.F, Rank.R2) -> Piece.BlackRook,
         sq(File.A, Rank.R8) -> Piece.BlackKing
-      )
-    // No history means castling rights are intact
-    GameRules.gameStatus(b, GameHistory.empty, Color.White) shouldBe PositionStatus.Normal
-
-  test("CastleSide.withCastle correctly positions pieces for Queenside castling"):
-    // Directly test the withCastle extension for Queenside (coverage gap on line 10)
-    val b = board(
-      sq(File.E, Rank.R1) -> Piece.WhiteKing,
-      sq(File.A, Rank.R1) -> Piece.WhiteRook,
-      sq(File.H, Rank.R8) -> Piece.BlackKing
+      ),
+      whiteCastling = CastlingRights(kingSide = true, queenSide = false),
+      blackCastling = CastlingRights.None
     )
-    val result = b.withCastle(Color.White, CastleSide.Queenside)
-    result.pieceAt(sq(File.C, Rank.R1)) shouldBe Some(Piece.WhiteKing)
-    result.pieceAt(sq(File.D, Rank.R1)) shouldBe Some(Piece.WhiteRook)
-    result.pieceAt(sq(File.E, Rank.R1)) shouldBe None
-    result.pieceAt(sq(File.A, Rank.R1)) shouldBe None
-
-  test("CastleSide.withCastle correctly positions pieces for Black Kingside castling"):
-    val b = board(
-      sq(File.E, Rank.R8) -> Piece.BlackKing,
-      sq(File.H, Rank.R8) -> Piece.BlackRook,
-      sq(File.A, Rank.R1) -> Piece.WhiteKing
-    )
-    val result = b.withCastle(Color.Black, CastleSide.Kingside)
-    result.pieceAt(sq(File.G, Rank.R8)) shouldBe Some(Piece.BlackKing)
-    result.pieceAt(sq(File.F, Rank.R8)) shouldBe Some(Piece.BlackRook)
-    result.pieceAt(sq(File.E, Rank.R8)) shouldBe None
-    result.pieceAt(sq(File.H, Rank.R8)) shouldBe None
-
-  test("CastleSide.withCastle correctly positions pieces for Black Queenside castling"):
-    val b = board(
-      sq(File.E, Rank.R8) -> Piece.BlackKing,
-      sq(File.A, Rank.R8) -> Piece.BlackRook,
-      sq(File.A, Rank.R1) -> Piece.WhiteKing
-    )
-    val result = b.withCastle(Color.Black, CastleSide.Queenside)
-    result.pieceAt(sq(File.C, Rank.R8)) shouldBe Some(Piece.BlackKing)
-    result.pieceAt(sq(File.D, Rank.R8)) shouldBe Some(Piece.BlackRook)
-    result.pieceAt(sq(File.E, Rank.R8)) shouldBe None
-    result.pieceAt(sq(File.A, Rank.R8)) shouldBe None
+    GameRules.gameStatus(c, Color.White) shouldBe PositionStatus.Normal

modules/core/src/test/scala/de/nowchess/chess/logic/MoveValidatorTest.scala

@@ -2,7 +2,7 @@ package de.nowchess.chess.logic
 
 import de.nowchess.api.board.{Board, Color, File, Piece, Rank, Square}
 import de.nowchess.api.game.CastlingRights
-import de.nowchess.chess.logic.{CastleSide, GameHistory}
+import de.nowchess.chess.logic.{GameContext, CastleSide}
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
@@ -212,46 +212,167 @@ class MoveValidatorTest extends AnyFunSuite with Matchers:
     )
     MoveValidator.legalTargets(b, sq(File.D, Rank.R4)) should contain(sq(File.E, Rank.R4))
 
-  // ──── Pawn – en passant targets ──────────────────────────────────────
+  // ──── castlingTargets ────────────────────────────────────────────────
 
-  test("white pawn includes ep target in legal moves after black double push"):
-    // Black pawn just double-pushed to d5 (ep target = d6); white pawn on e5
-    val b = board(
-      sq(File.E, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R7), sq(File.D, Rank.R5))
-    MoveValidator.legalTargets(b, h, sq(File.E, Rank.R5)) should contain(sq(File.D, Rank.R6))
+  private def ctxWithRights(
+    entries: (Square, Piece)*
+  )(white: CastlingRights = CastlingRights.Both,
+    black: CastlingRights = CastlingRights.Both
+  ): GameContext =
+    GameContext(Board(entries.toMap), white, black)
 
-  test("white pawn does not include ep target without a preceding double push"):
-    val b = board(
-      sq(File.E, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R6), sq(File.D, Rank.R5))  // single push
-    MoveValidator.legalTargets(b, h, sq(File.E, Rank.R5)) should not contain sq(File.D, Rank.R6)
+  test("castlingTargets: white kingside available when all conditions met"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) should contain(sq(File.G, Rank.R1))
 
-  test("black pawn includes ep target in legal moves after white double push"):
-    // White pawn just double-pushed to e4 (ep target = e3); black pawn on d4
-    val b = board(
-      sq(File.D, Rank.R4) -> Piece.BlackPawn,
-      sq(File.E, Rank.R4) -> Piece.WhitePawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    MoveValidator.legalTargets(b, h, sq(File.D, Rank.R4)) should contain(sq(File.E, Rank.R3))
+  test("castlingTargets: white queenside available when all conditions met"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.A, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) should contain(sq(File.C, Rank.R1))
 
-  test("pawn on wrong file does not get ep target from adjacent double push"):
-    // White pawn on a5, black pawn double-pushed to d5 — a5 is not adjacent to d5
-    val b = board(
-      sq(File.A, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R5) -> Piece.BlackPawn
-    )
-    val h = GameHistory.empty.addMove(sq(File.D, Rank.R7), sq(File.D, Rank.R5))
-    MoveValidator.legalTargets(b, h, sq(File.A, Rank.R5)) should not contain sq(File.D, Rank.R6)
+  test("castlingTargets: black kingside available when all conditions met"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R8) -> Piece.BlackKing,
+      sq(File.H, Rank.R8) -> Piece.BlackRook,
+      sq(File.H, Rank.R1) -> Piece.WhiteKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.Black) should contain(sq(File.G, Rank.R8))
 
-  // ──── History-aware legalTargets fallback for non-pawn non-king pieces ─────
+  test("castlingTargets: black queenside available when all conditions met"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R8) -> Piece.BlackKing,
+      sq(File.A, Rank.R8) -> Piece.BlackRook,
+      sq(File.H, Rank.R1) -> Piece.WhiteKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.Black) should contain(sq(File.C, Rank.R8))
 
-  test("legalTargets with history delegates to geometry-only for non-pawn non-king pieces"):
-    val b = board(sq(File.D, Rank.R4) -> Piece.WhiteRook)
-    val h = GameHistory.empty.addMove(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    MoveValidator.legalTargets(b, h, sq(File.D, Rank.R4)) shouldBe MoveValidator.legalTargets(b, sq(File.D, Rank.R4))
+  test("castlingTargets: blocked when transit square is occupied"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.F, Rank.R1) -> Piece.WhiteBishop,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) should not contain sq(File.G, Rank.R1)
+
+  test("castlingTargets: blocked when king is in check"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.E, Rank.R8) -> Piece.BlackRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) shouldBe empty
+
+  test("castlingTargets: blocked when transit square f1 is attacked"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.F, Rank.R8) -> Piece.BlackRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) should not contain sq(File.G, Rank.R1)
+
+  test("castlingTargets: blocked when landing square g1 is attacked"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.G, Rank.R8) -> Piece.BlackRook,
+      sq(File.A, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) should not contain sq(File.G, Rank.R1)
+
+  test("castlingTargets: blocked when kingSide right is false"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )(white = CastlingRights(kingSide = false, queenSide = true))
+    MoveValidator.castlingTargets(ctx, Color.White) should not contain sq(File.G, Rank.R1)
+
+  test("castlingTargets: blocked when queenSide right is false"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.A, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )(white = CastlingRights(kingSide = true, queenSide = false))
+    MoveValidator.castlingTargets(ctx, Color.White) should not contain sq(File.C, Rank.R1)
+
+  test("castlingTargets: blocked when relevant rook is not on home square"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.G, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) should not contain sq(File.G, Rank.R1)
+
+  // ──── context-aware legalTargets includes castling ────────────────────
+
+  test("legalTargets(ctx, from): king on e1 includes g1 when castling available"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.legalTargets(ctx, sq(File.E, Rank.R1)) should contain(sq(File.G, Rank.R1))
+
+  test("legalTargets(ctx, from): non-king pieces unchanged by context"):
+    val ctx = ctxWithRights(
+      sq(File.D, Rank.R4) -> Piece.WhiteBishop,
+      sq(File.H, Rank.R8) -> Piece.BlackKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteKing
+    )()
+    MoveValidator.legalTargets(ctx, sq(File.D, Rank.R4)) shouldBe
+      MoveValidator.legalTargets(ctx.board, sq(File.D, Rank.R4))
+
+  // ──── isCastle / castleSide / isLegal(ctx) ───────────────────────────
+
+  test("isCastle: returns true when king moves two files"):
+    val board = Board(Map(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook
+    ))
+    MoveValidator.isCastle(board, sq(File.E, Rank.R1), sq(File.G, Rank.R1)) shouldBe true
+
+  test("isCastle: returns false when king moves one file"):
+    val board = Board(Map(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing
+    ))
+    MoveValidator.isCastle(board, sq(File.E, Rank.R1), sq(File.F, Rank.R1)) shouldBe false
+
+  test("castleSide: returns Kingside when moving to higher file"):
+    MoveValidator.castleSide(sq(File.E, Rank.R1), sq(File.G, Rank.R1)) shouldBe CastleSide.Kingside
+
+  test("castleSide: returns Queenside when moving to lower file"):
+    MoveValidator.castleSide(sq(File.E, Rank.R1), sq(File.C, Rank.R1)) shouldBe CastleSide.Queenside
+
+  test("isLegal(ctx): returns true for legal castling move"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.isLegal(ctx, sq(File.E, Rank.R1), sq(File.G, Rank.R1)) shouldBe true
+
+  test("isLegal(ctx): returns false for illegal castling move when rights revoked"):
+    val ctx = ctxWithRights(
+      sq(File.E, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )(white = CastlingRights.None)
+    MoveValidator.isLegal(ctx, sq(File.E, Rank.R1), sq(File.G, Rank.R1)) shouldBe false
+
+  test("castlingTargets: returns empty when king not on home square"):
+    val ctx = ctxWithRights(
+      sq(File.D, Rank.R1) -> Piece.WhiteKing,
+      sq(File.H, Rank.R1) -> Piece.WhiteRook,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    )()
+    MoveValidator.castlingTargets(ctx, Color.White) shouldBe empty

modules/core/src/test/scala/de/nowchess/chess/notation/FenExporterTest.scala

@@ -1,69 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.api.game.*
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class FenExporterTest extends AnyFunSuite with Matchers:
-
-  test("export initial position to FEN"):
-    val gameState = GameState.initial
-    val fen = FenExporter.gameStateToFen(gameState)
-    fen shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-
-  test("export position after e4"):
-    val gameState = GameState(
-      piecePlacement = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR",
-      activeColor = Color.Black,
-      castlingWhite = CastlingRights.Both,
-      castlingBlack = CastlingRights.Both,
-      enPassantTarget = Some(Square(File.E, Rank.R3)),
-      halfMoveClock = 0,
-      fullMoveNumber = 1,
-      status = GameStatus.InProgress
-    )
-    val fen = FenExporter.gameStateToFen(gameState)
-    fen shouldBe "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"
-
-  test("export position with no castling"):
-    val gameState = GameState(
-      piecePlacement = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR",
-      activeColor = Color.White,
-      castlingWhite = CastlingRights.None,
-      castlingBlack = CastlingRights.None,
-      enPassantTarget = None,
-      halfMoveClock = 0,
-      fullMoveNumber = 1,
-      status = GameStatus.InProgress
-    )
-    val fen = FenExporter.gameStateToFen(gameState)
-    fen shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1"
-
-  test("export position with partial castling"):
-    val gameState = GameState(
-      piecePlacement = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR",
-      activeColor = Color.White,
-      castlingWhite = CastlingRights(kingSide = true, queenSide = false),
-      castlingBlack = CastlingRights(kingSide = false, queenSide = true),
-      enPassantTarget = None,
-      halfMoveClock = 5,
-      fullMoveNumber = 3,
-      status = GameStatus.InProgress
-    )
-    val fen = FenExporter.gameStateToFen(gameState)
-    fen shouldBe "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w Kq - 5 3"
-
-  test("export position with en passant and move counts"):
-    val gameState = GameState(
-      piecePlacement = "rnbqkbnr/pp1ppppp/8/2pP4/8/8/PPPP1PPP/RNBQKBNR",
-      activeColor = Color.White,
-      castlingWhite = CastlingRights.Both,
-      castlingBlack = CastlingRights.Both,
-      enPassantTarget = Some(Square(File.C, Rank.R6)),
-      halfMoveClock = 2,
-      fullMoveNumber = 3,
-      status = GameStatus.InProgress
-    )
-    val fen = FenExporter.gameStateToFen(gameState)
-    fen shouldBe "rnbqkbnr/pp1ppppp/8/2pP4/8/8/PPPP1PPP/RNBQKBNR w KQkq c6 2 3"

modules/core/src/test/scala/de/nowchess/chess/notation/FenParserTest.scala

@@ -1,134 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.api.game.*
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class FenParserTest extends AnyFunSuite with Matchers:
-
-  test("parseBoard: initial position places pieces on correct squares"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
-    val board = FenParser.parseBoard(fen)
-
-    board.map(_.pieceAt(Square(File.E, Rank.R2))) shouldBe Some(Some(Piece.WhitePawn))
-    board.map(_.pieceAt(Square(File.E, Rank.R7))) shouldBe Some(Some(Piece.BlackPawn))
-    board.map(_.pieceAt(Square(File.E, Rank.R1))) shouldBe Some(Some(Piece.WhiteKing))
-    board.map(_.pieceAt(Square(File.E, Rank.R8))) shouldBe Some(Some(Piece.BlackKing))
-
-  test("parseBoard: empty board has no pieces"):
-    val fen = "8/8/8/8/8/8/8/8"
-    val board = FenParser.parseBoard(fen)
-
-    board shouldBe defined
-    board.get.pieces.size shouldBe 0
-
-  test("parseBoard: returns None for missing rank (only 7 ranks)"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP"
-    val board = FenParser.parseBoard(fen)
-
-    board shouldBe empty
-
-  test("parseBoard: returns None for invalid piece character"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNX"
-    val board = FenParser.parseBoard(fen)
-
-    board shouldBe empty
-
-  test("parseBoard: partial position with two kings placed correctly"):
-    val fen = "8/8/4k3/8/4K3/8/8/8"
-    val board = FenParser.parseBoard(fen)
-
-    board.map(_.pieceAt(Square(File.E, Rank.R6))) shouldBe Some(Some(Piece.BlackKing))
-    board.map(_.pieceAt(Square(File.E, Rank.R4))) shouldBe Some(Some(Piece.WhiteKing))
-
-  test("testRoundTripInitialPosition"):
-    val originalFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR"
-    val board = FenParser.parseBoard(originalFen)
-    val exportedFen = board.map(FenExporter.boardToFen)
-
-    exportedFen shouldBe Some(originalFen)
-
-  test("testRoundTripEmptyBoard"):
-    val originalFen = "8/8/8/8/8/8/8/8"
-    val board = FenParser.parseBoard(originalFen)
-    val exportedFen = board.map(FenExporter.boardToFen)
-
-    exportedFen shouldBe Some(originalFen)
-
-  test("testRoundTripPartialPosition"):
-    val originalFen = "8/8/4k3/8/4K3/8/8/8"
-    val board = FenParser.parseBoard(originalFen)
-    val exportedFen = board.map(FenExporter.boardToFen)
-
-    exportedFen shouldBe Some(originalFen)
-
-  test("parse full FEN - initial position"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
-    val gameState = FenParser.parseFen(fen)
-
-    gameState.isDefined shouldBe true
-    gameState.get.activeColor shouldBe Color.White
-    gameState.get.castlingWhite.kingSide shouldBe true
-    gameState.get.castlingWhite.queenSide shouldBe true
-    gameState.get.castlingBlack.kingSide shouldBe true
-    gameState.get.castlingBlack.queenSide shouldBe true
-    gameState.get.enPassantTarget shouldBe None
-    gameState.get.halfMoveClock shouldBe 0
-    gameState.get.fullMoveNumber shouldBe 1
-
-  test("parse full FEN - after e4"):
-    val fen = "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq e3 0 1"
-    val gameState = FenParser.parseFen(fen)
-
-    gameState.get.activeColor shouldBe Color.Black
-    gameState.get.enPassantTarget shouldBe Some(Square(File.E, Rank.R3))
-
-  test("parse full FEN - invalid parts count"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq"
-    val gameState = FenParser.parseFen(fen)
-
-    gameState.isDefined shouldBe false
-
-  test("parse full FEN - invalid color"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR x KQkq - 0 1"
-    val gameState = FenParser.parseFen(fen)
-
-    gameState.isDefined shouldBe false
-
-  test("parse full FEN - invalid castling"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w XYZ - 0 1"
-    val gameState = FenParser.parseFen(fen)
-
-    gameState.isDefined shouldBe false
-
-  test("parseFen: castling '-' produces CastlingRights.None for both sides"):
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1"
-    val gameState = FenParser.parseFen(fen)
-
-    gameState.isDefined shouldBe true
-    gameState.get.castlingWhite.kingSide shouldBe false
-    gameState.get.castlingWhite.queenSide shouldBe false
-    gameState.get.castlingBlack.kingSide shouldBe false
-    gameState.get.castlingBlack.queenSide shouldBe false
-
-  test("parseBoard: returns None when a rank has too many files (overflow beyond 8)"):
-    // "9" alone would advance fileIdx to 9, exceeding 8 → None
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBN9"
-    val board = FenParser.parseBoard(fen)
-
-    board shouldBe empty
-
-  test("parseBoard: returns None when a rank fails to parse (invalid middle rank)"):
-    // Invalid character 'X' in rank 4 should cause failure
-    val fen = "rnbqkbnr/pppppppp/8/8/XXXXXXXX/8/PPPPPPPP/RNBQKBNR"
-    val board = FenParser.parseBoard(fen)
-
-    board shouldBe empty
-
-  test("parseBoard: returns None when a rank has 9 piece characters (fileIdx > 7)"):
-    // 9 pawns in one rank triggers fileIdx > 7 guard (line 78)
-    val fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/PPPPPPPPP"
-    val board = FenParser.parseBoard(fen)
-
-    board shouldBe empty

modules/core/src/test/scala/de/nowchess/chess/notation/PgnExporterTest.scala

@@ -1,65 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.chess.logic.{GameHistory, HistoryMove, CastleSide}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class PgnExporterTest extends AnyFunSuite with Matchers:
-
-  test("export empty game") {
-    val headers = Map("Event" -> "Test", "White" -> "A", "Black" -> "B")
-    val history = GameHistory.empty
-    val pgn = PgnExporter.exportGame(headers, history)
-
-    pgn.contains("[Event \"Test\"]") shouldBe true
-    pgn.contains("[White \"A\"]") shouldBe true
-    pgn.contains("[Black \"B\"]") shouldBe true
-  }
-
-  test("export single move") {
-    val headers = Map("Event" -> "Test", "White" -> "A", "Black" -> "B")
-    val history = GameHistory()
-      .addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
-    val pgn = PgnExporter.exportGame(headers, history)
-
-    pgn.contains("1. e2e4") shouldBe true
-  }
-
-  test("export castling") {
-    val headers = Map("Event" -> "Test")
-    val history = GameHistory()
-      .addMove(HistoryMove(Square(File.E, Rank.R1), Square(File.G, Rank.R1), Some(CastleSide.Kingside)))
-    val pgn = PgnExporter.exportGame(headers, history)
-
-    pgn.contains("O-O") shouldBe true
-  }
-
-  test("export game sequence") {
-    val headers = Map("Event" -> "Test", "White" -> "A", "Black" -> "B", "Result" -> "1-0")
-    val history = GameHistory()
-      .addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
-      .addMove(HistoryMove(Square(File.C, Rank.R7), Square(File.C, Rank.R5), None))
-      .addMove(HistoryMove(Square(File.G, Rank.R1), Square(File.F, Rank.R3), None))
-    val pgn = PgnExporter.exportGame(headers, history)
-
-    pgn.contains("1. e2e4 c7c5") shouldBe true
-    pgn.contains("2. g1f3") shouldBe true
-  }
-
-  test("export game with no headers returns only move text") {
-    val history = GameHistory()
-      .addMove(HistoryMove(Square(File.E, Rank.R2), Square(File.E, Rank.R4), None))
-    val pgn = PgnExporter.exportGame(Map.empty, history)
-
-    pgn shouldBe "1. e2e4 *"
-  }
-
-  test("export queenside castling") {
-    val headers = Map("Event" -> "Test")
-    val history = GameHistory()
-      .addMove(HistoryMove(Square(File.E, Rank.R1), Square(File.C, Rank.R1), Some(CastleSide.Queenside)))
-    val pgn = PgnExporter.exportGame(headers, history)
-
-    pgn.contains("O-O-O") shouldBe true
-  }

modules/core/src/test/scala/de/nowchess/chess/notation/PgnParserTest.scala

@@ -1,334 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.chess.logic.{GameHistory, HistoryMove, CastleSide}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class PgnParserTest extends AnyFunSuite with Matchers:
-
-  test("parse PGN headers only") {
-    val pgn = """[Event "Test Game"]
-[Site "Earth"]
-[Date "2026.03.28"]
-[White "Alice"]
-[Black "Bob"]
-[Result "1-0"]"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    game.get.headers("Event") shouldBe "Test Game"
-    game.get.headers("White") shouldBe "Alice"
-    game.get.headers("Result") shouldBe "1-0"
-    game.get.moves shouldBe List()
-  }
-
-  test("parse PGN simple game") {
-    val pgn = """[Event "Test"]
-[Site "?"]
-[Date "2026.03.28"]
-[White "A"]
-[Black "B"]
-[Result "*"]
-
-1. e4 e5 2. Nf3 Nc6 3. Bb5 a6
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    game.get.moves.length shouldBe 6
-    // e4: e2-e4
-    game.get.moves(0).from shouldBe Square(File.E, Rank.R2)
-    game.get.moves(0).to shouldBe Square(File.E, Rank.R4)
-  }
-
-  test("parse PGN move with capture") {
-    val pgn = """[Event "Test"]
-[White "A"]
-[Black "B"]
-
-1. e4 e5 2. Nxe5
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    game.get.moves.length shouldBe 3
-    // Nxe5: knight captures on e5
-    game.get.moves(2).to shouldBe Square(File.E, Rank.R5)
-  }
-
-  test("parse PGN castling") {
-    val pgn = """[Event "Test"]
-[White "A"]
-[Black "B"]
-
-1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. O-O
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    // O-O is kingside castling: king e1-g1
-    val lastMove = game.get.moves.last
-    lastMove.from shouldBe Square(File.E, Rank.R1)
-    lastMove.to shouldBe Square(File.G, Rank.R1)
-    lastMove.castleSide.isDefined shouldBe true
-  }
-
-  test("parse PGN empty moves") {
-    val pgn = """[Event "Test"]
-[White "A"]
-[Black "B"]
-[Result "1-0"]
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    game.get.moves.length shouldBe 0
-  }
-
-  test("parse PGN black kingside castling O-O") {
-    // After e4 e5 Nf3 Nc6 Bc4 Bc5, black can castle kingside
-    val pgn = """[Event "Test"]
-
-1. e4 e5 2. Nf3 Nc6 3. Bc4 Bc5 4. O-O O-O
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    val blackCastle = game.get.moves.last
-    blackCastle.castleSide shouldBe Some(CastleSide.Kingside)
-    blackCastle.from shouldBe Square(File.E, Rank.R8)
-    blackCastle.to shouldBe Square(File.G, Rank.R8)
-  }
-
-  test("parse PGN result tokens are skipped") {
-    // Result tokens like 1-0, 0-1, 1/2-1/2, * should be silently skipped
-    val pgn = """[Event "Test"]
-
-1. e4 e5 1-0
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    game.get.moves.length shouldBe 2
-  }
-
-  test("parseAlgebraicMove: unrecognised token returns None and is skipped") {
-    val board = Board.initial
-    val history = GameHistory.empty
-    // "zzz" is not valid algebraic notation
-    val result = PgnParser.parseAlgebraicMove("zzz", board, history, Color.White)
-    result shouldBe None
-  }
-
-  test("parseAlgebraicMove: piece moves use charToPieceType for N B R Q K") {
-    // Test that piece type characters are recognised
-    val board = Board.initial
-    val history = GameHistory.empty
-
-    // Nf3 - knight move
-    val nMove = PgnParser.parseAlgebraicMove("Nf3", board, history, Color.White)
-    nMove.isDefined shouldBe true
-    nMove.get.to shouldBe Square(File.F, Rank.R3)
-  }
-
-  test("parseAlgebraicMove: single char that is too short returns None") {
-    val board = Board.initial
-    val history = GameHistory.empty
-    // Single char that is not castling and cleaned length < 2
-    val result = PgnParser.parseAlgebraicMove("e", board, history, Color.White)
-    result shouldBe None
-  }
-
-  test("parse PGN with file disambiguation hint") {
-    // Use a position where two rooks can reach the same square to test file hint
-    // Rooks on a1 and h1, destination d1 - "Rad1" uses file 'a' to disambiguate
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    val pieces: Map[Square, Piece] = Map(
-      Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
-      Square(File.H, Rank.R1) -> Piece(Color.White, PieceType.Rook),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val board = Board(pieces)
-    val history = GameHistory.empty
-
-    val result = PgnParser.parseAlgebraicMove("Rad1", board, history, Color.White)
-    result.isDefined shouldBe true
-    result.get.from shouldBe Square(File.A, Rank.R1)
-    result.get.to shouldBe Square(File.D, Rank.R1)
-  }
-
-  test("parse PGN with rank disambiguation hint") {
-    // Two rooks on a1 and a4 can reach a3 - "R1a3" uses rank '1' to disambiguate
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    val pieces: Map[Square, Piece] = Map(
-      Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
-      Square(File.A, Rank.R4) -> Piece(Color.White, PieceType.Rook),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val board = Board(pieces)
-    val history = GameHistory.empty
-
-    val result = PgnParser.parseAlgebraicMove("R1a3", board, history, Color.White)
-    result.isDefined shouldBe true
-    result.get.from shouldBe Square(File.A, Rank.R1)
-    result.get.to shouldBe Square(File.A, Rank.R3)
-  }
-
-  test("parseAlgebraicMove: charToPieceType covers all piece letters including B R Q K") {
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    // Bishop move
-    val piecesForBishop: Map[Square, Piece] = Map(
-      Square(File.C, Rank.R1) -> Piece(Color.White, PieceType.Bishop),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val boardBishop = Board(piecesForBishop)
-    val bResult = PgnParser.parseAlgebraicMove("Bd2", boardBishop, GameHistory.empty, Color.White)
-    bResult.isDefined shouldBe true
-
-    // Rook move
-    val piecesForRook: Map[Square, Piece] = Map(
-      Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val boardRook = Board(piecesForRook)
-    val rResult = PgnParser.parseAlgebraicMove("Ra4", boardRook, GameHistory.empty, Color.White)
-    rResult.isDefined shouldBe true
-
-    // Queen move
-    val piecesForQueen: Map[Square, Piece] = Map(
-      Square(File.D, Rank.R1) -> Piece(Color.White, PieceType.Queen),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val boardQueen = Board(piecesForQueen)
-    val qResult = PgnParser.parseAlgebraicMove("Qd4", boardQueen, GameHistory.empty, Color.White)
-    qResult.isDefined shouldBe true
-
-    // King move
-    val piecesForKing: Map[Square, Piece] = Map(
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val boardKing = Board(piecesForKing)
-    val kResult = PgnParser.parseAlgebraicMove("Ke2", boardKing, GameHistory.empty, Color.White)
-    kResult.isDefined shouldBe true
-  }
-
-  test("parse PGN queenside castling O-O-O") {
-    val pgn = """[Event "Test"]
-
-1. d4 d5 2. Nc3 Nc6 3. Bf4 Bf5 4. Qd2 Qd7 5. O-O-O
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    val lastMove = game.get.moves.last
-    lastMove.castleSide shouldBe Some(CastleSide.Queenside)
-    lastMove.from shouldBe Square(File.E, Rank.R1)
-    lastMove.to shouldBe Square(File.C, Rank.R1)
-  }
-
-  test("parse PGN black queenside castling O-O-O") {
-    // After sufficient moves, black castles queenside
-    val pgn = """[Event "Test"]
-
-1. d4 d5 2. Nc3 Nc6 3. Bf4 Bf5 4. Qd2 Qd7 5. O-O-O O-O-O
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    val lastMove = game.get.moves.last
-    lastMove.castleSide shouldBe Some(CastleSide.Queenside)
-    lastMove.from shouldBe Square(File.E, Rank.R8)
-    lastMove.to shouldBe Square(File.C, Rank.R8)
-  }
-
-  test("parse PGN with unrecognised token in move text is silently skipped") {
-    // "INVALID" is not valid PGN; it should be skipped and remaining moves parsed
-    val pgn = """[Event "Test"]
-
-1. e4 INVALID e5
-"""
-    val game = PgnParser.parsePgn(pgn)
-
-    game.isDefined shouldBe true
-    // e4 parsed, INVALID skipped, e5 parsed
-    game.get.moves.length shouldBe 2
-  }
-
-  test("parseAlgebraicMove: file+rank disambiguation with piece letter") {
-    // "Rae1" notation: piece R, disambig "a" -> hint is "a", piece letter is uppercase first char of disambig
-    // But since disambig="a" which is not uppercase, the piece letter comes from clean.head
-    // Test "Rae1" style: R is clean.head uppercase, disambig "a" is the hint
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    val pieces: Map[Square, Piece] = Map(
-      Square(File.A, Rank.R4) -> Piece(Color.White, PieceType.Rook),
-      Square(File.H, Rank.R4) -> Piece(Color.White, PieceType.Rook),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val board = Board(pieces)
-    val history = GameHistory.empty
-
-    // "Rae4" - Rook from a-file to e4; disambig = "a", clean.head = 'R' uppercase
-    val result = PgnParser.parseAlgebraicMove("Rae4", board, history, Color.White)
-    result.isDefined shouldBe true
-    result.get.from shouldBe Square(File.A, Rank.R4)
-    result.get.to shouldBe Square(File.E, Rank.R4)
-  }
-
-  test("parseAlgebraicMove: charToPieceType returns None for unknown character") {
-    // 'Z' is not a valid piece letter - the regex clean should return None
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    val board = Board.initial
-    val history = GameHistory.empty
-
-    // "Ze4" - Z is not a valid piece, charToPieceType('Z') returns None
-    // The result will be None because requiredPieceType is None and filtering by None.forall = true
-    // so it finds any piece that can reach e4, but since clean="Ze4" -> destStr="e4", disambig="Z"
-    // disambig.head.isUpper so charToPieceType('Z') is called
-    val result = PgnParser.parseAlgebraicMove("Ze4", board, history, Color.White)
-    // With None piece type, forall(pt => ...) is vacuously true so any piece reaching e4 is candidate
-    // But there's no piece named Z so requiredPieceType=None, meaning any piece can match
-    // This tests that charToPieceType('Z') returns None without crashing
-    result shouldBe defined  // will find a pawn or whatever reaches e4
-  }
-
-  test("parseAlgebraicMove: uppercase dest-only notation hits clean.head.isUpper and charToPieceType unknown char") {
-    // "E4" - clean = "E4", disambig = "", clean.head = 'E' is upper, charToPieceType('E') returns None
-    // This exercises line 97 (else if clean.head.isUpper) and line 152 (case _ => None)
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    val board = Board.initial
-    val history = GameHistory.empty
-    // 'E' is not a valid piece type but we still get a result since requiredPieceType is None
-    val result = PgnParser.parseAlgebraicMove("E4", board, history, Color.White)
-    // Result may be defined (pawn that can reach e4) or None; main goal is no crash and line coverage
-    result should not be null  // just verifies code path executes without exception
-  }
-
-  test("parseAlgebraicMove: rank disambiguation with digit outside 1-8 hits matchesHint else-true branch") {
-    // Build a board with a Rook that can be targeted with a disambiguation hint containing '9'
-    // hint = "9" → c = '9', not in a-h, not in 1-8, triggers else true
-    import de.nowchess.api.board.{Board, Square, File, Rank, Piece, Color, PieceType}
-    val pieces: Map[Square, Piece] = Map(
-      Square(File.A, Rank.R1) -> Piece(Color.White, PieceType.Rook),
-      Square(File.H, Rank.R1) -> Piece(Color.White, PieceType.Rook),
-      Square(File.E, Rank.R1) -> Piece(Color.White, PieceType.King),
-      Square(File.E, Rank.R8) -> Piece(Color.Black, PieceType.King)
-    )
-    val board = Board(pieces)
-    val history = GameHistory.empty
-
-    // "R9d1" - clean = "R9d1", destStr = "d1", disambig = "R9"
-    // disambig.head = 'R' is upper -> charToPieceType('R') = Rook, hint = "9"
-    // matchesHint called with hint "9" -> '9' not in a-h, not in 1-8 -> else true
-    val result = PgnParser.parseAlgebraicMove("R9d1", board, history, Color.White)
-    // Should find a rook (hint "9" matches everything)
-    result.isDefined shouldBe true
-    result.get.to shouldBe Square(File.D, Rank.R1)
-  }

modules/core/versions.env

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