refactor: update CLAUDE.md for improved structure and clarity

.claude/agents/scala-implementer.md

@@ -2,10 +2,9 @@
 name: scala-implementer
 description: "Implements Scala 3 + Quarkus REST services, domain logic, and persistence"
 tools: Read, Write, Edit, Bash, Glob
-model: inherit
+model: sonnet
 color: pink
 ---
-
 You do not have permissions to write tests, just source code.
 You are a Scala 3 expert specialising in Quarkus microservices.
 Always read the relevant /docs/api/ file before implementing.

.claude/agents/test-writer.md

@@ -2,10 +2,9 @@
 name: test-writer
 description: "Writes QuarkusTest unit and integration tests for a service. Invoke after scala-implementer has finished."
 tools: Read, Write, Edit, Bash, Glob, Grep, WebFetch, WebSearch, NotebookEdit
-model: haiku
+model: sonnet
 color: purple
 ---
-
 You do not have permissions to modify the source code, just write tests.
 You write tests for Scala 3 + Quarkus services.
 
@@ -13,11 +12,12 @@ 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.
 
 When invoked AFTER scala-implementer (implementation exists):
   Run python3 jacoco-reporter/jacoco_coverage_gaps.py modules/{service-name}/build/reports/jacoco/test/jacocoTestReport.xml --output agent
+  Use the jacoco-coverage-gaps skill — close coverage gaps revealed by the report.
   To regenerate the report run the tests first.

.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

.idea/AndroidProjectSystem.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AndroidProjectSystem">
-    <option name="providerId" value="com.android.tools.idea.GradleProjectSystem" />
-  </component>
-</project>

.idea/gradle.xml

@@ -12,7 +12,6 @@
             <option value="$PROJECT_DIR$/modules" />
             <option value="$PROJECT_DIR$/modules/api" />
             <option value="$PROJECT_DIR$/modules/core" />
-            <option value="$PROJECT_DIR$/modules/ui" />
           </set>
         </option>
       </GradleProjectSettings>

.idea/misc.xml

@@ -1,3 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
   <component name="FrameworkDetectionExcludesConfiguration">

.idea/scala_compiler.xml

@@ -5,7 +5,7 @@
       <option name="deprecationWarnings" value="true" />
       <option name="uncheckedWarnings" value="true" />
     </profile>
-    <profile name="Gradle 2" modules="NowChessSystems.modules.core.main,NowChessSystems.modules.core.scoverage,NowChessSystems.modules.core.test,NowChessSystems.modules.ui.main,NowChessSystems.modules.ui.scoverage,NowChessSystems.modules.ui.test">
+    <profile name="Gradle 2" modules="NowChessSystems.modules.core.main,NowChessSystems.modules.core.scoverage,NowChessSystems.modules.core.test">
       <option name="deprecationWarnings" value="true" />
       <option name="uncheckedWarnings" value="true" />
       <parameters>

.idea/vcs.xml

@@ -6,16 +6,6 @@
       <inspection_tool class="CommitNamingConvention" enabled="true" level="WARNING" enabled_by_default="true" />
     </profile>
   </component>
-  <component name="IssueNavigationConfiguration">
-    <option name="links">
-      <list>
-        <IssueNavigationLink>
-          <option name="issueRegexp" value="(?x)\b(CORE|NCWF|BAC|FRO|K8S|ORG|NCI|NCS)-\d+\b#YouTrack" />
-          <option name="linkRegexp" value="https://knockoutwhist.youtrack.cloud/issue/$0" />
-        </IssueNavigationLink>
-      </list>
-    </option>
-  </component>
   <component name="VcsDirectoryMappings">
     <mapping directory="" vcs="Git" />
   </component>

ARABIAN CHESS/license.txt

@@ -1,7 +0,0 @@
-YOU CAN:
-- Edit and use the asset in any commercial  or non commercial project 
-- Use the asset in any commercial  or non commercial project
-
-YOU CAN'T:
-- Resell or distribute the asset to others
-- Edit and resell the asset to others - - Credits required using This link: https://fatman200.itch.io/

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/`.
 

build.gradle.kts

@@ -1,6 +1,5 @@
 plugins {
     id("org.sonarqube") version "7.2.3.7755"
-    id("org.scoverage") version "8.1" apply false
 }
 
 group = "de.nowchess"
@@ -29,10 +28,7 @@ val versions = mapOf(
     "SCALA_LIBRARY"         to "2.13.18",
     "SCALATEST"             to "3.2.19",
     "SCALATEST_JUNIT"       to "0.1.11",
-    "SCOVERAGE"             to "2.1.1",
+    "SCOVERAGE"             to "2.1.1"
-    "SCALAFX"               to "21.0.0-R32",
-    "JAVAFX"                to "21.0.1",
-    "JUNIT_BOM"             to "5.13.4"
 )
 extra["VERSIONS"] = versions
 

clean

@@ -1,4 +0,0 @@
-#! /usr/bin/env bash
-set -euo pipefail
-
-./gradlew clean

compile

@@ -1,4 +0,0 @@
-#! /usr/bin/env bash
-set -euo pipefail
-
-./gradlew classes

coverage

@@ -1,10 +0,0 @@
-#! /usr/bin/env bash
-set -euo pipefail
-
-./gradlew test
-
-if [ "$#" -eq 0 ]; then
-  PYTHONUTF8=1 python3 jacoco-reporter/scoverage_coverage_gaps.py
-else
-  PYTHONUTF8=1 python3 jacoco-reporter/scoverage_coverage_gaps.py "modules/$1/build/reports/scoverageTest/scoverage.xml"
-fi

docs/unresolved.md

@@ -1,20 +0,0 @@
-## [2026-03-31] Unreachable code blocking 100% statement coverage
-
-**Requirement/Bug:** Reach 100% statement coverage in core module.
-
-**Root Cause:** 4 remaining uncovered statements (99.6% coverage) are unreachable code:
-1. **PgnParser.scala:160** (`case _ => None` in extractPromotion) - Regex `=([QRBN])` only matches those 4 characters; fallback case can never execute
-2. **GameHistory.scala:29** (`addMove$default$4` compiler-generated method) - Method overload 3 without defaults shadows the 4-param version, making promotionPiece default accessor unreachable
-3. **GameEngine.scala:201-202** (`case _` in completePromotion) - GameController.completePromotion always returns one of 4 expected MoveResult types; catch-all is defensive code
-
-**Attempted Fixes:**
-1. Added comprehensive PGN parsing tests (all 4 promotion types) - PgnParser improved from 95.8% to 99.4%
-2. Added GameHistory tests using named parameters - hit `addMove$default$3` (castleSide) but not `$default$4` (promotionPiece)
-3. Named parameter approach: `addMove(from=..., to=..., promotionPiece=...)` triggers 4-param with castleSide default ✓
-4. Positional approach: `addMove(f, t, None, None)` requires all 4 args (explicit, no defaults used) - doesn't hit $default$4
-5. Root issue: Scala's overload resolution prefers more-specific non-default overloads (2-param, 3-param) over the 4-param with defaults
-
-**Recommendation:** 99.6% (1029/1033) is maximum achievable without refactoring method overloads. Unreachable code design patterns:
-- **Pattern 1 (unreachable regex fallback):** Defensive pattern match against exhaustive regex
-- **Pattern 2 (overshadowed defaults):** Method overloads shadow default parameters in parent signature
-- **Pattern 3 (defensive catch-all):** Error handling for impossible external API returns

jacoco-reporter/scoverage_coverage_gaps.py

@@ -19,9 +19,6 @@ Usage:
     python scoverage_coverage_gaps.py <scoverage.xml> --output agent   (default)
     python scoverage_coverage_gaps.py <scoverage.xml> --package-filter de.nowchess.chess.controller
     python scoverage_coverage_gaps.py <scoverage.xml> --min-coverage 80
-    python scoverage_coverage_gaps.py                                 (default: scans ./modules)
-    python scoverage_coverage_gaps.py --modules-dir ./services
-    python scoverage_coverage_gaps.py <scoverage.xml>
 """
 
 import xml.etree.ElementTree as ET
@@ -29,8 +26,7 @@ import sys
 import argparse
 import json
 import re
-import glob
+from pathlib import Path, PureWindowsPath
-from pathlib import Path
 from dataclasses import dataclass, field
 from typing import Optional
 
@@ -116,6 +112,7 @@ class ClassGap:
     @property
     def uncovered_branch_lines(self) -> list[int]:
         """Lines that are branch points and have at least one uncovered branch statement."""
+        # Group branch statements by line; a line is "partial" if some covered, some not
         from collections import defaultdict
         by_line: dict[int, list[Statement]] = defaultdict(list)
         for s in self.statements:
@@ -123,7 +120,10 @@ class ClassGap:
                 by_line[s.line].append(s)
         partial = []
         for line, stmts in by_line.items():
-            if any(s.is_uncovered for s in stmts):
+            has_covered = any(s.is_covered for s in stmts)
+            has_uncovered = any(s.is_uncovered for s in stmts)
+            # Report line if any branch arm is uncovered
+            if has_uncovered:
                 partial.append(line)
         return sorted(partial)
 
@@ -169,10 +169,20 @@ class ClassGap:
 # ---------------------------------------------------------------------------
 
 def _normalise_source(raw: str) -> str:
+    """
+    Convert an absolute Windows or Unix source path from the XML into a
+    relative src/main/scala/… path for agent consumption.
+
+    Strategy:
+      1. Replace Windows backslashes.
+      2. Find the 'src/' anchor and take everything from there.
+      3. Fall back to the package-derived path if no anchor found.
+    """
     normalised = raw.replace("\\", "/")
     match = re.search(r"(src/(?:main|test)/scala/.+)", normalised)
     if match:
         return match.group(1)
+    # Fallback: just the filename portion
     return normalised.split("/")[-1]
 
 
@@ -180,10 +190,11 @@ def _normalise_source(raw: str) -> str:
 # Parser
 # ---------------------------------------------------------------------------
 
-def parse_scoverage_xml(xml_path: str) -> tuple[dict, list[ClassGap]]:
+def parse_scoverage_xml(xml_path: str) -> list[ClassGap]:
     tree = ET.parse(xml_path)
     root = tree.getroot()
 
+    # ── Authoritative project-level totals from <scoverage> root element ──────
     project_stats = {
         "total_statements":    int(root.get("statement-count", 0)),
         "covered_statements":  int(root.get("statements-invoked", 0)),
@@ -191,16 +202,17 @@ def parse_scoverage_xml(xml_path: str) -> tuple[dict, list[ClassGap]]:
         "branch_coverage_pct": float(root.get("branch-rate", 0.0)),
     }
     project_stats["missed_statements"] = (
-            project_stats["total_statements"] - project_stats["covered_statements"]
+        project_stats["total_statements"] - project_stats["covered_statements"]
     )
 
-    class_map: dict[str, ClassGap] = {}
+    class_map: dict[str, ClassGap] = {}   # full-class-name → ClassGap
 
     for package in root.findall("packages/package"):
         for cls_elem in package.findall("classes/class"):
             class_name = cls_elem.get("name", "")
             filename   = cls_elem.get("filename", "")
 
+            # Authoritative per-class totals from <class> attributes
             cls_total     = int(cls_elem.get("statement-count", 0))
             cls_invoked   = int(cls_elem.get("statements-invoked", 0))
             cls_stmt_rate = float(cls_elem.get("statement-rate", 0.0))
@@ -209,8 +221,11 @@ def parse_scoverage_xml(xml_path: str) -> tuple[dict, list[ClassGap]]:
             for method_elem in cls_elem.findall("methods/method"):
                 method_name = method_elem.get("name", "")
 
-                m_total   = int(method_elem.get("statement-count", 0))
+                # Authoritative per-method totals from <method> attributes
-                m_invoked = int(method_elem.get("statements-invoked", 0))
+                m_total     = int(method_elem.get("statement-count", 0))
+                m_invoked   = int(method_elem.get("statements-invoked", 0))
+                m_stmt_rate = float(method_elem.get("statement-rate", 0.0))
+                m_br_rate   = float(method_elem.get("branch-rate", 0.0))
 
                 for stmt_elem in method_elem.findall("statements/statement"):
                     raw_source = stmt_elem.get("source", filename)
@@ -242,6 +257,7 @@ def parse_scoverage_xml(xml_path: str) -> tuple[dict, list[ClassGap]]:
                         method=method_name,
                     ))
 
+                # Register method-level gap using authoritative XML stats
                 cg = next(
                     (v for v in class_map.values() if v.class_name == class_name),
                     None,
@@ -252,6 +268,7 @@ def parse_scoverage_xml(xml_path: str) -> tuple[dict, list[ClassGap]]:
                 uncov_lines        = sorted({s.line for s in active if s.is_uncovered})
                 uncov_branch_lines = sorted({s.line for s in active if s.is_branch and s.is_uncovered})
                 if uncov_lines or uncov_branch_lines:
+                    # Count branches from statement-level data (not in method XML attrs)
                     total_b = sum(1 for s in active if s.is_branch)
                     cov_b   = sum(1 for s in active if s.is_branch and s.is_covered)
                     mg = MethodGap(
@@ -265,6 +282,7 @@ def parse_scoverage_xml(xml_path: str) -> tuple[dict, list[ClassGap]]:
                     )
                     cg.method_gaps.append(mg)
 
+    # ── Project stats injected so formatters never recount from statements ────
     return project_stats, [cg for cg in class_map.values() if cg.has_gaps]
 
 
@@ -292,60 +310,103 @@ def _compact_ranges(numbers: list[int]) -> str:
 # Formatters
 # ---------------------------------------------------------------------------
 
-def format_agent(project_stats: dict, classes: list[ClassGap]) -> str:
+def _pct_bar(pct: float, width: int = 20) -> str:
-    """
+    """Render a compact ASCII progress bar, e.g. [████░░░░░░░░░░░░░░░░] 23.5%"""
-    Compact agent format — optimised for low token count.
+    filled = round(pct / 100 * width)
-    Emits only actionable gaps: file path, uncovered lines, branch-gap lines,
+    bar = "█" * filled + "░" * (width - filled)
-    and a per-method breakdown. No ASCII bars, no redundant tables.
+    return f"[{bar}] {pct:.1f}%"
-    """
-    lines: list[str] = []
 
-    total_stmts        = project_stats["total_statements"]
+
-    covered_stmts      = project_stats["covered_statements"]
+def format_agent(project_stats: dict, classes: list[ClassGap]) -> str:
-    missed_stmts       = project_stats["missed_statements"]
+    lines: list[str] = []
+    lines.append("# scoverage Coverage Gaps — Agent Action Report")
+    lines.append("")
+
+    # ---- Project-level totals (authoritative from <scoverage> root element) ----
+    total_stmts      = project_stats["total_statements"]
+    covered_stmts    = project_stats["covered_statements"]
+    missed_stmts     = project_stats["missed_statements"]
     overall_stmt_pct   = project_stats["stmt_coverage_pct"]
     overall_branch_pct = project_stats["branch_coverage_pct"]
-    total_branches     = sum(c.total_branches for c in classes)
+    total_branch_lines = sum(len(c.uncovered_branch_lines) for c in classes)
-    covered_branches   = sum(c.covered_branches for c in classes)
+    # Branch totals: count from statement data (scoverage root has no branch count attr)
-    missed_branches    = total_branches - covered_branches
+    total_branches   = sum(c.total_branches for c in classes)
+    covered_branches = sum(c.covered_branches for c in classes)
+    missed_branches  = sum(c.missed_branches for c in classes)
 
-    lines.append("# scoverage Coverage Gaps")
+    lines.append("## Project Coverage Summary")
-    lines.append(
+    lines.append("")
-        f"stmt: {overall_stmt_pct:.1f}% ({missed_stmts}/{total_stmts} missed) | "
+    lines.append(f"| Metric            | Covered | Total | Missed | Coverage |")
-        f"branches: {overall_branch_pct:.1f}% ({missed_branches}/{total_branches} missed) | "
+    lines.append(f"|-------------------|---------|-------|--------|----------|")
-        f"files with gaps: {len(classes)}"
+    lines.append(f"| Statements        | {covered_stmts:>7} | {total_stmts:>5} | {missed_stmts:>6} | {_pct_bar(overall_stmt_pct)} |")
-    )
+    lines.append(f"| Branch paths      | {covered_branches:>7} | {total_branches:>5} | {missed_branches:>6} | {_pct_bar(overall_branch_pct)} |")
+    lines.append(f"| Files with gaps   | {'—':>7} | {len(classes):>5} | {'—':>6} | {'—'} |")
+    lines.append(f"| Lines w/ br. gaps | {'—':>7} | {total_branch_lines:>5} | {'—':>6} | {'—'} |")
+    lines.append("")
+    lines.append("---")
+    lines.append("")
+    lines.append("## Files Requiring Tests")
+    lines.append("")
+    lines.append("> Each entry lists the SOURCE FILE PATH, uncovered LINE NUMBERS,")
+    lines.append("> and the METHODS that contain those gaps.")
+    lines.append("> Write or extend unit/integration tests to exercise these paths.")
     lines.append("")
 
     sorted_classes = sorted(classes, key=lambda c: -(c.missed_statements + c.missed_branches))
 
     for cls in sorted_classes:
-        uncov        = cls.all_uncovered_lines
+        lines.append(f"### `{cls.source_path}`")
-        branch_lines = cls.uncovered_branch_lines
+        lines.append(f"**Class**: `{cls.class_name}`")
+        lines.append("")
+        lines.append(f"| Metric       | Covered | Total | Missed | Coverage |")
+        lines.append(f"|--------------|---------|-------|--------|----------|")
+        lines.append(f"| Statements   | {cls.covered_statements:>7} | {cls.total_statements:>5} | {cls.missed_statements:>6} | {_pct_bar(cls.stmt_coverage_pct)} |")
+        if cls.total_branches:
+            lines.append(f"| Branch paths | {cls.covered_branches:>7} | {cls.total_branches:>5} | {cls.missed_branches:>6} | {_pct_bar(cls.branch_coverage_pct)} |")
+        lines.append("")
 
-        lines.append(f"## {cls.source_path}")
+        uncov = cls.all_uncovered_lines
-        lines.append(
-            f"stmt: {cls.stmt_coverage_pct:.1f}% ({cls.missed_statements} missed)"
-            + (f" | branches: {cls.branch_coverage_pct:.1f}% ({cls.missed_branches} missed)"
-               if cls.total_branches else "")
-        )
         if uncov:
-            lines.append(f"uncovered lines: {_compact_ranges(uncov)}")
+            lines.append("#### ❌ Uncovered Statements")
-        only_branch = [l for l in branch_lines if l not in cls.all_uncovered_lines]
+            lines.append(f"Lines never executed: `{_compact_ranges(uncov)}`")
-        if only_branch:
+            lines.append("")
-            lines.append(f"partial branches: {_compact_ranges(only_branch)}")
+
+        branch_lines = cls.uncovered_branch_lines
+        if branch_lines:
+            lines.append("#### ⚠️  Missing Branch Coverage (Conditional Paths)")
+            lines.append(f"Lines where not all conditional paths are taken: `{_compact_ranges(branch_lines)}`")
+            lines.append("")
 
         if cls.method_gaps:
-            lines.append("methods:")
+            lines.append("#### Methods with Gaps")
+            lines.append("")
+            lines.append("| Method | Stmt Coverage | Branch Coverage | Uncovered Lines | Branch Gap Lines |")
+            lines.append("|--------|--------------|-----------------|-----------------|------------------|")
             for mg in cls.method_gaps:
-                parts = [f"  {mg.short_name}"]
+                stmt_cell   = f"{_pct_bar(mg.stmt_coverage_pct, 10)} ({mg.total_statements - mg.covered_statements}/{mg.total_statements} missed)"
-                if mg.uncovered_lines:
+                branch_cell = f"{_pct_bar(mg.branch_coverage_pct, 10)} ({mg.missed_branches}/{mg.total_branches} missed)" if mg.total_branches else "n/a"
-                    parts.append(f"lines={_compact_ranges(mg.uncovered_lines)}")
+                uncov_cell  = f"`{_compact_ranges(mg.uncovered_lines)}`"        if mg.uncovered_lines        else "—"
-                if mg.uncovered_branch_lines:
+                br_cell     = f"`{_compact_ranges(mg.uncovered_branch_lines)}`" if mg.uncovered_branch_lines else "—"
-                    parts.append(f"branches={_compact_ranges(mg.uncovered_branch_lines)}")
+                lines.append(f"| `{mg.short_name}` | {stmt_cell} | {branch_cell} | {uncov_cell} | {br_cell} |")
-                lines.append(" ".join(parts))
+            lines.append("")
 
+        lines.append("**Action**: Add tests that exercise the lines/branches listed above.")
         lines.append("")
+        lines.append("---")
+        lines.append("")
+
+    lines.append("## Quick Reference: All Uncovered Locations")
+    lines.append("")
+    lines.append("Copy-paste friendly list for IDE navigation or grep:")
+    lines.append("")
+    lines.append("```")
+    for cls in sorted_classes:
+        for ln in cls.all_uncovered_lines:
+            lines.append(f"{cls.source_path}:{ln}  # uncovered statement")
+        for ln in cls.uncovered_branch_lines:
+            if ln not in cls.all_uncovered_lines:
+                lines.append(f"{cls.source_path}:{ln}  # partial branch")
+    lines.append("```")
 
     return "\n".join(lines)
 
@@ -450,87 +511,6 @@ def format_markdown(project_stats: dict, classes: list[ClassGap]) -> str:
     return "\n".join(lines)
 
 
-# ---------------------------------------------------------------------------
-# Scan-modules mode
-# ---------------------------------------------------------------------------
-
-# Candidate sub-paths within a module directory where scoverage.xml may live.
-_SCOVERAGE_SUBPATHS = [
-    # Gradle / default layout
-    "build/reports/scoverageTest/scoverage.xml",
-    # sbt default (scala version wildcard resolved via glob)
-    "target/scala-*/scoverage-report/scoverage.xml",
-    # Maven / flat layout
-    "target/scoverage-report/scoverage.xml",
-    # Already at root of module
-    "scoverage.xml",
-]
-
-
-def _find_scoverage_xml(module_dir: Path) -> Optional[Path]:
-    """Return the first scoverage.xml found inside *module_dir*, or None."""
-    for pattern in _SCOVERAGE_SUBPATHS:
-        hits = sorted(module_dir.glob(pattern))
-        if hits:
-            return hits[0]
-    return None
-
-
-def format_module_gaps(module_name: str, classes: list[ClassGap], stmt_pct: float) -> str:
-    """
-    One summary line per module. If coverage is not 100%, append an agent hint.
-    """
-    if not classes:
-        return f"[{module_name}] stmt: {stmt_pct:.1f}% ✅"
-
-    line = f"[{module_name}] stmt: {stmt_pct:.1f}%  files_with_gaps: {len(classes)}"
-    if stmt_pct < 100.0:
-        line += f"  # hint: run ./coverage {module_name} for details"
-    return line
-
-
-def run_scan_modules(modules_dir: str, package_filter: Optional[str], min_coverage: float) -> None:
-    base = Path(modules_dir)
-    if not base.is_dir():
-        print(f"ERROR: modules directory not found: {base}", file=sys.stderr)
-        sys.exit(1)
-
-    module_dirs = sorted(p for p in base.iterdir() if p.is_dir())
-    if not module_dirs:
-        print(f"No sub-directories found in {base}", file=sys.stderr)
-        sys.exit(1)
-
-    results: list[str] = []
-    missing: list[str] = []
-
-    for mod_dir in module_dirs:
-        if mod_dir.name.startswith("build"):
-            continue
-        xml_path = _find_scoverage_xml(mod_dir)
-        if xml_path is None:
-            missing.append(mod_dir.name)
-            continue
-
-        project_stats, classes = parse_scoverage_xml(str(xml_path))
-
-        if package_filter:
-            classes = [c for c in classes if c.class_name.startswith(package_filter)]
-        if min_coverage > 0:
-            classes = [c for c in classes if c.stmt_coverage_pct < min_coverage]
-
-        results.append(
-            format_module_gaps(mod_dir.name, classes, project_stats["stmt_coverage_pct"])
-        )
-
-    print("\n".join(results))
-
-    if missing:
-        print(
-            f"\n# Modules without scoverage.xml: {', '.join(missing)}",
-            file=sys.stderr,
-        )
-
-
 # ---------------------------------------------------------------------------
 # Entry point
 # ---------------------------------------------------------------------------
@@ -539,13 +519,7 @@ def main() -> None:
     parser = argparse.ArgumentParser(
         description="Report missing statement & branch coverage from a scoverage XML report."
     )
-
+    parser.add_argument("xml_file", help="Path to scoverage.xml report file")
-    # Positional xml_file is optional when --scan-modules is used
-    parser.add_argument(
-        "xml_file",
-        nargs="?",
-        help="Path to scoverage.xml report file (not required with --scan-modules)",
-    )
     parser.add_argument(
         "--output", "-o",
         choices=["agent", "json", "markdown"],
@@ -563,30 +537,8 @@ def main() -> None:
         default=None,
         help="Only report classes in this package prefix (e.g. de.nowchess.chess.controller)",
     )
-    # ── Scan-modules mode ──────────────────────────────────────────────────
-    parser.add_argument(
-        "--scan-modules",
-        action="store_true",
-        help=(
-            "Scan every sub-directory of --modules-dir for a scoverage.xml "
-            "and print a compact coverage-gaps summary per module."
-        ),
-    )
-    parser.add_argument(
-        "--modules-dir",
-        default="./modules",
-        help="Root directory that contains one sub-directory per module (default: ./modules)",
-    )
-
     args = parser.parse_args()
 
-    # ── Scan-modules path (explicit flag, or default when no xml_file given) ──
-    if args.scan_modules or not args.xml_file:
-        run_scan_modules(args.modules_dir, args.package_filter, args.min_coverage)
-        return
-
-    # ── Single-file path ──────────────────────────────────────────────────
-
     xml_path = Path(args.xml_file)
     if not xml_path.exists():
         print(f"ERROR: File not found: {xml_path}", file=sys.stderr)
@@ -613,4 +565,4 @@ def main() -> None:
 
 
 if __name__ == "__main__":
-    main()
+    main()

jacoco-reporter/test_gaps.py

@@ -1,288 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test Gap Reporter
-Scans JUnit XML test results under modules/*/build/test-results/*.xml and
-outputs a minimal summary optimised for agent consumption.
-
-Usage:
-    python test_gaps.py                        # scan all modules (default)
-    python test_gaps.py --module chess         # single module
-    python test_gaps.py --module all           # explicit all
-    python test_gaps.py --modules-dir ./modules
-    python test_gaps.py --results-subdir build/test-results
-"""
-
-import xml.etree.ElementTree as ET
-import sys
-import argparse
-from pathlib import Path
-from dataclasses import dataclass, field
-from typing import Optional
-
-
-# ---------------------------------------------------------------------------
-# Data classes
-# ---------------------------------------------------------------------------
-
-@dataclass
-class TestCase:
-    classname: str
-    name: str
-    time: float
-    failure: Optional[str] = None   # message if failed
-    error: Optional[str]   = None   # message if errored
-    skipped: bool          = False
-
-    @property
-    def short_class(self) -> str:
-        return self.classname.split(".")[-1]
-
-    @property
-    def status(self) -> str:
-        if self.failure is not None:
-            return "FAIL"
-        if self.error is not None:
-            return "ERROR"
-        if self.skipped:
-            return "SKIP"
-        return "OK"
-
-
-@dataclass
-class SuiteResult:
-    name: str
-    total: int
-    failures: int
-    errors: int
-    skipped: int
-    time: float
-    cases: list[TestCase] = field(default_factory=list)
-
-    @property
-    def passed(self) -> int:
-        return self.total - self.failures - self.errors - self.skipped
-
-    @property
-    def is_clean(self) -> bool:
-        return self.failures == 0 and self.errors == 0
-
-    @property
-    def bad_cases(self) -> list[TestCase]:
-        return [c for c in self.cases if c.status in ("FAIL", "ERROR")]
-
-    @property
-    def skipped_cases(self) -> list[TestCase]:
-        return [c for c in self.cases if c.skipped]
-
-
-@dataclass
-class ModuleResult:
-    name: str
-    suites: list[SuiteResult] = field(default_factory=list)
-
-    @property
-    def total(self)    -> int: return sum(s.total    for s in self.suites)
-    @property
-    def failures(self) -> int: return sum(s.failures for s in self.suites)
-    @property
-    def errors(self)   -> int: return sum(s.errors   for s in self.suites)
-    @property
-    def skipped(self)  -> int: return sum(s.skipped  for s in self.suites)
-    @property
-    def passed(self)   -> int: return sum(s.passed   for s in self.suites)
-    @property
-    def is_clean(self) -> bool: return self.failures == 0 and self.errors == 0
-
-    @property
-    def bad_cases(self) -> list[TestCase]:
-        return [c for s in self.suites for c in s.bad_cases]
-
-    @property
-    def skipped_cases(self) -> list[TestCase]:
-        return [c for s in self.suites for c in s.skipped_cases]
-
-
-# ---------------------------------------------------------------------------
-# Parser
-# ---------------------------------------------------------------------------
-
-def parse_suite_xml(xml_path: Path) -> SuiteResult:
-    tree = ET.parse(xml_path)
-    root = tree.getroot()
-
-    # Handle both <testsuite> root and <testsuites> wrapper
-    suites = [root] if root.tag == "testsuite" else root.findall("testsuite")
-
-    # Merge multiple suites from one file into a single SuiteResult
-    total = failures = errors = skipped = 0
-    elapsed = 0.0
-    name = xml_path.stem
-    cases: list[TestCase] = []
-
-    for suite in suites:
-        total    += int(suite.get("tests",    0))
-        failures += int(suite.get("failures", 0))
-        errors   += int(suite.get("errors",   0))
-        skipped  += int(suite.get("skipped",  0))
-        elapsed  += float(suite.get("time",   0.0))
-        if suite.get("name"):
-            name = suite.get("name")
-
-        for tc in suite.findall("testcase"):
-            fail_el = tc.find("failure")
-            err_el  = tc.find("error")
-            skip_el = tc.find("skipped")
-            cases.append(TestCase(
-                classname=tc.get("classname", ""),
-                name=tc.get("name", ""),
-                time=float(tc.get("time", 0.0)),
-                failure=fail_el.get("message", fail_el.text or "") if fail_el is not None else None,
-                error=err_el.get("message",  err_el.text  or "") if err_el  is not None else None,
-                skipped=skip_el is not None,
-            ))
-
-    return SuiteResult(
-        name=name, total=total, failures=failures,
-        errors=errors, skipped=skipped, time=elapsed, cases=cases,
-    )
-
-
-def load_module(module_dir: Path, results_subdir: str) -> Optional[ModuleResult]:
-    results_dir = module_dir / results_subdir
-    if not results_dir.is_dir():
-        return None
-
-    xml_files = sorted(results_dir.glob("*.xml"))
-    if not xml_files:
-        return None
-
-    mod = ModuleResult(name=module_dir.name)
-    for xml_path in xml_files:
-        try:
-            mod.suites.append(parse_suite_xml(xml_path))
-        except ET.ParseError:
-            pass  # skip malformed files silently
-    return mod if mod.suites else None
-
-
-# ---------------------------------------------------------------------------
-# Formatter
-# ---------------------------------------------------------------------------
-
-def _truncate(text: str, max_len: int = 120) -> str:
-    text = " ".join(text.split())        # collapse whitespace
-    return text[:max_len] + "…" if len(text) > max_len else text
-
-
-def format_module(mod: ModuleResult) -> str:
-    parts = [f"[{mod.name}]"]
-
-    if mod.is_clean and mod.skipped == 0:
-        parts.append(f"tests: {mod.total} ✅")
-        return " ".join(parts)
-
-    parts.append(f"tests: {mod.total}")
-    if mod.failures:  parts.append(f"failed: {mod.failures}")
-    if mod.errors:    parts.append(f"errors: {mod.errors}")
-    if mod.skipped:   parts.append(f"skipped: {mod.skipped}")
-
-    # Agent hint only when there are actual failures/errors
-    if not mod.is_clean:
-        parts.append(f" # hint: run ./test {mod.name} for details")
-
-    lines = [" ".join(parts)]
-
-    # List each failed/errored test — this IS the actionable info
-    for tc in mod.bad_cases:
-        msg = tc.failure if tc.failure is not None else tc.error
-        label = f"  {tc.status}: {tc.short_class} > {tc.name}"
-        if msg:
-            label += f"  [{_truncate(msg, 80)}]"
-        lines.append(label)
-
-    # Skipped: compact, one line total
-    if mod.skipped_cases:
-        skipped_names = ", ".join(
-            f"{c.short_class}.{c.name}" for c in mod.skipped_cases[:5]
-        )
-        if len(mod.skipped_cases) > 5:
-            skipped_names += f" (+{len(mod.skipped_cases) - 5} more)"
-        lines.append(f"  SKIP: {skipped_names}")
-
-    return "\n".join(lines)
-
-
-# ---------------------------------------------------------------------------
-# Runner
-# ---------------------------------------------------------------------------
-
-def run(modules_dir: str, results_subdir: str, module_filter: Optional[str]) -> None:
-    base = Path(modules_dir)
-    if not base.is_dir():
-        print(f"ERROR: modules directory not found: {base}", file=sys.stderr)
-        sys.exit(1)
-
-    # Resolve which module dirs to scan
-    if module_filter and module_filter != "all":
-        mod_dir = base / module_filter
-        if not mod_dir.is_dir():
-            print(f"ERROR: module not found: {mod_dir}", file=sys.stderr)
-            sys.exit(1)
-        candidates = [mod_dir]
-    else:
-        candidates = sorted(p for p in base.iterdir() if p.is_dir())
-
-    results: list[str] = []
-    missing: list[str] = []
-
-    for mod_dir in candidates:
-        if mod_dir.name.startswith("build"):
-            continue
-        mod = load_module(mod_dir, results_subdir)
-        if mod is None:
-            missing.append(mod_dir.name)
-            continue
-        results.append(format_module(mod))
-
-    print("\n".join(results))
-
-    if missing:
-        print(
-            f"\n# Modules without test results: {', '.join(missing)}",
-            file=sys.stderr,
-        )
-
-
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-
-def main() -> None:
-    parser = argparse.ArgumentParser(
-        description="Minimal test-gap reporter for JUnit XML results across modules."
-    )
-    parser.add_argument(
-        "--module", "-m",
-        nargs="?",
-        const="all",
-        default="all",
-        help="Module name to scan, or 'all' (default: all)",
-    )
-    parser.add_argument(
-        "--modules-dir",
-        default="./modules",
-        help="Root directory containing one sub-directory per module (default: ./modules)",
-    )
-    parser.add_argument(
-        "--results-subdir",
-        default="build/test-results/test",
-        help="Sub-path inside each module dir where *.xml files live (default: build/test-results/test)",
-    )
-    args = parser.parse_args()
-
-    filter_ = None if args.module == "all" else args.module
-    run(args.modules_dir, args.results_subdir, filter_)
-
-
-if __name__ == "__main__":
-    main()

modules/api/CHANGELOG.md

@@ -1,13 +0,0 @@
-##  (2026-03-27)
-##  (2026-03-28)
-##  (2026-03-28)
-##  (2026-03-29)
-##  (2026-03-31)
-##  (2026-04-01)
-##  (2026-04-01)
-##  (2026-04-01)
-##  (2026-04-02)
-
-### Features
-
-* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))

modules/api/build.gradle.kts

@@ -59,7 +59,7 @@ tasks.test {
     useJUnitPlatform {
         includeEngines("scalatest")
         testLogging {
-            events("skipped", "failed")
+            events("passed", "skipped", "failed")
         }
     }
     finalizedBy(tasks.reportScoverage)

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))
+      val updated  = b.removed(from).updated(to, b(from))
-      (updatedBoard, captured)
+      (updated, captured)
     def pieces: Map[Square, Piece] = b
 
   val initial: Board =

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

@@ -100,23 +100,3 @@ class BoardTest extends AnyFunSuite with Matchers:
     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/versions.env

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

modules/core/CHANGELOG.md

@@ -1,167 +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))
-##  (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))
-* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
-* 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-31)
-
-### 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-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
-* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
-* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
-* 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-04-01)
-
-### 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-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
-* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
-* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
-* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
-* 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))
-* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
-##  (2026-04-01)
-
-### 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-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
-* NCS-11 50-move rule ([#9](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/9)) ([412ed98](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/412ed986a95703a3b282276540153480ceed229d))
-* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
-* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
-* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
-* 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))
-* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
-##  (2026-04-01)
-
-### 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-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
-* NCS-11 50-move rule ([#9](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/9)) ([412ed98](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/412ed986a95703a3b282276540153480ceed229d))
-* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
-* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
-* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
-* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
-* 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))
-* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))
-##  (2026-04-02)
-
-### 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-10 Implement Pawn Promotion ([#12](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/12)) ([13bfc16](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/13bfc16cfe25db78ec607db523ca6d993c13430c))
-* NCS-11 50-move rule ([#9](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/9)) ([412ed98](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/412ed986a95703a3b282276540153480ceed229d))
-* NCS-16 Core Separation via Patterns ([#10](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/10)) ([1361dfc](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/1361dfc89553b146864fb8ff3526cf12cf3f293a))
-* NCS-17 Implement basic ScalaFX UI ([#14](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/14)) ([3ff8031](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/3ff80318b4f16c59733a46498581a5c27f048287))
-* NCS-21 Write Scripts to automate certain tasks ([#15](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/15)) ([8051871](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/80518719d536a087d339fe02530825dc07f8b388))
-* NCS-6 Implementing FEN & PGN ([#7](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/7)) ([f28e69d](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/f28e69dc181416aa2f221fdc4b45c2cda5efbf07))
-* NCS-9 En passant implementation ([#8](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/8)) ([919beb3](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/919beb3b4bfa8caf2f90976a415fe9b19b7e9747))
-* 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))
-* update move validation to check for king safety ([#13](https://git.janis-eccarius.de/NowChess/NowChessSystems/issues/13)) ([e5e20c5](https://git.janis-eccarius.de/NowChess/NowChessSystems/commit/e5e20c566e368b12ca1dc59680c34e9112bf6762))

modules/core/build.gradle.kts

@@ -62,7 +62,7 @@ tasks.test {
     useJUnitPlatform {
         includeEngines("scalatest")
         testLogging {
-            events("skipped", "failed")
+            events("passed", "skipped", "failed")
         }
     }
     finalizedBy(tasks.reportScoverage)

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

@@ -0,0 +1,11 @@
+package de.nowchess.chess
+
+import de.nowchess.api.board.Color
+import de.nowchess.chess.controller.GameController
+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(GameContext.initial, Color.White)
+}

modules/core/src/main/scala/de/nowchess/chess/command/Command.scala

@@ -1,64 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Square, Board, Color, Piece}
-import de.nowchess.chess.logic.GameHistory
-
-/** Marker trait for all commands that can be executed and undone.
- *  Commands encapsulate user actions and game state transitions.
- */
-trait Command:
-  /** Execute the command and return true if successful, false otherwise. */
-  def execute(): Boolean
-
-  /** Undo the command and return true if successful, false otherwise. */
-  def undo(): Boolean
-
-  /** A human-readable description of this command. */
-  def description: String
-
-/** Command to move a piece from one square to another.
- *  Stores the move result so undo can restore previous state.
- */
-case class MoveCommand(
-  from: Square,
-  to: Square,
-  moveResult: Option[MoveResult] = None,
-  previousBoard: Option[Board] = None,
-  previousHistory: Option[GameHistory] = None,
-  previousTurn: Option[Color] = None
-) extends Command:
-
-  override def execute(): Boolean =
-    moveResult.isDefined
-
-  override def undo(): Boolean =
-    previousBoard.isDefined && previousHistory.isDefined && previousTurn.isDefined
-
-  override def description: String = s"Move from $from to $to"
-
-// Sealed hierarchy of move outcomes (for tracking state changes)
-sealed trait MoveResult
-object MoveResult:
-  case class Successful(newBoard: Board, newHistory: GameHistory, newTurn: Color, captured: Option[Piece]) extends MoveResult
-  case object InvalidFormat extends MoveResult
-  case object InvalidMove extends MoveResult
-
-/** Command to quit the game. */
-case class QuitCommand() extends Command:
-  override def execute(): Boolean = true
-  override def undo(): Boolean = false
-  override def description: String = "Quit game"
-
-/** Command to reset the board to initial position. */
-case class ResetCommand(
-  previousBoard: Option[Board] = None,
-  previousHistory: Option[GameHistory] = None,
-  previousTurn: Option[Color] = None
-) extends Command:
-
-  override def execute(): Boolean = true
-
-  override def undo(): Boolean =
-    previousBoard.isDefined && previousHistory.isDefined && previousTurn.isDefined
-
-  override def description: String = "Reset board"

modules/core/src/main/scala/de/nowchess/chess/command/CommandInvoker.scala

@@ -1,73 +0,0 @@
-package de.nowchess.chess.command
-
-/** Manages command execution and history for undo/redo support. */
-class CommandInvoker:
-  private val executedCommands = scala.collection.mutable.ListBuffer[Command]()
-  private var currentIndex = -1
-
-  /** Execute a command and add it to history.
-   *  Discards any redo history if not at the end of the stack.
-   */
-  def execute(command: Command): Boolean = synchronized {
-    if command.execute() then
-      // Remove any commands after current index (redo stack is discarded)
-      while currentIndex < executedCommands.size - 1 do
-        executedCommands.remove(executedCommands.size - 1)
-      executedCommands += command
-      currentIndex += 1
-      true
-    else
-      false
-  }
-
-  /** Undo the last executed command if possible. */
-  def undo(): Boolean = synchronized {
-    if currentIndex >= 0 && currentIndex < executedCommands.size then
-      val command = executedCommands(currentIndex)
-      if command.undo() then
-        currentIndex -= 1
-        true
-      else
-        false
-    else
-      false
-  }
-
-  /** Redo the next command in history if available. */
-  def redo(): Boolean = synchronized {
-    if currentIndex + 1 < executedCommands.size then
-      val command = executedCommands(currentIndex + 1)
-      if command.execute() then
-        currentIndex += 1
-        true
-      else
-        false
-    else
-      false
-  }
-
-  /** Get the history of all executed commands. */
-  def history: List[Command] = synchronized {
-    executedCommands.toList
-  }
-
-  /** Get the current position in command history. */
-  def getCurrentIndex: Int = synchronized {
-    currentIndex
-  }
-
-  /** Clear all command history. */
-  def clear(): Unit = synchronized {
-    executedCommands.clear()
-    currentIndex = -1
-  }
-
-  /** Check if undo is available. */
-  def canUndo: Boolean = synchronized {
-    currentIndex >= 0
-  }
-
-  /** Check if redo is available. */
-  def canRedo: Boolean = synchronized {
-    currentIndex + 1 < executedCommands.size
-  }

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

@@ -1,8 +1,10 @@
 package de.nowchess.chess.controller
 
-import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
+import scala.io.StdIn
-import de.nowchess.api.move.PromotionPiece
+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
 
 // ---------------------------------------------------------------------------
 // Result ADT returned by the pure processMove function
@@ -15,16 +17,8 @@ object MoveResult:
   case object NoPiece                                                                   extends MoveResult
   case object WrongColor                                                                extends MoveResult
   case object IllegalMove                                                               extends MoveResult
-  case class  PromotionRequired(
+  case class  Moved(newCtx: GameContext, captured: Option[Piece], newTurn: Color)      extends MoveResult
-    from: Square,
+  case class  MovedInCheck(newCtx: GameContext, captured: Option[Piece], newTurn: Color) extends MoveResult
-    to: Square,
-    boardBefore: Board,
-    historyBefore: GameHistory,
-    captured: Option[Piece],
-    turn: Color
-  ) 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  Checkmate(winner: Color)                                                  extends MoveResult
   case object Stalemate                                                                 extends MoveResult
 
@@ -37,70 +31,106 @@ 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
+      case "quit" | "q" =>
+        MoveResult.Quit
       case trimmed =>
         Parser.parseMove(trimmed) match
-          case None              => MoveResult.InvalidFormat(trimmed)
+          case None =>
-          case Some((from, to))  => validateAndApply(board, history, turn, from, to)
+            MoveResult.InvalidFormat(trimmed)
+          case Some((from, to)) =>
+            ctx.board.pieceAt(from) match
+              case None =>
+                MoveResult.NoPiece
+              case Some(piece) if piece.color != turn =>
+                MoveResult.WrongColor
+              case Some(_) =>
+                if !MoveValidator.isLegal(ctx, from, to) then
+                  MoveResult.IllegalMove
+                else
+                  val castleOpt = if MoveValidator.isCastle(ctx.board, from, to)
+                                  then Some(MoveValidator.castleSide(from, to))
+                                  else None
+                  val (newBoard, captured) = castleOpt match
+                    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
 
-  /** Apply a previously detected promotion move with the chosen piece.
+  private def applyRightsRevocation(
-   *  Called after processMove returned PromotionRequired.
+    ctx: GameContext,
-   */
+    turn: Color,
-  def completePromotion(
-    board: Board,
-    history: GameHistory,
     from: Square,
     to: Square,
-    piece: PromotionPiece,
+    castle: Option[CastleSide]
-    turn: Color
+  ): GameContext =
-  ): MoveResult =
+    // Step 1: Revoke all rights for a castling move (idempotent with step 2)
-    val (boardAfterMove, captured) = board.withMove(from, to)
+    val ctx0 = castle.fold(ctx)(_ => ctx.withUpdatedRights(turn, CastlingRights.None))
-    val promotedPieceType = piece match
-      case PromotionPiece.Queen  => PieceType.Queen
-      case PromotionPiece.Rook   => PieceType.Rook
-      case PromotionPiece.Bishop => PieceType.Bishop
-      case PromotionPiece.Knight => PieceType.Knight
-    val newBoard    = boardAfterMove.updated(to, Piece(turn, promotedPieceType))
-    // Promotion is always a pawn move → clock resets
-    val newHistory = history.addMove(from, to, None, Some(piece), wasPawnMove = true)
-    toMoveResult(newBoard, newHistory, captured, turn)
 
-  // ---------------------------------------------------------------------------
+    // Step 2: Source-square revocation
-  // Private helpers
+    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
 
-  private def validateAndApply(board: Board, history: GameHistory, turn: Color, from: Square, to: Square): MoveResult =
+    // Step 3: Destination-square revocation (enemy captures a rook on its home square)
-    board.pieceAt(from) match
+    to match
-      case None                              => MoveResult.NoPiece
+      case Square(File.A, Rank.R1) => ctx1.withUpdatedRights(Color.White, ctx1.whiteCastling.copy(queenSide = false))
-      case Some(piece) if piece.color != turn => MoveResult.WrongColor
+      case Square(File.H, Rank.R1) => ctx1.withUpdatedRights(Color.White, ctx1.whiteCastling.copy(kingSide  = false))
-      case Some(_) =>
+      case Square(File.A, Rank.R8) => ctx1.withUpdatedRights(Color.Black, ctx1.blackCastling.copy(queenSide = false))
-        if !GameRules.legalMoves(board, history, turn).contains(from -> to) then MoveResult.IllegalMove
+      case Square(File.H, Rank.R8) => ctx1.withUpdatedRights(Color.Black, ctx1.blackCastling.copy(kingSide  = false))
-        else if MoveValidator.isPromotionMove(board, from, to) then
+      case _                       => ctx1
-          MoveResult.PromotionRequired(from, to, board, history, board.pieceAt(to), turn)
-        else applyNormalMove(board, history, turn, from, to)
 
-  private def applyNormalMove(board: Board, history: GameHistory, turn: Color, from: Square, to: Square): MoveResult =
+  /** Thin I/O shell: renders the board, reads a line, delegates to processMove,
-    val castleOpt              = Option.when(MoveValidator.isCastle(board, from, to))(MoveValidator.castleSide(from, to))
+   *  prints the outcome, and recurses until the game ends.
-    val isEP                   = EnPassantCalculator.isEnPassant(board, history, from, to)
+   */
-    val (newBoard, captured)   = castleOpt match
+  def gameLoop(ctx: GameContext, turn: Color): Unit =
-      case Some(side) => (board.withCastle(turn, side), None)
+    println()
-      case None =>
+    print(Renderer.render(ctx.board))
-        val (b, cap) = board.withMove(from, to)
+    println(s"${turn.label}'s turn. Enter move: ")
-        if isEP then
+    val input = Option(StdIn.readLine()).getOrElse("quit").trim
-          val capturedSq = EnPassantCalculator.capturedPawnSquare(to, turn)
+    processMove(ctx, turn, input) match
-          (b.removed(capturedSq), board.pieceAt(capturedSq))
+      case MoveResult.Quit =>
-        else (b, cap)
+        println("Game over. Goodbye!")
-    val pieceType   = board.pieceAt(from).map(_.pieceType).getOrElse(PieceType.Pawn)
+      case MoveResult.InvalidFormat(raw) =>
-    val wasPawnMove = pieceType == PieceType.Pawn
+        println(s"Invalid move format '$raw'. Use coordinate notation, e.g. e2e4.")
-    val wasCapture  = captured.isDefined
+        gameLoop(ctx, turn)
-    val newHistory  = history.addMove(from, to, castleOpt, wasPawnMove = wasPawnMove, wasCapture = wasCapture, pieceType = pieceType)
+      case MoveResult.NoPiece =>
-    toMoveResult(newBoard, newHistory, captured, turn)
+        println(s"No piece on ${Parser.parseMove(input).map(_._1).fold("?")(_.toString)}.")
-
+        gameLoop(ctx, turn)
-  private def toMoveResult(newBoard: Board, newHistory: GameHistory, captured: Option[Piece], turn: Color): MoveResult =
+      case MoveResult.WrongColor =>
-    GameRules.gameStatus(newBoard, newHistory, turn.opposite) match
+        println(s"That is not your piece.")
-      case PositionStatus.Normal  => MoveResult.Moved(newBoard, newHistory, captured, turn.opposite)
+        gameLoop(ctx, turn)
-      case PositionStatus.InCheck => MoveResult.MovedInCheck(newBoard, newHistory, captured, turn.opposite)
+      case MoveResult.IllegalMove =>
-      case PositionStatus.Mated   => MoveResult.Checkmate(turn)
+        println(s"Illegal move.")
-      case PositionStatus.Drawn   => MoveResult.Stalemate
+        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(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(newCtx, newTurn)
+      case MoveResult.Checkmate(winner) =>
+        println(s"Checkmate! ${winner.label} wins.")
+        gameLoop(GameContext.initial, Color.White)
+      case MoveResult.Stalemate =>
+        println("Stalemate! The game is a draw.")
+        gameLoop(GameContext.initial, Color.White)

modules/core/src/main/scala/de/nowchess/chess/engine/GameEngine.scala

@@ -1,352 +0,0 @@
-package de.nowchess.chess.engine
-
-import de.nowchess.api.board.{Board, Color, Piece, Square}
-import de.nowchess.api.move.PromotionPiece
-import de.nowchess.chess.logic.{GameHistory, GameRules, PositionStatus}
-import de.nowchess.chess.controller.{GameController, Parser, MoveResult}
-import de.nowchess.chess.observer.*
-import de.nowchess.chess.command.{CommandInvoker, MoveCommand}
-import de.nowchess.chess.notation.{PgnExporter, PgnParser}
-
-/** Pure game engine that manages game state and notifies observers of state changes.
- *  This class is the single source of truth for the game state.
- *  All user interactions must go through this engine via Commands, and all state changes
- *  are communicated to observers via GameEvent notifications.
- */
-class GameEngine(
-  initialBoard: Board = Board.initial,
-  initialHistory: GameHistory = GameHistory.empty,
-  initialTurn: Color = Color.White,
-  completePromotionFn: (Board, GameHistory, Square, Square, PromotionPiece, Color) => MoveResult =
-    GameController.completePromotion
-) extends Observable:
-  private var currentBoard: Board = initialBoard
-  private var currentHistory: GameHistory = initialHistory
-  private var currentTurn: Color = initialTurn
-  private val invoker = new CommandInvoker()
-
-  /** Inner class for tracking pending promotion state */
-  private case class PendingPromotion(
-    from: Square, to: Square,
-    boardBefore: Board, historyBefore: GameHistory,
-    turn: Color
-  )
-
-  /** Current pending promotion, if any */
-  private var pendingPromotion: Option[PendingPromotion] = None
-
-  /** True if a pawn promotion move is pending and needs a piece choice. */
-  def isPendingPromotion: Boolean = synchronized { pendingPromotion.isDefined }
-
-  // Synchronized accessors for current state
-  def board: Board = synchronized { currentBoard }
-  def history: GameHistory = synchronized { currentHistory }
-  def turn: Color = synchronized { currentTurn }
-
-  /** Check if undo is available. */
-  def canUndo: Boolean = synchronized { invoker.canUndo }
-
-  /** Check if redo is available. */
-  def canRedo: Boolean = synchronized { invoker.canRedo }
-
-  /** Get the command history for inspection (testing/debugging). */
-  def commandHistory: List[de.nowchess.chess.command.Command] = synchronized { invoker.history }
-
-  /** Process a raw move input string and update game state if valid.
-   *  Notifies all observers of the outcome via GameEvent.
-   */
-  def processUserInput(rawInput: String): Unit = synchronized {
-    val trimmed = rawInput.trim.toLowerCase
-    trimmed match
-      case "quit" | "q" =>
-        // Client should handle quit logic; we just return
-        ()
-
-      case "undo" =>
-        performUndo()
-
-      case "redo" =>
-        performRedo()
-
-      case "draw" =>
-        if currentHistory.halfMoveClock >= 100 then
-          currentBoard   = Board.initial
-          currentHistory = GameHistory.empty
-          currentTurn    = Color.White
-          invoker.clear()
-          notifyObservers(DrawClaimedEvent(currentBoard, currentHistory, currentTurn))
-        else
-          notifyObservers(InvalidMoveEvent(
-            currentBoard, currentHistory, currentTurn,
-            "Draw cannot be claimed: the 50-move rule has not been triggered."
-          ))
-
-      case "" =>
-        val event = InvalidMoveEvent(
-          currentBoard,
-          currentHistory,
-          currentTurn,
-          "Please enter a valid move or command."
-        )
-        notifyObservers(event)
-
-      case moveInput =>
-        Parser.parseMove(moveInput) match
-          case None =>
-            notifyObservers(InvalidMoveEvent(
-              currentBoard, currentHistory, currentTurn,
-              s"Invalid move format '$moveInput'. Use coordinate notation, e.g. e2e4."
-            ))
-          case Some((from, to)) =>
-            handleParsedMove(from, to, moveInput)
-  }
-
-  private def handleParsedMove(from: Square, to: Square, moveInput: String): Unit =
-    val cmd = MoveCommand(
-      from = from,
-      to = to,
-      previousBoard = Some(currentBoard),
-      previousHistory = Some(currentHistory),
-      previousTurn = Some(currentTurn)
-    )
-    GameController.processMove(currentBoard, currentHistory, currentTurn, moveInput) match
-      case MoveResult.InvalidFormat(_) | MoveResult.NoPiece | MoveResult.WrongColor | MoveResult.IllegalMove | MoveResult.Quit =>
-        handleFailedMove(moveInput)
-
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
-        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
-        invoker.execute(updatedCmd)
-        updateGameState(newBoard, newHistory, newTurn)
-        emitMoveEvent(from.toString, to.toString, captured, newTurn)
-        if currentHistory.halfMoveClock >= 100 then
-          notifyObservers(FiftyMoveRuleAvailableEvent(currentBoard, currentHistory, currentTurn))
-
-      case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
-        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
-        invoker.execute(updatedCmd)
-        updateGameState(newBoard, newHistory, newTurn)
-        emitMoveEvent(from.toString, to.toString, captured, newTurn)
-        notifyObservers(CheckDetectedEvent(currentBoard, currentHistory, currentTurn))
-        if currentHistory.halfMoveClock >= 100 then
-          notifyObservers(FiftyMoveRuleAvailableEvent(currentBoard, currentHistory, currentTurn))
-
-      case MoveResult.Checkmate(winner) =>
-        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
-        invoker.execute(updatedCmd)
-        currentBoard = Board.initial
-        currentHistory = GameHistory.empty
-        currentTurn = Color.White
-        notifyObservers(CheckmateEvent(currentBoard, currentHistory, currentTurn, winner))
-
-      case MoveResult.Stalemate =>
-        val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
-        invoker.execute(updatedCmd)
-        currentBoard = Board.initial
-        currentHistory = GameHistory.empty
-        currentTurn = Color.White
-        notifyObservers(StalemateEvent(currentBoard, currentHistory, currentTurn))
-
-      case MoveResult.PromotionRequired(promFrom, promTo, boardBefore, histBefore, _, promotingTurn) =>
-        pendingPromotion = Some(PendingPromotion(promFrom, promTo, boardBefore, histBefore, promotingTurn))
-        notifyObservers(PromotionRequiredEvent(currentBoard, currentHistory, currentTurn, promFrom, promTo))
-
-  /** Undo the last move. */
-  def undo(): Unit = synchronized {
-    performUndo()
-  }
-
-  /** Redo the last undone move. */
-  def redo(): Unit = synchronized {
-    performRedo()
-  }
-
-  /** Apply a player's promotion piece choice.
-   *  Must only be called when isPendingPromotion is true.
-   */
-  def completePromotion(piece: PromotionPiece): Unit = synchronized {
-    pendingPromotion match
-      case None =>
-        notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "No promotion pending."))
-      case Some(pending) =>
-        pendingPromotion = None
-        val cmd = MoveCommand(
-          from = pending.from,
-          to = pending.to,
-          previousBoard = Some(pending.boardBefore),
-          previousHistory = Some(pending.historyBefore),
-          previousTurn = Some(pending.turn)
-        )
-        completePromotionFn(
-          pending.boardBefore, pending.historyBefore,
-          pending.from, pending.to, piece, pending.turn
-        ) match
-          case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
-            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
-            invoker.execute(updatedCmd)
-            updateGameState(newBoard, newHistory, newTurn)
-            emitMoveEvent(pending.from.toString, pending.to.toString, captured, newTurn)
-
-          case MoveResult.MovedInCheck(newBoard, newHistory, captured, newTurn) =>
-            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(newBoard, newHistory, newTurn, captured)))
-            invoker.execute(updatedCmd)
-            updateGameState(newBoard, newHistory, newTurn)
-            emitMoveEvent(pending.from.toString, pending.to.toString, captured, newTurn)
-            notifyObservers(CheckDetectedEvent(currentBoard, currentHistory, currentTurn))
-
-          case MoveResult.Checkmate(winner) =>
-            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
-            invoker.execute(updatedCmd)
-            currentBoard = Board.initial
-            currentHistory = GameHistory.empty
-            currentTurn = Color.White
-            notifyObservers(CheckmateEvent(currentBoard, currentHistory, currentTurn, winner))
-
-          case MoveResult.Stalemate =>
-            val updatedCmd = cmd.copy(moveResult = Some(de.nowchess.chess.command.MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)))
-            invoker.execute(updatedCmd)
-            currentBoard = Board.initial
-            currentHistory = GameHistory.empty
-            currentTurn = Color.White
-            notifyObservers(StalemateEvent(currentBoard, currentHistory, currentTurn))
-
-          case _ =>
-            notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "Error completing promotion."))
-  }
-
-  /** Validate and load a PGN string.
-   *  Each move is replayed through the command system so undo/redo is available after loading.
-   *  Returns Right(()) on success; Left(error) if any move is illegal or the position impossible. */
-  def loadPgn(pgn: String): Either[String, Unit] = synchronized {
-    PgnParser.validatePgn(pgn) match
-      case Left(err) =>
-        Left(err)
-      case Right(game) =>
-        val initialBoardBeforeLoad = currentBoard
-        val initialHistoryBeforeLoad = currentHistory
-        val initialTurnBeforeLoad = currentTurn
-        
-        currentBoard = Board.initial
-        currentHistory = GameHistory.empty
-        currentTurn = Color.White
-        pendingPromotion = None
-        invoker.clear()
-
-        var error: Option[String] = None
-        import scala.util.control.Breaks._
-        breakable {
-          game.moves.foreach { move =>
-            handleParsedMove(move.from, move.to, s"${move.from}${move.to}")
-            move.promotionPiece.foreach(completePromotion)
-            
-            // If the move failed to execute properly, stop and report
-            // (validatePgn should have caught this, but we're being safe)
-            if pendingPromotion.isDefined && move.promotionPiece.isEmpty then
-              error = Some(s"Promotion required for move ${move.from}${move.to}")
-              break()
-          }
-        }
-        
-        error match
-          case Some(err) =>
-            currentBoard = initialBoardBeforeLoad
-            currentHistory = initialHistoryBeforeLoad
-            currentTurn = initialTurnBeforeLoad
-            Left(err)
-          case None =>
-            notifyObservers(PgnLoadedEvent(currentBoard, currentHistory, currentTurn))
-            Right(())
-  }
-
-  /** Load an arbitrary board position, clearing all history and undo/redo state. */
-  def loadPosition(board: Board, history: GameHistory, turn: Color): Unit = synchronized {
-    currentBoard = board
-    currentHistory = history
-    currentTurn = turn
-    pendingPromotion = None
-    invoker.clear()
-    notifyObservers(BoardResetEvent(currentBoard, currentHistory, currentTurn))
-  }
-
-  /** Reset the board to initial position. */
-  def reset(): Unit = synchronized {
-    currentBoard = Board.initial
-    currentHistory = GameHistory.empty
-    currentTurn = Color.White
-    invoker.clear()
-    notifyObservers(BoardResetEvent(
-      currentBoard,
-      currentHistory,
-      currentTurn
-    ))
-  }
-
-  // ──── Private Helpers ────
-
-  private def performUndo(): Unit =
-    if invoker.canUndo then
-      val cmd = invoker.history(invoker.getCurrentIndex)
-      (cmd: @unchecked) match
-        case moveCmd: MoveCommand =>
-          val notation = currentHistory.moves.lastOption.map(PgnExporter.moveToAlgebraic).getOrElse("")
-          moveCmd.previousBoard.foreach(currentBoard = _)
-          moveCmd.previousHistory.foreach(currentHistory = _)
-          moveCmd.previousTurn.foreach(currentTurn = _)
-          invoker.undo()
-          notifyObservers(MoveUndoneEvent(currentBoard, currentHistory, currentTurn, notation))
-    else
-      notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "Nothing to undo."))
-
-  private def performRedo(): Unit =
-    if invoker.canRedo then
-      val cmd = invoker.history(invoker.getCurrentIndex + 1)
-      (cmd: @unchecked) match
-        case moveCmd: MoveCommand =>
-          for case de.nowchess.chess.command.MoveResult.Successful(nb, nh, nt, cap) <- moveCmd.moveResult do
-            updateGameState(nb, nh, nt)
-            invoker.redo()
-            val notation    = nh.moves.lastOption.map(PgnExporter.moveToAlgebraic).getOrElse("")
-            val capturedDesc = cap.map(c => s"${c.color.label} ${c.pieceType.label}")
-            notifyObservers(MoveRedoneEvent(currentBoard, currentHistory, currentTurn, notation, moveCmd.from.toString, moveCmd.to.toString, capturedDesc))
-    else
-      notifyObservers(InvalidMoveEvent(currentBoard, currentHistory, currentTurn, "Nothing to redo."))
-
-  private def updateGameState(newBoard: Board, newHistory: GameHistory, newTurn: Color): Unit =
-    currentBoard = newBoard
-    currentHistory = newHistory
-    currentTurn = newTurn
-
-  private def emitMoveEvent(fromSq: String, toSq: String, captured: Option[Piece], newTurn: Color): Unit =
-    val capturedDesc = captured.map(c => s"${c.color.label} ${c.pieceType.label}")
-    notifyObservers(MoveExecutedEvent(
-      currentBoard,
-      currentHistory,
-      newTurn,
-      fromSq,
-      toSq,
-      capturedDesc
-    ))
-
-  private def handleFailedMove(moveInput: String): Unit =
-    (GameController.processMove(currentBoard, currentHistory, currentTurn, moveInput): @unchecked) match
-      case MoveResult.NoPiece =>
-        notifyObservers(InvalidMoveEvent(
-          currentBoard,
-          currentHistory,
-          currentTurn,
-          "No piece on that square."
-        ))
-      case MoveResult.WrongColor =>
-        notifyObservers(InvalidMoveEvent(
-          currentBoard,
-          currentHistory,
-          currentTurn,
-          "That is not your piece."
-        ))
-      case MoveResult.IllegalMove =>
-        notifyObservers(InvalidMoveEvent(
-          currentBoard,
-          currentHistory,
-          currentTurn,
-          "Illegal move."
-        ))
-

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,49 +0,0 @@
-package de.nowchess.chess.logic
-
-import de.nowchess.api.board.{PieceType, Square}
-import de.nowchess.api.move.PromotionPiece
-
-/** 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],
-  promotionPiece: Option[PromotionPiece] = None,
-  pieceType: PieceType = PieceType.Pawn,
-  isCapture: Boolean = false
-)
-
-/** Complete game history: ordered list of moves plus the half-move clock for the 50-move rule.
- *
- *  @param moves         moves played so far, oldest first
- *  @param halfMoveClock plies since the last pawn move or capture (FIDE 50-move rule counter)
- */
-case class GameHistory(moves: List[HistoryMove] = List.empty, halfMoveClock: Int = 0):
-
-  /** Add a raw HistoryMove record. Clock increments by 1.
-   *  Use the coordinate overload when you know whether the move is a pawn move or capture.
-   */
-  def addMove(move: HistoryMove): GameHistory =
-    GameHistory(moves :+ move, halfMoveClock + 1)
-
-  /** Add a move by coordinates.
-   *
-   *  @param wasPawnMove true when the moving piece is a pawn — resets the clock to 0
-   *  @param wasCapture  true when a piece was captured (including en passant) — resets the clock to 0
-   *
-   *  If neither flag is set the clock increments by 1.
-   */
-  def addMove(
-    from: Square,
-    to: Square,
-    castleSide: Option[CastleSide] = None,
-    promotionPiece: Option[PromotionPiece] = None,
-    wasPawnMove: Boolean = false,
-    wasCapture: Boolean = false,
-    pieceType: PieceType = PieceType.Pawn
-  ): GameHistory =
-    val newClock = if wasPawnMove || wasCapture then 0 else halfMoveClock + 1
-    GameHistory(moves :+ HistoryMove(from, to, castleSide, promotionPiece, pieceType, wasCapture), newClock)
-
-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)] =
+  def legalMoves(ctx: GameContext, color: Color): Set[(Square, Square)] =
-    board.pieces
+    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
+              if MoveValidator.isCastle(ctx.board, from, to) then
-                board.withCastle(color, MoveValidator.castleSide(from, to))
+                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 =
+  def gameStatus(ctx: GameContext, color: Color): PositionStatus =
-    val moves   = legalMoves(board, history, color)
+    val moves   = legalMoves(ctx, color)
-    val inCheck = isInCheck(board, 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:
 
@@ -73,7 +73,7 @@ object MoveValidator:
     val fi       = from.file.ordinal
     val ri       = from.rank.ordinal
     val dir      = if color == Color.White then 1 else -1
-    val startRank = if color == Color.White then Rank.R2.ordinal else Rank.R7.ordinal
+    val startRank = if color == Color.White then 1 else 6  // R2 = ordinal 1, R7 = ordinal 6
 
     val oneStep = squareAt(fi, ri + dir)
 
@@ -126,58 +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] =
+  def castlingTargets(ctx: GameContext, color: Color): Set[Square] =
-    val rights = CastlingRightsCalculator.deriveCastlingRights(history, color)
+    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)) ||
+    if !ctx.board.pieceAt(kingSq).contains(Piece(color, PieceType.King)) ||
-       GameRules.isInCheck(board, color) then Set.empty
+       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)) &&
+        ctx.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)).forall(s => ctx.board.pieceAt(s).isEmpty) &&
-        !List(Square(File.F, rank), Square(File.G, rank)).exists(s => isAttackedBy(board, s, enemy))
+        !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)) &&
+        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 => board.pieceAt(s).isEmpty) &&
+        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(board, s, enemy))
+        !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] =
+  def legalTargets(ctx: GameContext, from: Square): Set[Square] =
-    board.pieceAt(from) match
+    ctx.board.pieceAt(from) match
       case Some(piece) if piece.pieceType == PieceType.King =>
-        legalTargets(board, from) ++ castlingTargets(board, history, piece.color)
+        legalTargets(ctx.board, from) ++ castlingTargets(ctx, piece.color)
-      case Some(piece) if piece.pieceType == PieceType.Pawn =>
-        pawnTargets(board, history, from, piece.color)
       case _ =>
-        legalTargets(board, from)
+        legalTargets(ctx.board, from)
 
-  private def pawnTargets(board: Board, history: GameHistory, from: Square, color: Color): Set[Square] =
+  def isLegal(ctx: GameContext, from: Square, to: Square): Boolean =
-    val existing = pawnTargets(board, from, color)
+    legalTargets(ctx, from).contains(to)
-    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)
-
-  /** Returns true if the piece on `from` is a pawn moving to its back rank (promotion). */
-  def isPromotionMove(board: Board, from: Square, to: Square): Boolean =
-    board.pieceAt(from) match
-      case Some(Piece(_, PieceType.Pawn)) =>
-        (from.rank == Rank.R7 && to.rank == Rank.R8) ||
-        (from.rank == Rank.R2 && to.rank == Rank.R1)
-      case _ => false

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,54 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.{PieceType, *}
-import de.nowchess.api.move.PromotionPiece
-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"
-
-      val termination = headers.getOrElse("Result", "*")
-      moveLines.mkString(" ") + s" $termination"
-
-    if headerLines.isEmpty then moveText
-    else if moveText.isEmpty then headerLines
-    else s"$headerLines\n\n$moveText"
-
-  /** Convert a HistoryMove to Standard Algebraic Notation. */
-  def moveToAlgebraic(move: HistoryMove): String =
-    move.castleSide match
-      case Some(CastleSide.Kingside)  => "O-O"
-      case Some(CastleSide.Queenside) => "O-O-O"
-      case None =>
-        val dest       = move.to.toString
-        val capStr     = if move.isCapture then "x" else ""
-        val promSuffix = move.promotionPiece match
-          case Some(PromotionPiece.Queen)  => "=Q"
-          case Some(PromotionPiece.Rook)   => "=R"
-          case Some(PromotionPiece.Bishop) => "=B"
-          case Some(PromotionPiece.Knight) => "=N"
-          case None                        => ""
-        move.pieceType match
-          case PieceType.Pawn =>
-            if move.isCapture then s"${move.from.file.toString.toLowerCase}x$dest$promSuffix"
-            else s"$dest$promSuffix"
-          case PieceType.Knight => s"N$capStr$dest$promSuffix"
-          case PieceType.Bishop => s"B$capStr$dest$promSuffix"
-          case PieceType.Rook   => s"R$capStr$dest$promSuffix"
-          case PieceType.Queen  => s"Q$capStr$dest$promSuffix"
-          case PieceType.King   => s"K$capStr$dest$promSuffix"

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

@@ -1,267 +0,0 @@
-package de.nowchess.chess.notation
-
-import de.nowchess.api.board.*
-import de.nowchess.api.move.PromotionPiece
-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:
-
-  /** Strictly validate a PGN text.
-   *  Returns Right(PgnGame) if every move token is a legal move in the evolving position.
-   *  Returns Left(error message) on the first illegal or impossible move, or any unrecognised token. */
-  def validatePgn(pgn: String): Either[String, PgnGame] =
-    val lines = pgn.split("\n").map(_.trim)
-    val (headerLines, rest) = lines.span(_.startsWith("["))
-    val headers  = parseHeaders(headerLines)
-    val moveText = rest.mkString(" ")
-    validateMovesText(moveText).map(moves => PgnGame(headers, moves))
-
-  /** 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   = applyMoveToBoard(board, move, color)
-              val newHistory = history.addMove(move)
-              (newBoard, newHistory, color.opposite, acc :+ move)
-
-    moves
-
-  /** Apply a single HistoryMove to a Board, handling castling and promotion. */
-  private def applyMoveToBoard(board: Board, move: HistoryMove, color: Color): Board =
-    move.castleSide match
-      case Some(side) => board.withCastle(color, side)
-      case None =>
-        val (boardAfterMove, _) = board.withMove(move.from, move.to)
-        move.promotionPiece match
-          case Some(pp) =>
-            val pieceType = pp match
-              case PromotionPiece.Queen  => PieceType.Queen
-              case PromotionPiece.Rook   => PieceType.Rook
-              case PromotionPiece.Bishop => PieceType.Bishop
-              case PromotionPiece.Knight => PieceType.Knight
-            boardAfterMove.updated(move.to, Piece(color, pieceType))
-          case None => boardAfterMove
-
-  /** 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), pieceType = PieceType.King))
-
-      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), pieceType = PieceType.King))
-
-      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))
-
-        val promotion     = extractPromotion(notation)
-        val movePieceType = requiredPieceType.getOrElse(PieceType.Pawn)
-        val moveIsCapture = notation.contains('x')
-        disambiguated.headOption.map(from => HistoryMove(from, toSquare, None, promotion, movePieceType, moveIsCapture))
-
-  /** True if `sq` matches a disambiguation hint (file letter, rank digit, or both). */
-  private def matchesHint(sq: Square, hint: String): Boolean =
-    hint.forall(c => 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)
-
-  /** Extract a promotion piece from a notation string containing =Q/=R/=B/=N. */
-  private[notation] def extractPromotion(notation: String): Option[PromotionPiece] =
-    val promotionPattern = """=([A-Z])""".r
-    promotionPattern.findFirstMatchIn(notation).flatMap { m =>
-      m.group(1) match
-        case "Q" => Some(PromotionPiece.Queen)
-        case "R" => Some(PromotionPiece.Rook)
-        case "B" => Some(PromotionPiece.Bishop)
-        case "N" => Some(PromotionPiece.Knight)
-        case _   => None
-    }
-
-  /** 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
-
-  // ── Strict validation helpers ─────────────────────────────────────────────
-
-  /** Walk all move tokens, failing immediately on any unresolvable or illegal move. */
-  private def validateMovesText(moveText: String): Either[String, List[HistoryMove]] =
-    val tokens = moveText.split("\\s+").filter(_.nonEmpty)
-    tokens.foldLeft(Right((Board.initial, GameHistory.empty, Color.White, List.empty[HistoryMove])): Either[String, (Board, GameHistory, Color, List[HistoryMove])]) {
-      case (acc, token) =>
-        acc.flatMap { case (board, history, color, moves) =>
-          if isMoveNumberOrResult(token) then Right((board, history, color, moves))
-          else
-            strictParseAlgebraicMove(token, board, history, color) match
-              case None       => Left(s"Illegal or impossible move: '$token'")
-              case Some(move) =>
-                val newBoard   = applyMoveToBoard(board, move, color)
-                val newHistory = history.addMove(move)
-                Right((newBoard, newHistory, color.opposite, moves :+ move))
-        }
-    }.map(_._4)
-
-  /** Strict algebraic move parse — no fallback to positionally-illegal moves. */
-  private def strictParseAlgebraicMove(notation: String, board: Board, history: GameHistory, color: Color): Option[HistoryMove] =
-    val rank = if color == Color.White then Rank.R1 else Rank.R8
-    notation match
-      case "O-O" | "O-O+" | "O-O#" =>
-        val dest = Square(File.G, rank)
-        Option.when(MoveValidator.castlingTargets(board, history, color).contains(dest))(
-          HistoryMove(Square(File.E, rank), dest, Some(CastleSide.Kingside), pieceType = PieceType.King)
-        )
-      case "O-O-O" | "O-O-O+" | "O-O-O#" =>
-        val dest = Square(File.C, rank)
-        Option.when(MoveValidator.castlingTargets(board, history, color).contains(dest))(
-          HistoryMove(Square(File.E, rank), dest, Some(CastleSide.Queenside), pieceType = PieceType.King)
-        )
-      case _ =>
-        strictParseRegularMove(notation, board, history, color)
-
-  /** Strict regular move parse — uses only legally reachable squares, no fallback. */
-  private def strictParseRegularMove(notation: String, board: Board, history: GameHistory, color: Color): Option[HistoryMove] =
-    val clean = notation
-      .replace("+", "")
-      .replace("#", "")
-      .replace("x", "")
-      .replaceAll("=[NBRQ]$", "")
-
-    if clean.length < 2 then None
-    else
-      val destStr = clean.takeRight(2)
-      Square.fromAlgebraic(destStr).flatMap { toSquare =>
-        val disambig = clean.dropRight(2)
-
-        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)
-
-        val hint =
-          if disambig.nonEmpty && disambig.head.isUpper then disambig.tail
-          else disambig
-
-        // Strict: only squares from which a legal move (including en passant/castling awareness) exists.
-        val reachable: Set[Square] =
-          board.pieces.collect {
-            case (from, piece) if piece.color == color &&
-              MoveValidator.legalTargets(board, history, from).contains(toSquare) => from
-          }.toSet
-
-        val byPiece = reachable.filter(from =>
-          requiredPieceType.forall(pt => board.pieceAt(from).exists(_.pieceType == pt))
-        )
-
-        val disambiguated =
-          if hint.isEmpty then byPiece
-          else byPiece.filter(from => matchesHint(from, hint))
-
-        val promotion     = extractPromotion(notation)
-        val movePieceType = requiredPieceType.getOrElse(PieceType.Pawn)
-        val moveIsCapture = notation.contains('x')
-        disambiguated.headOption.map(from => HistoryMove(from, toSquare, None, promotion, movePieceType, moveIsCapture))
-      }

modules/core/src/main/scala/de/nowchess/chess/observer/Observer.scala

@@ -1,136 +0,0 @@
-package de.nowchess.chess.observer
-
-import de.nowchess.api.board.{Board, Color, Square}
-import de.nowchess.chess.logic.GameHistory
-
-/** Base trait for all game state events.
- *  Events are immutable snapshots of game state changes.
- */
-sealed trait GameEvent:
-  def board: Board
-  def history: GameHistory
-  def turn: Color
-
-/** Fired when a move is successfully executed. */
-case class MoveExecutedEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color,
-  fromSquare: String,
-  toSquare: String,
-  capturedPiece: Option[String]
-) extends GameEvent
-
-/** Fired when the current player is in check. */
-case class CheckDetectedEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color
-) extends GameEvent
-
-/** Fired when the game reaches checkmate. */
-case class CheckmateEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color,
-  winner: Color
-) extends GameEvent
-
-/** Fired when the game reaches stalemate. */
-case class StalemateEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color
-) extends GameEvent
-
-/** Fired when a move is invalid. */
-case class InvalidMoveEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color,
-  reason: String
-) extends GameEvent
-
-/** Fired when a pawn reaches the back rank and the player must choose a promotion piece. */
-case class PromotionRequiredEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color,
-  from: Square,
-  to: Square
-) extends GameEvent
-
-/** Fired when the board is reset. */
-case class BoardResetEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color
-) extends GameEvent
-
-/** Fired after any move where the half-move clock reaches 100 — the 50-move rule is now claimable. */
-case class FiftyMoveRuleAvailableEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color
-) extends GameEvent
-
-/** Fired when a player successfully claims a draw under the 50-move rule. */
-case class DrawClaimedEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color
-) extends GameEvent
-
-/** Fired when a move is undone, carrying PGN notation of the reversed move. */
-case class MoveUndoneEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color,
-  pgnNotation: String
-) extends GameEvent
-
-/** Fired when a previously undone move is redone, carrying PGN notation of the replayed move. */
-case class MoveRedoneEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color,
-  pgnNotation: String,
-  fromSquare: String,
-  toSquare: String,
-  capturedPiece: Option[String]
-) extends GameEvent
-
-/** Fired after a PGN string is successfully loaded and all moves are replayed into history. */
-case class PgnLoadedEvent(
-  board: Board,
-  history: GameHistory,
-  turn: Color
-) extends GameEvent
-
-/** Observer trait: implement to receive game state updates. */
-trait Observer:
-  def onGameEvent(event: GameEvent): Unit
-
-/** Observable trait: manages observers and notifies them of events. */
-trait Observable:
-  private val observers = scala.collection.mutable.Set[Observer]()
-
-  /** Register an observer to receive game events. */
-  def subscribe(observer: Observer): Unit = synchronized {
-    observers += observer
-  }
-
-  /** Unregister an observer. */
-  def unsubscribe(observer: Observer): Unit = synchronized {
-    observers -= observer
-  }
-
-  /** Notify all observers of a game event. */
-  protected def notifyObservers(event: GameEvent): Unit = synchronized {
-    observers.foreach(_.onGameEvent(event))
-  }
-
-  /** Return current list of observers (for testing). */
-  def observerCount: Int = synchronized {
-    observers.size
-  }

modules/core/src/test/scala/de/nowchess/chess/command/CommandInvokerBranchTest.scala

@@ -1,216 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Square, File, Rank, Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class CommandInvokerBranchTest extends AnyFunSuite with Matchers:
-  
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  // ──── Helper: Command that always fails ────
-  private case class FailingCommand() extends Command:
-    override def execute(): Boolean = false
-    override def undo(): Boolean = false
-    override def description: String = "Failing command"
-
-  // ──── Helper: Command that conditionally fails on undo or execute ────
-  private case class ConditionalFailCommand(var shouldFailOnUndo: Boolean = false, var shouldFailOnExecute: Boolean = false) extends Command:
-    override def execute(): Boolean = !shouldFailOnExecute
-    override def undo(): Boolean = !shouldFailOnUndo
-    override def description: String = "Conditional fail"
-
-  private def createMoveCommand(from: Square, to: Square, executeSucceeds: Boolean = true): MoveCommand =
-    val cmd = MoveCommand(
-      from = from,
-      to = to,
-      moveResult = if executeSucceeds then Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)) else None,
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-    cmd
-
-  // ──── BRANCH: execute() returns false ────
-  test("CommandInvoker.execute() with failing command returns false"):
-    val invoker = new CommandInvoker()
-    val cmd = FailingCommand()
-    invoker.execute(cmd) shouldBe false
-    invoker.history.size shouldBe 0
-    invoker.getCurrentIndex shouldBe -1
-
-  test("CommandInvoker.execute() does not add failed command to history"):
-    val invoker = new CommandInvoker()
-    val failingCmd = FailingCommand()
-    val successCmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    
-    invoker.execute(failingCmd) shouldBe false
-    invoker.history.size shouldBe 0
-    
-    invoker.execute(successCmd) shouldBe true
-    invoker.history.size shouldBe 1
-    invoker.history(0) shouldBe successCmd
-
-  // ──── BRANCH: undo() with invalid index (currentIndex < 0) ────
-  test("CommandInvoker.undo() returns false when currentIndex < 0"):
-    val invoker = new CommandInvoker()
-    // currentIndex starts at -1
-    invoker.undo() shouldBe false
-
-  test("CommandInvoker.undo() returns false when empty history"):
-    val invoker = new CommandInvoker()
-    invoker.canUndo shouldBe false
-    invoker.undo() shouldBe false
-
-  // ──── BRANCH: undo() with invalid index (currentIndex >= size) ────
-  test("CommandInvoker.undo() returns false when currentIndex >= history size"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    // currentIndex now = 1, history.size = 2
-    
-    invoker.undo()  // currentIndex becomes 0
-    invoker.undo()  // currentIndex becomes -1
-    invoker.undo()  // currentIndex still -1, should fail
-
-  // ──── BRANCH: undo() command returns false ────
-  test("CommandInvoker.undo() returns false when command.undo() fails"):
-    val invoker = new CommandInvoker()
-    val failingCmd = ConditionalFailCommand(shouldFailOnUndo = true)
-    
-    invoker.execute(failingCmd) shouldBe true
-    invoker.canUndo shouldBe true
-    
-    invoker.undo() shouldBe false
-    // Index should not change when undo fails
-    invoker.getCurrentIndex shouldBe 0
-
-  test("CommandInvoker.undo() returns true when command.undo() succeeds"):
-    val invoker = new CommandInvoker()
-    val successCmd = ConditionalFailCommand(shouldFailOnUndo = false)
-    
-    invoker.execute(successCmd) shouldBe true
-    invoker.undo() shouldBe true
-    invoker.getCurrentIndex shouldBe -1
-
-  // ──── BRANCH: redo() with invalid index (currentIndex + 1 >= size) ────
-  test("CommandInvoker.redo() returns false when nothing to redo"):
-    val invoker = new CommandInvoker()
-    invoker.redo() shouldBe false
-
-  test("CommandInvoker.redo() returns false when at end of history"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    
-    invoker.execute(cmd)
-    // currentIndex = 0, history.size = 1
-    invoker.canRedo shouldBe false
-    invoker.redo() shouldBe false
-
-  test("CommandInvoker.redo() returns false when currentIndex + 1 >= size"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    // currentIndex = 1, size = 2, currentIndex + 1 = 2, so 2 < 2 is false
-    invoker.canRedo shouldBe false
-    invoker.redo() shouldBe false
-
-  // ──── BRANCH: redo() command returns false ────
-  test("CommandInvoker.redo() returns false when command.execute() fails"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val redoFailCmd = ConditionalFailCommand(shouldFailOnExecute = false)  // Succeeds on first execute
-    
-    invoker.execute(cmd1)
-    invoker.execute(redoFailCmd)  // Succeeds and added to history
-    
-    invoker.undo()
-    // currentIndex = 0, redoFailCmd is at index 1
-    invoker.canRedo shouldBe true
-    
-    // Now modify to fail on next execute (redo)
-    redoFailCmd.shouldFailOnExecute = true
-    invoker.redo() shouldBe false
-    // currentIndex should not change
-    invoker.getCurrentIndex shouldBe 0
-
-  test("CommandInvoker.redo() returns true when command.execute() succeeds"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    
-    invoker.execute(cmd) shouldBe true
-    invoker.undo() shouldBe true
-    invoker.redo() shouldBe true
-    invoker.getCurrentIndex shouldBe 0
-
-  // ──── BRANCH: execute() with redo history discarding (while loop) ────
-  test("CommandInvoker.execute() discards redo history via while loop"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    val cmd3 = createMoveCommand(sq(File.D, Rank.R2), sq(File.D, Rank.R4))
-    
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    // currentIndex = 1, size = 2
-    
-    invoker.undo()
-    // currentIndex = 0, size = 2
-    // Redo history exists: cmd2 is at index 1
-    invoker.canRedo shouldBe true
-    
-    invoker.execute(cmd3)
-    // while loop should discard cmd2
-    invoker.canRedo shouldBe false
-    invoker.history.size shouldBe 2
-    invoker.history(1) shouldBe cmd3
-
-  test("CommandInvoker.execute() discards multiple redo commands"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    val cmd3 = createMoveCommand(sq(File.G, Rank.R1), sq(File.F, Rank.R3))
-    val cmd4 = createMoveCommand(sq(File.D, Rank.R2), sq(File.D, Rank.R4))
-    
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    invoker.execute(cmd3)
-    invoker.execute(cmd4)
-    // currentIndex = 3, size = 4
-    
-    invoker.undo()
-    invoker.undo()
-    // currentIndex = 1, size = 4
-    // Redo history: cmd3 (idx 2), cmd4 (idx 3)
-    invoker.canRedo shouldBe true
-    
-    val newCmd = createMoveCommand(sq(File.B, Rank.R2), sq(File.B, Rank.R4))
-    invoker.execute(newCmd)
-    // While loop should discard indices 2 and 3 (cmd3 and cmd4)
-    invoker.history.size shouldBe 3
-    invoker.canRedo shouldBe false
-
-  // ──── BRANCH: execute() with no redo history to discard ────
-  test("CommandInvoker.execute() with no redo history (while condition false)"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    // currentIndex = 1, size = 2
-    // currentIndex < size - 1 is 1 < 1 which is false, so while loop doesn't run
-    
-    invoker.canRedo shouldBe false
-    
-    val cmd3 = createMoveCommand(sq(File.D, Rank.R2), sq(File.D, Rank.R4))
-    invoker.execute(cmd3)  // While loop condition should be false, no iterations
-    invoker.history.size shouldBe 3
-

modules/core/src/test/scala/de/nowchess/chess/command/CommandInvokerTest.scala

@@ -1,123 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Square, File, Rank, Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class CommandInvokerTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-  
-  private def createMoveCommand(from: Square, to: Square): MoveCommand =
-    MoveCommand(
-      from = from,
-      to = to,
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)),
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-
-  test("CommandInvoker executes a command and adds it to history"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd) shouldBe true
-    invoker.history.size shouldBe 1
-    invoker.getCurrentIndex shouldBe 0
-
-  test("CommandInvoker executes multiple commands in sequence"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    invoker.execute(cmd1) shouldBe true
-    invoker.execute(cmd2) shouldBe true
-    invoker.history.size shouldBe 2
-    invoker.getCurrentIndex shouldBe 1
-
-  test("CommandInvoker.canUndo returns false when empty"):
-    val invoker = new CommandInvoker()
-    invoker.canUndo shouldBe false
-
-  test("CommandInvoker.canUndo returns true after execution"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd)
-    invoker.canUndo shouldBe true
-
-  test("CommandInvoker.undo decrements current index"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd)
-    invoker.getCurrentIndex shouldBe 0
-    invoker.undo() shouldBe true
-    invoker.getCurrentIndex shouldBe -1
-
-  test("CommandInvoker.canRedo returns true after undo"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd)
-    invoker.undo()
-    invoker.canRedo shouldBe true
-
-  test("CommandInvoker.redo re-executes a command"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd)
-    invoker.undo() shouldBe true
-    invoker.redo() shouldBe true
-    invoker.getCurrentIndex shouldBe 0
-
-  test("CommandInvoker.canUndo returns false when at beginning"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd)
-    invoker.undo()
-    invoker.canUndo shouldBe false
-
-  test("CommandInvoker clear removes all history"):
-    val invoker = new CommandInvoker()
-    val cmd = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    invoker.execute(cmd)
-    invoker.clear()
-    invoker.history.size shouldBe 0
-    invoker.getCurrentIndex shouldBe -1
-
-  test("CommandInvoker discards all history when executing after undoing all"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    val cmd3 = createMoveCommand(sq(File.D, Rank.R2), sq(File.D, Rank.R4))
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    invoker.undo()
-    invoker.undo()
-    // After undoing twice, we're at the beginning (before any commands)
-    invoker.getCurrentIndex shouldBe -1
-    invoker.canRedo shouldBe true
-    // Executing a new command from the beginning discards all redo history
-    invoker.execute(cmd3)
-    invoker.canRedo shouldBe false
-    invoker.history.size shouldBe 1
-    invoker.history(0) shouldBe cmd3
-    invoker.getCurrentIndex shouldBe 0
-
-  test("CommandInvoker discards redo history when executing mid-history"):
-    val invoker = new CommandInvoker()
-    val cmd1 = createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4))
-    val cmd2 = createMoveCommand(sq(File.E, Rank.R7), sq(File.E, Rank.R5))
-    val cmd3 = createMoveCommand(sq(File.D, Rank.R2), sq(File.D, Rank.R4))
-    invoker.execute(cmd1)
-    invoker.execute(cmd2)
-    invoker.undo()
-    // After one undo, we're at the end of cmd1
-    invoker.getCurrentIndex shouldBe 0
-    invoker.canRedo shouldBe true
-    // Executing a new command discards cmd2 (the redo history)
-    invoker.execute(cmd3)
-    invoker.canRedo shouldBe false
-    invoker.history.size shouldBe 2
-    invoker.history(0) shouldBe cmd1
-    invoker.history(1) shouldBe cmd3
-    invoker.getCurrentIndex shouldBe 1
-

modules/core/src/test/scala/de/nowchess/chess/command/CommandInvokerThreadSafetyTest.scala

@@ -1,131 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Square, File, Rank, Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-import scala.collection.mutable
-
-class CommandInvokerThreadSafetyTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  private def createMoveCommand(from: Square, to: Square): MoveCommand =
-    MoveCommand(
-      from = from,
-      to = to,
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)),
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-
-  test("CommandInvoker is thread-safe for concurrent execute and history reads"):
-    val invoker = new CommandInvoker()
-    @volatile var raceDetected = false
-    val exceptions = mutable.ListBuffer[Exception]()
-
-    // Thread 1: executes commands
-    val executorThread = new Thread(new Runnable {
-      def run(): Unit = {
-        try {
-          for i <- 1 to 1000 do
-            val cmd = createMoveCommand(
-              sq(File.E, Rank.R2),
-              sq(File.E, Rank.R4)
-            )
-            invoker.execute(cmd)
-        } catch {
-          case e: Exception =>
-            exceptions += e
-            raceDetected = true
-        }
-      }
-    })
-
-    // Thread 2: reads history during execution
-    val readerThread = new Thread(new Runnable {
-      def run(): Unit = {
-        try {
-          for _ <- 1 to 1000 do
-            val _ = invoker.history
-            val _ = invoker.getCurrentIndex
-            Thread.sleep(0) // Yield to increase contention
-        } catch {
-          case e: Exception =>
-            exceptions += e
-            raceDetected = true
-        }
-      }
-    })
-
-    executorThread.start()
-    readerThread.start()
-    executorThread.join()
-    readerThread.join()
-
-    exceptions.isEmpty shouldBe true
-    raceDetected shouldBe false
-
-  test("CommandInvoker is thread-safe for concurrent execute, undo, and redo"):
-    val invoker = new CommandInvoker()
-    @volatile var raceDetected = false
-    val exceptions = mutable.ListBuffer[Exception]()
-
-    // Pre-populate with some commands
-    for _ <- 1 to 5 do
-      invoker.execute(createMoveCommand(sq(File.E, Rank.R2), sq(File.E, Rank.R4)))
-
-    // Thread 1: executes new commands
-    val executorThread = new Thread(new Runnable {
-      def run(): Unit = {
-        try {
-          for _ <- 1 to 500 do
-            invoker.execute(createMoveCommand(sq(File.D, Rank.R2), sq(File.D, Rank.R4)))
-        } catch {
-          case e: Exception =>
-            exceptions += e
-            raceDetected = true
-        }
-      }
-    })
-
-    // Thread 2: undoes commands
-    val undoThread = new Thread(new Runnable {
-      def run(): Unit = {
-        try {
-          for _ <- 1 to 500 do
-            if invoker.canUndo then
-              invoker.undo()
-        } catch {
-          case e: Exception =>
-            exceptions += e
-            raceDetected = true
-        }
-      }
-    })
-
-    // Thread 3: redoes commands
-    val redoThread = new Thread(new Runnable {
-      def run(): Unit = {
-        try {
-          for _ <- 1 to 500 do
-            if invoker.canRedo then
-              invoker.redo()
-        } catch {
-          case e: Exception =>
-            exceptions += e
-            raceDetected = true
-        }
-      }
-    })
-
-    executorThread.start()
-    undoThread.start()
-    redoThread.start()
-    executorThread.join()
-    undoThread.join()
-    redoThread.join()
-
-    exceptions.isEmpty shouldBe true
-    raceDetected shouldBe false

modules/core/src/test/scala/de/nowchess/chess/command/CommandTest.scala

@@ -1,52 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class CommandTest extends AnyFunSuite with Matchers:
-
-  test("QuitCommand can be created"):
-    val cmd = QuitCommand()
-    cmd shouldNot be(null)
-
-  test("QuitCommand execute returns true"):
-    val cmd = QuitCommand()
-    cmd.execute() shouldBe true
-
-  test("QuitCommand undo returns false (cannot undo quit)"):
-    val cmd = QuitCommand()
-    cmd.undo() shouldBe false
-
-  test("QuitCommand description"):
-    val cmd = QuitCommand()
-    cmd.description shouldBe "Quit game"
-
-  test("ResetCommand with no prior state"):
-    val cmd = ResetCommand()
-    cmd.execute() shouldBe true
-    cmd.undo() shouldBe false
-
-  test("ResetCommand with prior state can undo"):
-    val cmd = ResetCommand(
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-    cmd.execute() shouldBe true
-    cmd.undo() shouldBe true
-
-  test("ResetCommand with partial state cannot undo"):
-    val cmd = ResetCommand(
-      previousBoard = Some(Board.initial),
-      previousHistory = None,  // missing
-      previousTurn = Some(Color.White)
-    )
-    cmd.execute() shouldBe true
-    cmd.undo() shouldBe false
-
-  test("ResetCommand description"):
-    val cmd = ResetCommand()
-    cmd.description shouldBe "Reset board"
-

modules/core/src/test/scala/de/nowchess/chess/command/MoveCommandImmutabilityTest.scala

@@ -1,65 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Square, File, Rank, Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class MoveCommandImmutabilityTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  test("MoveCommand should be immutable - fields cannot be mutated after creation"):
-    val cmd1 = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4)
-    )
-
-    // Create second command with filled state
-    val result = MoveResult.Successful(Board.initial, GameHistory.empty, Color.Black, None)
-    val cmd2 = cmd1.copy(
-      moveResult = Some(result),
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-
-    // Original should be unchanged
-    cmd1.moveResult shouldBe None
-    cmd1.previousBoard shouldBe None
-    cmd1.previousHistory shouldBe None
-    cmd1.previousTurn shouldBe None
-
-    // New should have values
-    cmd2.moveResult shouldBe Some(result)
-    cmd2.previousBoard shouldBe Some(Board.initial)
-    cmd2.previousHistory shouldBe Some(GameHistory.empty)
-    cmd2.previousTurn shouldBe Some(Color.White)
-
-  test("MoveCommand equals and hashCode respect immutability"):
-    val cmd1 = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = None,
-      previousBoard = None,
-      previousHistory = None,
-      previousTurn = None
-    )
-
-    val cmd2 = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = None,
-      previousBoard = None,
-      previousHistory = None,
-      previousTurn = None
-    )
-
-    // Same values should be equal
-    cmd1 shouldBe cmd2
-    cmd1.hashCode shouldBe cmd2.hashCode
-
-    // Hash should be consistent (required for use as map keys)
-    val hash1 = cmd1.hashCode
-    val hash2 = cmd1.hashCode
-    hash1 shouldBe hash2

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

@@ -2,525 +2,406 @@ package de.nowchess.chess.controller
 
 import de.nowchess.api.board.*
 import de.nowchess.api.game.CastlingRights
-import de.nowchess.api.move.PromotionPiece
+import de.nowchess.chess.logic.{GameContext, CastleSide}
-import de.nowchess.chess.logic.{CastleSide, GameHistory}
-import de.nowchess.chess.notation.FenParser
 import org.scalatest.funsuite.AnyFunSuite
 import org.scalatest.matchers.should.Matchers
 
+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 =
+  private val initial = GameContext.initial
-    GameController.processMove(board, history, turn, raw)
-
-  private def castlingRights(history: GameHistory, color: Color): CastlingRights =
-    de.nowchess.chess.logic.CastlingRightsCalculator.deriveCastlingRights(history, color)
 
   // ──── 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: move that leaves own king in check returns IllegalMove"):
-    // White King E1 is in check from Black Rook E8. Moving the D2 pawn is
-    // geometrically legal but does not resolve the check — must be rejected.
-    val b = Board(Map(
-      sq(File.E, Rank.R1) -> Piece.WhiteKing,
-      sq(File.D, Rank.R2) -> Piece.WhitePawn,
-      sq(File.E, Rank.R8) -> Piece.BlackRook,
-      sq(File.A, Rank.R8) -> Piece.BlackKing
-    ))
-    processMove(b, GameHistory.empty, Color.White, "d2d4") shouldBe MoveResult.IllegalMove
-
-  test("processMove: move that resolves check is allowed"):
-    // White King E1 is in check from Black Rook E8 along the E-file.
-    // White Rook A5 interposes at E5 — resolves the check, no new check on Black King A8.
-    val b = Board(Map(
-      sq(File.E, Rank.R1) -> Piece.WhiteKing,
-      sq(File.A, Rank.R5) -> Piece.WhiteRook,
-      sq(File.E, Rank.R8) -> Piece.BlackRook,
-      sq(File.A, Rank.R8) -> Piece.BlackKing
-    ))
-    processMove(b, GameHistory.empty, Color.White, "a5e5") match
-      case _: MoveResult.Moved => succeed
-      case other => fail(s"Expected Moved, got $other")
 
   test("processMove: legal pawn move returns Moved with updated board and flipped turn"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "e2e4") match
+    GameController.processMove(initial, Color.White, "e2e4") match
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
-        newBoard.pieceAt(sq(File.E, Rank.R4)) shouldBe Some(Piece.WhitePawn)
+        newCtx.board.pieceAt(sq(File.E, Rank.R4)) shouldBe Some(Piece.WhitePawn)
-        newBoard.pieceAt(sq(File.E, Rank.R2)) shouldBe None
+        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
+    )))
+    GameController.processMove(captureCtx, Color.White, "e5d6") match
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
+        captured shouldBe Some(Piece.BlackPawn)
+        newCtx.board.pieceAt(sq(File.D, Rank.R6)) shouldBe Some(Piece.WhitePawn)
+        newTurn shouldBe Color.Black
+      case other => fail(s"Expected Moved, got $other")
+
+  // ──── gameLoop ───────────────────────────────────────────────────────
+
+  private def withInput(input: String)(block: => Unit): Unit =
+    val stream = ByteArrayInputStream(input.getBytes("UTF-8"))
+    scala.Console.withIn(stream)(block)
+
+  test("gameLoop: 'quit' exits cleanly without exception"):
+    withInput("quit\n"):
+      GameController.gameLoop(GameContext.initial, Color.White)
+
+  test("gameLoop: EOF (null readLine) exits via quit fallback"):
+    withInput(""):
+      GameController.gameLoop(GameContext.initial, Color.White)
+
+  test("gameLoop: invalid format prints message and recurses until quit"):
+    withInput("badmove\nquit\n"):
+      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"):
+      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"):
+      GameController.gameLoop(GameContext.initial, Color.White)
+
+  test("gameLoop: IllegalMove prints message and recurses until quit"):
+    withInput("e2e5\nquit\n"):
+      GameController.gameLoop(GameContext.initial, Color.White)
+
+  test("gameLoop: legal non-capture move recurses with new board then quits"):
+    withInput("e2e4\nquit\n"):
+      GameController.gameLoop(GameContext.initial, Color.White)
+
+  test("gameLoop: capture move prints capture message then recurses and quits"):
+    val captureBoard = 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
+    withInput("e5d6\nquit\n"):
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
+      GameController.gameLoop(GameContext(captureBoard), Color.White)
-        captured shouldBe Some(Piece.BlackPawn)
+
-        newBoard.pieceAt(sq(File.D, Rank.R6)) shouldBe Some(Piece.WhitePawn)
+  // ──── helpers ────────────────────────────────────────────────────────
-        newTurn shouldBe Color.Black
+
-      case other => fail(s"Expected Moved, got $other")
+  private def captureOutput(block: => Unit): String =
+    val out = java.io.ByteArrayOutputStream()
+    scala.Console.withOut(out)(block)
+    out.toString("UTF-8")
 
   // ──── processMove: check / checkmate / stalemate ─────────────────────
 
   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
+    GameController.processMove(ctx, Color.White, "a1a8") match
-      case MoveResult.MovedInCheck(_, _, _, newTurn) => newTurn shouldBe Color.Black
+      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 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
+    )))
+    GameController.processMove(ctx, Color.White, "b1b6") match
+      case MoveResult.Stalemate => succeed
+      case other => fail(s"Expected Stalemate, got $other")
+
+  // ──── gameLoop: check / checkmate / stalemate ─────────────────────────
+
+  test("gameLoop: checkmate prints winner message and resets to new game"):
+    // After Qa1-Qh8, position is checkmate; second "quit" exits the new game
+    val b = Board(Map(
+      sq(File.A, Rank.R1) -> Piece.WhiteQueen,
+      sq(File.A, Rank.R6) -> Piece.WhiteKing,
+      sq(File.A, Rank.R8) -> Piece.BlackKing
+    ))
+    val output = captureOutput:
+      withInput("a1h8\nquit\n"):
+        GameController.gameLoop(GameContext(b), Color.White)
+    output should include("Checkmate! White wins.")
+
+  test("gameLoop: stalemate prints draw message and resets to new game"):
     val b = 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
+    val output = captureOutput:
-      case MoveResult.Stalemate => succeed
+      withInput("b1b6\nquit\n"):
-      case other => fail(s"Expected Stalemate, got $other")
+        GameController.gameLoop(GameContext(b), Color.White)
+    output should include("Stalemate! The game is a draw.")
+
+  test("gameLoop: MovedInCheck without capture prints check message"):
+    val b = Board(Map(
+      sq(File.A, Rank.R1) -> Piece.WhiteRook,
+      sq(File.C, Rank.R3) -> Piece.WhiteKing,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    ))
+    val output = captureOutput:
+      withInput("a1a8\nquit\n"):
+        GameController.gameLoop(GameContext(b), Color.White)
+    output should include("Black is in check!")
+
+  test("gameLoop: MovedInCheck with capture prints both capture and check message"):
+    // White Rook A1 captures Black Pawn on A8, Ra8 then attacks rank 8 putting Kh8 in check
+    val b = Board(Map(
+      sq(File.A, Rank.R1) -> Piece.WhiteRook,
+      sq(File.C, Rank.R3) -> Piece.WhiteKing,
+      sq(File.A, Rank.R8) -> Piece.BlackPawn,
+      sq(File.H, Rank.R8) -> Piece.BlackKing
+    ))
+    val output = captureOutput:
+      withInput("a1a8\nquit\n"):
+        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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(newBoard, newHistory, captured, newTurn) =>
+      blackCastling = CastlingRights.None
-        newBoard.pieceAt(sq(File.G, Rank.R1)) shouldBe Some(Piece.WhiteKing)
+    )
-        newBoard.pieceAt(sq(File.F, Rank.R1)) shouldBe Some(Piece.WhiteRook)
+    GameController.processMove(ctx, Color.White, "e1g1") match
-        newBoard.pieceAt(sq(File.E, Rank.R1)) shouldBe None
+      case MoveResult.Moved(newCtx, captured, newTurn) =>
-        newBoard.pieceAt(sq(File.H, Rank.R1)) shouldBe None
+        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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(newBoard, _, _, _) =>
+      blackCastling = CastlingRights.None
-        newBoard.pieceAt(sq(File.C, Rank.R1)) shouldBe Some(Piece.WhiteKing)
+    )
-        newBoard.pieceAt(sq(File.D, Rank.R1)) shouldBe Some(Piece.WhiteRook)
+    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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.None
-        castlingRights(newHistory, Color.White) shouldBe 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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.None
-        castlingRights(newHistory, Color.White).kingSide  shouldBe false
+    )
-        castlingRights(newHistory, Color.White).queenSide shouldBe true
+    GameController.processMove(ctx, Color.White, "h1h4") match
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
+      case MoveResult.Moved(newCtx, _, _) =>
-        castlingRights(newHistory, Color.White).kingSide  shouldBe false
+        newCtx.whiteCastling.kingSide  shouldBe false
-        castlingRights(newHistory, Color.White).queenSide shouldBe true
+        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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.None
-        castlingRights(newHistory, Color.White) shouldBe 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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.None
-        castlingRights(newHistory, Color.White).kingSide shouldBe false
+    )
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
+    GameController.processMove(ctx, Color.Black, "h2h1") match
-        castlingRights(newHistory, Color.White).kingSide shouldBe false
+      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))
+      whiteCastling = CastlingRights.None,
-    processMove(b, history, Color.White, "e1g1") shouldBe MoveResult.IllegalMove
+      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
+      whiteCastling = CastlingRights.None,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.Both
-        castlingRights(newHistory, Color.Black) shouldBe CastlingRights.None
+    )
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
+    GameController.processMove(ctx, Color.Black, "e8e7") match
-        castlingRights(newHistory, Color.Black) shouldBe CastlingRights.None
+      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
+      whiteCastling = CastlingRights.None,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.Both
-        castlingRights(newHistory, Color.Black).queenSide shouldBe false
+    )
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe true
+    GameController.processMove(ctx, Color.Black, "a8a7") match
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
+      case MoveResult.Moved(newCtx, _, _) =>
-        castlingRights(newHistory, Color.Black).queenSide shouldBe false
+        newCtx.blackCastling.queenSide shouldBe false
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe true
+        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
+        sq(File.H, Rank.R1) -> Piece.WhiteKing
-      ))
+      )),
-    processMove(b, GameHistory.empty, Color.Black, "h8h4") match
+      whiteCastling = CastlingRights.None,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.Both
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe false
+    )
-        castlingRights(newHistory, Color.Black).queenSide shouldBe true
+    GameController.processMove(ctx, Color.Black, "h8h7") match
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
+      case MoveResult.Moved(newCtx, _, _) =>
-        castlingRights(newHistory, Color.Black).kingSide  shouldBe false
+        newCtx.blackCastling.kingSide  shouldBe false
-        castlingRights(newHistory, Color.Black).queenSide shouldBe true
+        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
+      whiteCastling = CastlingRights.Both,
-      case MoveResult.Moved(_, newHistory, _, _) =>
+      blackCastling = CastlingRights.None
-        castlingRights(newHistory, Color.White).queenSide shouldBe false
+    )
-      case MoveResult.MovedInCheck(_, newHistory, _, _) =>
+    GameController.processMove(ctx, Color.Black, "a2a1") match
-        castlingRights(newHistory, Color.White).queenSide shouldBe false
+      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")
-
-  // ──── pawn promotion detection ───────────────────────────────────────────
-
-  test("processMove detects white pawn reaching R8 and returns PromotionRequired"):
-    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val result = GameController.processMove(board, GameHistory.empty, Color.White, "e7e8")
-    result should matchPattern { case _: MoveResult.PromotionRequired => }
-    result match
-      case MoveResult.PromotionRequired(from, to, _, _, _, turn) =>
-        from should be (sq(File.E, Rank.R7))
-        to   should be (sq(File.E, Rank.R8))
-        turn should be (Color.White)
-      case _ => fail("Expected PromotionRequired")
-
-  test("processMove detects black pawn reaching R1 and returns PromotionRequired"):
-    val board = FenParser.parseBoard("8/8/8/8/4K3/8/4p3/8").get
-    val result = GameController.processMove(board, GameHistory.empty, Color.Black, "e2e1")
-    result should matchPattern { case _: MoveResult.PromotionRequired => }
-    result match
-      case MoveResult.PromotionRequired(from, to, _, _, _, turn) =>
-        from should be (sq(File.E, Rank.R2))
-        to   should be (sq(File.E, Rank.R1))
-        turn should be (Color.Black)
-      case _ => fail("Expected PromotionRequired")
-
-  test("processMove detects pawn capturing to back rank as PromotionRequired with captured piece"):
-    val board = FenParser.parseBoard("3q4/4P3/8/8/8/8/8/8").get
-    val result = GameController.processMove(board, GameHistory.empty, Color.White, "e7d8")
-    result should matchPattern { case _: MoveResult.PromotionRequired => }
-    result match
-      case MoveResult.PromotionRequired(_, _, _, _, captured, _) =>
-        captured should be (Some(Piece(Color.Black, PieceType.Queen)))
-      case _ => fail("Expected PromotionRequired")
-
-  // ──── completePromotion ──────────────────────────────────────────────────
-
-  test("completePromotion applies move and places queen"):
-    // Black king on h1: not attacked by queen on e8 (different file, rank, and diagonals)
-    val board = FenParser.parseBoard("8/4P3/8/8/8/8/8/7k").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
-      PromotionPiece.Queen, Color.White
-    )
-    result should matchPattern { case _: MoveResult.Moved => }
-    result match
-      case MoveResult.Moved(newBoard, newHistory, _, _) =>
-        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
-        newBoard.pieceAt(sq(File.E, Rank.R7)) should be (None)
-        newHistory.moves should have length 1
-        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
-      case _ => fail("Expected Moved")
-
-  test("completePromotion with rook underpromotion"):
-    // Black king on h1: not attacked by rook on e8 (different file and rank)
-    val board = FenParser.parseBoard("8/4P3/8/8/8/8/8/7k").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
-      PromotionPiece.Rook, Color.White
-    )
-    result match
-      case MoveResult.Moved(newBoard, newHistory, _, _) =>
-        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Rook)))
-        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Rook))
-      case _ => fail("Expected Moved with Rook")
-
-  test("completePromotion with bishop underpromotion"):
-    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
-      PromotionPiece.Bishop, Color.White
-    )
-    result match
-      case MoveResult.Moved(newBoard, newHistory, _, _) =>
-        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Bishop)))
-        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Bishop))
-      case _ => fail("Expected Moved with Bishop")
-
-  test("completePromotion with knight underpromotion"):
-    val board = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
-      PromotionPiece.Knight, Color.White
-    )
-    result match
-      case MoveResult.Moved(newBoard, newHistory, _, _) =>
-        newBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Knight)))
-        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Knight))
-      case _ => fail("Expected Moved with Knight")
-
-  test("completePromotion captures opponent piece"):
-    // Black king on h1: after white queen captures d8 queen, h1 king is safe (queen on d8 does not attack h1)
-    val board = FenParser.parseBoard("3q4/4P3/8/8/8/8/8/7k").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R7), sq(File.D, Rank.R8),
-      PromotionPiece.Queen, Color.White
-    )
-    result match
-      case MoveResult.Moved(newBoard, _, captured, _) =>
-        newBoard.pieceAt(sq(File.D, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
-        captured should be (Some(Piece(Color.Black, PieceType.Queen)))
-      case _ => fail("Expected Moved with captured piece")
-
-  test("completePromotion for black pawn to R1"):
-    val board = FenParser.parseBoard("8/8/8/8/4K3/8/4p3/8").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R2), sq(File.E, Rank.R1),
-      PromotionPiece.Knight, Color.Black
-    )
-    result match
-      case MoveResult.Moved(newBoard, newHistory, _, _) =>
-        newBoard.pieceAt(sq(File.E, Rank.R1)) should be (Some(Piece(Color.Black, PieceType.Knight)))
-        newHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Knight))
-      case _ => fail("Expected Moved")
-
-  test("completePromotion evaluates check after promotion"):
-    val board = FenParser.parseBoard("3k4/4P3/8/8/8/8/8/8").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.E, Rank.R7), sq(File.E, Rank.R8),
-      PromotionPiece.Queen, Color.White
-    )
-    result should matchPattern { case _: MoveResult.MovedInCheck => }
-
-  test("completePromotion full round-trip via processMove then completePromotion"):
-    // Black king on h1: not attacked by queen on e8
-    val board = FenParser.parseBoard("8/4P3/8/8/8/8/8/7k").get
-    GameController.processMove(board, GameHistory.empty, Color.White, "e7e8") match
-      case MoveResult.PromotionRequired(from, to, boardBefore, histBefore, _, turn) =>
-        val result = GameController.completePromotion(boardBefore, histBefore, from, to, PromotionPiece.Queen, turn)
-        result should matchPattern { case _: MoveResult.Moved => }
-        result match
-          case MoveResult.Moved(finalBoard, finalHistory, _, _) =>
-            finalBoard.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
-            finalHistory.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
-          case _ => fail("Expected Moved")
-      case _ => fail("Expected PromotionRequired")
-
-  test("completePromotion results in checkmate when promotion delivers checkmate"):
-    // Black king a8, white pawn h7, white king b6.
-    // After h7→h8=Q: Qh8 attacks rank 8 putting Ka8 in check;
-    // a7 covered by Kb6, b7 covered by Kb6, b8 covered by Qh8 — no escape.
-    val board = FenParser.parseBoard("k7/7P/1K6/8/8/8/8/8").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.H, Rank.R7), sq(File.H, Rank.R8),
-      PromotionPiece.Queen, Color.White
-    )
-    result should matchPattern { case MoveResult.Checkmate(_) => }
-    result match
-      case MoveResult.Checkmate(winner) => winner should be (Color.White)
-      case _ => fail("Expected Checkmate")
-
-  test("completePromotion results in stalemate when promotion stalemates opponent"):
-    // Black king a8, white pawn b7, white bishop c7, white king b6.
-    // After b7→b8=N: knight on b8 (doesn't check a8); a7 and b7 covered by Kb6;
-    // b8 defended by Bc7 so Ka8xb8 would walk into bishop — no legal moves.
-    val board = FenParser.parseBoard("k7/1PB5/1K6/8/8/8/8/8").get
-    val result = GameController.completePromotion(
-      board, GameHistory.empty,
-      sq(File.B, Rank.R7), sq(File.B, Rank.R8),
-      PromotionPiece.Knight, Color.White
-    )
-    result should be (MoveResult.Stalemate)
-
-  // ──── half-move clock propagation ────────────────────────────────────
-
-  test("processMove: non-pawn non-capture increments halfMoveClock"):
-    // g1f3 is a knight move — not a pawn, not a capture
-    processMove(Board.initial, GameHistory.empty, Color.White, "g1f3") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        newHistory.halfMoveClock shouldBe 1
-      case other => fail(s"Expected Moved, got $other")
-
-  test("processMove: pawn move resets halfMoveClock to 0"):
-    processMove(Board.initial, GameHistory.empty, Color.White, "e2e4") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        newHistory.halfMoveClock shouldBe 0
-      case other => fail(s"Expected Moved, got $other")
-
-  test("processMove: capture resets halfMoveClock to 0"):
-    // White pawn on e5, Black pawn on d6 — exd6 is a capture
-    val board = Board(Map(
-      sq(File.E, Rank.R5) -> Piece.WhitePawn,
-      sq(File.D, Rank.R6) -> Piece.BlackPawn,
-      sq(File.E, Rank.R1) -> Piece.WhiteKing,
-      sq(File.E, Rank.R8) -> Piece.BlackKing
-    ))
-    val history = GameHistory(halfMoveClock = 10)
-    processMove(board, history, Color.White, "e5d6") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        newHistory.halfMoveClock shouldBe 0
-      case other => fail(s"Expected Moved, got $other")
-
-  test("processMove: clock carries from previous history on non-pawn non-capture"):
-    val history = GameHistory(halfMoveClock = 5)
-    processMove(Board.initial, history, Color.White, "g1f3") match
-      case MoveResult.Moved(_, newHistory, _, _) =>
-        newHistory.halfMoveClock shouldBe 6
-      case other => fail(s"Expected Moved, got $other")

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineEdgeCasesTest.scala

@@ -1,214 +0,0 @@
-package de.nowchess.chess.engine
-
-import scala.collection.mutable
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.{Observer, GameEvent, MoveExecutedEvent, CheckDetectedEvent, BoardResetEvent, InvalidMoveEvent}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-/** Tests for GameEngine edge cases and uncovered paths */
-class GameEngineEdgeCasesTest extends AnyFunSuite with Matchers:
-
-  test("GameEngine handles empty input"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("Please enter a valid move or command")
-
-  test("GameEngine processes quit command"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("quit")
-    // Quit just returns, no events
-    observer.events.isEmpty shouldBe true
-
-  test("GameEngine processes q command (short form)"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("q")
-    observer.events.isEmpty shouldBe true
-
-  test("GameEngine handles uppercase quit"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("QUIT")
-    observer.events.isEmpty shouldBe true
-
-  test("GameEngine handles undo on empty history"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.canUndo shouldBe false
-    engine.processUserInput("undo")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("Nothing to undo")
-
-  test("GameEngine handles redo on empty redo history"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.canRedo shouldBe false
-    engine.processUserInput("redo")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("Nothing to redo")
-
-  test("GameEngine parses invalid move format"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("invalid_move_format")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("Invalid move format")
-
-  test("GameEngine handles lowercase input normalization"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("  UNDO  ")  // With spaces and uppercase
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]  // No moves to undo yet
-
-  test("GameEngine preserves board state on invalid move"):
-    val engine = new GameEngine()
-    val initialBoard = engine.board
-    
-    engine.processUserInput("invalid")
-    
-    engine.board shouldBe initialBoard
-
-  test("GameEngine preserves turn on invalid move"):
-    val engine = new GameEngine()
-    val initialTurn = engine.turn
-    
-    engine.processUserInput("invalid")
-    
-    engine.turn shouldBe initialTurn
-
-  test("GameEngine undo with no commands available"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // Make a valid move
-    engine.processUserInput("e2e4")
-    observer.events.clear()
-    
-    // Undo it
-    engine.processUserInput("undo")
-    
-    // Board should be reset
-    engine.board shouldBe Board.initial
-    engine.turn shouldBe Color.White
-
-  test("GameEngine redo after undo"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("e2e4")
-    val boardAfterMove = engine.board
-    val turnAfterMove = engine.turn
-    observer.events.clear()
-    
-    engine.processUserInput("undo")
-    engine.processUserInput("redo")
-    
-    engine.board shouldBe boardAfterMove
-    engine.turn shouldBe turnAfterMove
-
-  test("GameEngine canUndo flag tracks state correctly"):
-    val engine = new GameEngine()
-    
-    engine.canUndo shouldBe false
-    engine.processUserInput("e2e4")
-    engine.canUndo shouldBe true
-    engine.processUserInput("undo")
-    engine.canUndo shouldBe false
-
-  test("GameEngine canRedo flag tracks state correctly"):
-    val engine = new GameEngine()
-    
-    engine.canRedo shouldBe false
-    engine.processUserInput("e2e4")
-    engine.canRedo shouldBe false
-    engine.processUserInput("undo")
-    engine.canRedo shouldBe true
-
-  test("GameEngine command history is accessible"):
-    val engine = new GameEngine()
-    
-    engine.commandHistory.isEmpty shouldBe true
-    engine.processUserInput("e2e4")
-    engine.commandHistory.size shouldBe 1
-
-  test("GameEngine processes multiple moves in sequence"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    observer.events.clear()
-    
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    
-    observer.events.size shouldBe 2
-    engine.commandHistory.size shouldBe 2
-
-  test("GameEngine can undo multiple moves"):
-    val engine = new GameEngine()
-    
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    
-    engine.processUserInput("undo")
-    engine.turn shouldBe Color.Black
-    
-    engine.processUserInput("undo")
-    engine.turn shouldBe Color.White
-
-  test("GameEngine thread-safe operations"):
-    val engine = new GameEngine()
-    
-    // Access from synchronized methods
-    val board = engine.board
-    val history = engine.history
-    val turn = engine.turn
-    val canUndo = engine.canUndo
-    val canRedo = engine.canRedo
-    
-    board shouldBe Board.initial
-    canUndo shouldBe false
-    canRedo shouldBe false
-
-
-private class MockObserver extends Observer:
-  val events = mutable.ListBuffer[GameEvent]()
-  
-  override def onGameEvent(event: GameEvent): Unit =
-    events += event

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineGameEndingTest.scala

@@ -1,93 +0,0 @@
-package de.nowchess.chess.engine
-
-import scala.collection.mutable
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.{Observer, GameEvent, CheckDetectedEvent, CheckmateEvent, StalemateEvent}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-/** Tests for GameEngine check/checkmate/stalemate paths */
-class GameEngineGameEndingTest extends AnyFunSuite with Matchers:
-
-  test("GameEngine handles Checkmate (Fool's Mate)"):
-    val engine = new GameEngine()
-    val observer = new EndingMockObserver()
-    engine.subscribe(observer)
-    
-    // Play Fool's mate
-    engine.processUserInput("f2f3")
-    engine.processUserInput("e7e5")
-    engine.processUserInput("g2g4")
-    
-    observer.events.clear()
-    engine.processUserInput("d8h4")
-    
-    // Verify CheckmateEvent
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[CheckmateEvent]
-    
-    val event = observer.events.head.asInstanceOf[CheckmateEvent]
-    event.winner shouldBe Color.Black
-    
-    // Board should be reset after checkmate
-    engine.board shouldBe Board.initial
-    engine.turn shouldBe Color.White
-
-  test("GameEngine handles check detection"):
-    val engine = new GameEngine()
-    val observer = new EndingMockObserver()
-    engine.subscribe(observer)
-    
-    // Play a simple check
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    engine.processUserInput("f1c4")
-    engine.processUserInput("g8f6")
-    
-    observer.events.clear()
-    engine.processUserInput("c4f7") // Check!
-    
-    val checkEvents = observer.events.collect { case e: CheckDetectedEvent => e }
-    checkEvents.size shouldBe 1
-    checkEvents.head.turn shouldBe Color.Black // Black is now in check
-    
-  // Shortest known stalemate is 19 moves. Here is a faster one:
-  // e3 a5 Qh5 Ra6 Qxa5 h5 h4 Rah6 Qxc7 f6 Qxd7+ Kf7 Qxb7 Qd3 Qxb8 Qh7 Qxc8 Kg6 Qe6
-  // Wait, let's just use Sam Loyd's 10-move stalemate:
-  // 1. e3 a5 2. Qh5 Ra6 3. Qxa5 h5 4. h4 Rah6 5. Qxc7 f6 6. Qxd7+ Kf7 7. Qxb7 Qd3 8. Qxb8 Qh7 9. Qxc8 Kg6 10. Qe6
-  test("GameEngine handles Stalemate via 10-move known sequence"):
-    val engine = new GameEngine()
-    val observer = new EndingMockObserver()
-    engine.subscribe(observer)
-    
-    val moves = List(
-      "e2e3", "a7a5",
-      "d1h5", "a8a6",
-      "h5a5", "h7h5",
-      "h2h4", "a6h6",
-      "a5c7", "f7f6",
-      "c7d7", "e8f7",
-      "d7b7", "d8d3",
-      "b7b8", "d3h7",
-      "b8c8", "f7g6",
-      "c8e6"
-    )
-    
-    moves.dropRight(1).foreach(engine.processUserInput)
-    
-    observer.events.clear()
-    engine.processUserInput(moves.last)
-    
-    val stalemateEvents = observer.events.collect { case e: StalemateEvent => e }
-    stalemateEvents.size shouldBe 1
-    
-    // Board should be reset after stalemate
-    engine.board shouldBe Board.initial
-    engine.turn shouldBe Color.White
-
-private class EndingMockObserver extends Observer:
-  val events = mutable.ListBuffer[GameEvent]()
-  
-  override def onGameEvent(event: GameEvent): Unit =
-    events += event

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineHandleFailedMoveTest.scala

@@ -1,110 +0,0 @@
-package de.nowchess.chess.engine
-
-import scala.collection.mutable
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.{Observer, GameEvent, InvalidMoveEvent}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-/** Tests to maximize handleFailedMove coverage */
-class GameEngineHandleFailedMoveTest extends AnyFunSuite with Matchers:
-
-  test("GameEngine handles InvalidFormat error type"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("not_a_valid_move_format")
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val msg1 = observer.events.head.asInstanceOf[InvalidMoveEvent].reason
-    msg1 should include("Invalid move format")
-
-  test("GameEngine handles NoPiece error type"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("h3h4")
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val msg2 = observer.events.head.asInstanceOf[InvalidMoveEvent].reason
-    msg2 should include("No piece on that square")
-
-  test("GameEngine handles WrongColor error type"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("e2e4")  // White move
-    observer.events.clear()
-    
-    engine.processUserInput("a1b2")  // Try to move black's rook position with white's move (wrong color)
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val msg3 = observer.events.head.asInstanceOf[InvalidMoveEvent].reason
-    msg3 should include("That is not your piece")
-
-  test("GameEngine handles IllegalMove error type"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("e2e1")  // Try pawn backward
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val msg4 = observer.events.head.asInstanceOf[InvalidMoveEvent].reason
-    msg4 should include("Illegal move")
-
-  test("GameEngine invalid move message for InvalidFormat"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("xyz123")
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("coordinate notation")
-
-  test("GameEngine invalid move message for NoPiece"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("a3a4")  // a3 is empty
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("No piece")
-
-  test("GameEngine invalid move message for WrongColor"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("e2e4")
-    observer.events.clear()
-    
-    engine.processUserInput("e4e5")  // e4 has white pawn, it's black's turn
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("not your piece")
-
-  test("GameEngine invalid move message for IllegalMove"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    engine.processUserInput("e2e1")  // Pawn can't move backward
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("Illegal move")
-
-  test("GameEngine board unchanged after each type of invalid move"):
-    val engine = new GameEngine()
-    val initial = engine.board
-    
-    engine.processUserInput("invalid")
-    engine.board shouldBe initial
-    
-    engine.processUserInput("h3h4")
-    engine.board shouldBe initial
-    
-    engine.processUserInput("e2e1")
-    engine.board shouldBe initial

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineInvalidMovesTest.scala

@@ -1,114 +0,0 @@
-package de.nowchess.chess.engine
-
-import scala.collection.mutable
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.{Observer, GameEvent, InvalidMoveEvent, MoveExecutedEvent}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-/** Tests for GameEngine invalid move handling via handleFailedMove */
-class GameEngineInvalidMovesTest extends AnyFunSuite with Matchers:
-
-  test("GameEngine handles no piece at source square"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // Try to move from h1 which may be empty or not have our piece
-    // We'll try from a clearly empty square
-    engine.processUserInput("h1h2")
-    
-    // Should get an InvalidMoveEvent about NoPiece
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-
-  test("GameEngine handles moving wrong color piece"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // White moves first
-    engine.processUserInput("e2e4")
-    observer.events.clear()
-    
-    // White tries to move again (should fail - it's black's turn)
-    // But we need to try a move that looks legal but has wrong color
-    // This is hard to test because we'd need to be black and move white's piece
-    // Let's skip this for now and focus on testable cases
-    
-    // Actually, let's try moving a square that definitely has the wrong piece
-    // Move a white pawn as black by reaching that position
-    engine.processUserInput("e7e5")
-    observer.events.clear()
-    
-    // Now try to move white's e4 pawn as black (it's black's turn but e4 is white)
-    engine.processUserInput("e4e5")
-    
-    observer.events.size shouldBe 1
-    val event = observer.events.head
-    event shouldBe an[InvalidMoveEvent]
-
-  test("GameEngine handles illegal move"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // A pawn can't move backward
-    engine.processUserInput("e2e1")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("Illegal move")
-
-  test("GameEngine handles pawn trying to move 3 squares"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // Pawn can only move 1 or 2 squares on first move, not 3
-    engine.processUserInput("e2e5")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-
-  test("GameEngine handles moving from empty square"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // h3 is empty in starting position
-    engine.processUserInput("h3h4")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[InvalidMoveEvent]
-    val event = observer.events.head.asInstanceOf[InvalidMoveEvent]
-    event.reason should include("No piece on that square")
-
-  test("GameEngine processes valid move after invalid attempt"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    
-    // Try invalid move
-    engine.processUserInput("h3h4")
-    observer.events.clear()
-    
-    // Make valid move
-    engine.processUserInput("e2e4")
-    
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe an[MoveExecutedEvent]
-
-  test("GameEngine maintains state after failed move attempt"):
-    val engine = new GameEngine()
-    val initialTurn = engine.turn
-    val initialBoard = engine.board
-    
-    // Try invalid move
-    engine.processUserInput("h3h4")
-    
-    // State should not change
-    engine.turn shouldBe initialTurn
-    engine.board shouldBe initialBoard

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineLoadPgnTest.scala

@@ -1,165 +0,0 @@
-package de.nowchess.chess.engine
-
-import scala.collection.mutable
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.*
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class GameEngineLoadPgnTest extends AnyFunSuite with Matchers:
-
-  private class EventCapture extends Observer:
-    val events: mutable.Buffer[GameEvent] = mutable.Buffer.empty
-    def onGameEvent(event: GameEvent): Unit = events += event
-    def lastEvent: GameEvent = events.last
-
-  // ── loadPgn happy path ────────────────────────────────────────────────────
-
-  test("loadPgn: valid PGN returns Right and updates board/history"):
-    val engine = new GameEngine()
-    val pgn =
-      """[Event "Test"]
-
-1. e4 e5
-"""
-    val result = engine.loadPgn(pgn)
-    result shouldBe Right(())
-    engine.history.moves.length shouldBe 2
-    engine.turn shouldBe Color.White
-
-  test("loadPgn: emits PgnLoadedEvent on success"):
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    val pgn = "[Event \"T\"]\n\n1. e4 e5\n"
-    engine.loadPgn(pgn)
-    cap.events.last shouldBe a[PgnLoadedEvent]
-
-  test("loadPgn: after load canUndo is true and canRedo is false"):
-    val engine = new GameEngine()
-    val pgn = "[Event \"T\"]\n\n1. e4 e5\n"
-    engine.loadPgn(pgn) shouldBe Right(())
-    engine.canUndo shouldBe true
-    engine.canRedo shouldBe false
-
-  test("loadPgn: undo works after loading PGN"):
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    val pgn = "[Event \"T\"]\n\n1. e4 e5\n"
-    engine.loadPgn(pgn)
-    cap.events.clear()
-    engine.undo()
-    cap.events.last shouldBe a[MoveUndoneEvent]
-    engine.history.moves.length shouldBe 1
-
-  test("loadPgn: undo then redo restores position after PGN load"):
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    val pgn = "[Event \"T\"]\n\n1. e4 e5\n"
-    engine.loadPgn(pgn)
-    val boardAfterLoad = engine.board
-    engine.undo()
-    engine.redo()
-    cap.events.last shouldBe a[MoveRedoneEvent]
-    engine.board shouldBe boardAfterLoad
-    engine.history.moves.length shouldBe 2
-
-  test("loadPgn: longer game loads all moves into command history"):
-    val engine = new GameEngine()
-    val pgn =
-      """[Event "Ruy Lopez"]
-
-1. e4 e5 2. Nf3 Nc6 3. Bb5 a6
-"""
-    engine.loadPgn(pgn) shouldBe Right(())
-    engine.history.moves.length shouldBe 6
-    engine.commandHistory.length shouldBe 6
-
-  test("loadPgn: invalid PGN returns Left and does not change state"):
-    val engine  = new GameEngine()
-    val initial = engine.board
-    val result  = engine.loadPgn("[Event \"T\"]\n\n1. Qd4\n")
-    result.isLeft shouldBe true
-    // state is reset to initial (reset happens before replay, which fails)
-    engine.history.moves shouldBe empty
-
-  // ── undo/redo notation events ─────────────────────────────────────────────
-
-  test("undo emits MoveUndoneEvent with pgnNotation"):
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    engine.processUserInput("e2e4")
-    cap.events.clear()
-    engine.undo()
-    cap.events.last shouldBe a[MoveUndoneEvent]
-    val evt = cap.events.last.asInstanceOf[MoveUndoneEvent]
-    evt.pgnNotation should not be empty
-    evt.pgnNotation shouldBe "e4"  // pawn to e4
-
-  test("redo emits MoveRedoneEvent with pgnNotation"):
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    engine.processUserInput("e2e4")
-    engine.undo()
-    cap.events.clear()
-    engine.redo()
-    cap.events.last shouldBe a[MoveRedoneEvent]
-    val evt = cap.events.last.asInstanceOf[MoveRedoneEvent]
-    evt.pgnNotation should not be empty
-    evt.pgnNotation shouldBe "e4"
-
-  test("undo emits MoveUndoneEvent with empty notation when history is empty (after checkmate reset)"):
-    // Simulate state where canUndo=true but currentHistory is empty (board reset on checkmate).
-    // We achieve this by examining the branch: provide a MoveCommand with empty history saved.
-    // The simplest proxy: undo a move that reset history (stalemate/checkmate). We'll
-    // use a contrived engine state by direct command manipulation — instead, just verify
-    // that after a normal move-and-undo the notation is present; the empty-history branch
-    // is exercised internally when gameEnd resets state. We cover it via a castling undo.
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    // Play moves that let white castle kingside: e4 e5 Nf3 Nc6 Bc4 Bc5 O-O
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    engine.processUserInput("g1f3")
-    engine.processUserInput("b8c6")
-    engine.processUserInput("f1c4")
-    engine.processUserInput("f8c5")
-    engine.processUserInput("e1g1")  // white castles kingside
-    cap.events.clear()
-    engine.undo()
-    val evt = cap.events.last.asInstanceOf[MoveUndoneEvent]
-    evt.pgnNotation shouldBe "O-O"
-
-  test("redo emits MoveRedoneEvent with from/to squares and capturedPiece"):
-    val engine = new GameEngine()
-    val cap    = new EventCapture()
-    engine.subscribe(cap)
-    // White builds a capture on the a-file: b4, ... a6, b5, ... h6, bxa6
-    engine.processUserInput("b2b4")
-    engine.processUserInput("a7a6")
-    engine.processUserInput("b4b5")
-    engine.processUserInput("h7h6")
-    engine.processUserInput("b5a6")  // white pawn captures black pawn
-    engine.undo()
-    cap.events.clear()
-    engine.redo()
-    val evt = cap.events.last.asInstanceOf[MoveRedoneEvent]
-    evt.fromSquare shouldBe "b5"
-    evt.toSquare   shouldBe "a6"
-    evt.capturedPiece.isDefined shouldBe true
-
-  test("loadPgn: clears previous game state before loading"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val pgn = "[Event \"T\"]\n\n1. d4 d5\n"
-    engine.loadPgn(pgn) shouldBe Right(())
-    // First move should be d4, not e4
-    engine.history.moves.head.to shouldBe de.nowchess.api.board.Square(
-      de.nowchess.api.board.File.D, de.nowchess.api.board.Rank.R4
-    )

modules/core/src/test/scala/de/nowchess/chess/engine/GameEnginePromotionTest.scala

@@ -1,167 +0,0 @@
-package de.nowchess.chess.engine
-
-import de.nowchess.api.board.{Board, Color, File, Piece, PieceType, Rank, Square}
-import de.nowchess.api.move.PromotionPiece
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.notation.FenParser
-import de.nowchess.chess.observer.*
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class GameEnginePromotionTest extends AnyFunSuite with Matchers:
-
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  private def captureEvents(engine: GameEngine): collection.mutable.ListBuffer[GameEvent] =
-    val events = collection.mutable.ListBuffer[GameEvent]()
-    engine.subscribe(new Observer { def onGameEvent(e: GameEvent): Unit = events += e })
-    events
-
-  test("processUserInput fires PromotionRequiredEvent when pawn reaches back rank") {
-    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = promotionBoard)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-
-    events.exists(_.isInstanceOf[PromotionRequiredEvent]) should be (true)
-    events.collect { case e: PromotionRequiredEvent => e }.head.from should be (sq(File.E, Rank.R7))
-  }
-
-  test("isPendingPromotion is true after PromotionRequired input") {
-    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = promotionBoard)
-    captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-
-    engine.isPendingPromotion should be (true)
-  }
-
-  test("isPendingPromotion is false before any promotion input") {
-    val engine = new GameEngine()
-    engine.isPendingPromotion should be (false)
-  }
-
-  test("completePromotion fires MoveExecutedEvent with promoted piece") {
-    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = promotionBoard)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-    engine.completePromotion(PromotionPiece.Queen)
-
-    engine.isPendingPromotion should be (false)
-    engine.board.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
-    engine.board.pieceAt(sq(File.E, Rank.R7)) should be (None)
-    engine.history.moves.head.promotionPiece should be (Some(PromotionPiece.Queen))
-    events.exists(_.isInstanceOf[MoveExecutedEvent]) should be (true)
-  }
-
-  test("completePromotion with rook underpromotion") {
-    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = promotionBoard)
-    captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-    engine.completePromotion(PromotionPiece.Rook)
-
-    engine.board.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Rook)))
-  }
-
-  test("completePromotion with no pending promotion fires InvalidMoveEvent") {
-    val engine = new GameEngine()
-    val events = captureEvents(engine)
-
-    engine.completePromotion(PromotionPiece.Queen)
-
-    events.exists(_.isInstanceOf[InvalidMoveEvent]) should be (true)
-    engine.isPendingPromotion should be (false)
-  }
-
-  test("completePromotion fires CheckDetectedEvent when promotion gives check") {
-    val promotionBoard = FenParser.parseBoard("3k4/4P3/8/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = promotionBoard)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-    engine.completePromotion(PromotionPiece.Queen)
-
-    events.exists(_.isInstanceOf[CheckDetectedEvent]) should be (true)
-  }
-
-  test("completePromotion results in Moved when promotion doesn't give check") {
-    // White pawn on e7, black king on a2 (far away, not in check after promotion)
-    val board = FenParser.parseBoard("8/4P3/8/8/8/8/k7/8").get
-    val engine = new GameEngine(initialBoard = board)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-    engine.completePromotion(PromotionPiece.Queen)
-
-    engine.isPendingPromotion should be (false)
-    engine.board.pieceAt(sq(File.E, Rank.R8)) should be (Some(Piece(Color.White, PieceType.Queen)))
-    events.filter(_.isInstanceOf[MoveExecutedEvent]) should not be empty
-    events.exists(_.isInstanceOf[CheckDetectedEvent]) should be (false)
-  }
-
-  test("completePromotion results in Checkmate when promotion delivers checkmate") {
-    // Black king on a8, white king on b6, white pawn on h7
-    // h7->h8=Q delivers checkmate
-    val board = FenParser.parseBoard("k7/7P/1K6/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = board)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("h7h8")
-    engine.completePromotion(PromotionPiece.Queen)
-
-    engine.isPendingPromotion should be (false)
-    events.exists(_.isInstanceOf[CheckmateEvent]) should be (true)
-  }
-
-  test("completePromotion results in Stalemate when promotion creates stalemate") {
-    // Black king on a8, white pawn on b7, white bishop on c7, white king on b6
-    // b7->b8=N: no check; Ka8 has no legal moves -> stalemate
-    val board = FenParser.parseBoard("k7/1PB5/1K6/8/8/8/8/8").get
-    val engine = new GameEngine(initialBoard = board)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("b7b8")
-    engine.completePromotion(PromotionPiece.Knight)
-
-    engine.isPendingPromotion should be (false)
-    events.exists(_.isInstanceOf[StalemateEvent]) should be (true)
-  }
-
-  test("completePromotion with black pawn promotion results in Moved") {
-    // Black pawn e2, white king h3 (not on rank 1 or file e), black king a8
-    // e2->e1=Q: queen on e1 does not attack h3 -> normal Moved
-    val board = FenParser.parseBoard("k7/8/8/8/8/7K/4p3/8").get
-    val engine = new GameEngine(initialBoard = board, initialTurn = Color.Black)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("e2e1")
-    engine.completePromotion(PromotionPiece.Queen)
-
-    engine.isPendingPromotion should be (false)
-    engine.board.pieceAt(sq(File.E, Rank.R1)) should be (Some(Piece(Color.Black, PieceType.Queen)))
-    events.filter(_.isInstanceOf[MoveExecutedEvent]) should not be empty
-    events.exists(_.isInstanceOf[CheckDetectedEvent]) should be (false)
-  }
-
-  test("completePromotion catch-all fires InvalidMoveEvent for unexpected MoveResult") {
-    // Inject a function that returns an unexpected MoveResult to hit the catch-all case
-    val promotionBoard = FenParser.parseBoard("8/4P3/4k3/8/8/8/8/8").get
-    val stubFn: (de.nowchess.api.board.Board, de.nowchess.chess.logic.GameHistory, Square, Square, PromotionPiece, Color) => de.nowchess.chess.controller.MoveResult =
-      (_, _, _, _, _, _) => de.nowchess.chess.controller.MoveResult.NoPiece
-    val engine = new GameEngine(initialBoard = promotionBoard, completePromotionFn = stubFn)
-    val events = captureEvents(engine)
-
-    engine.processUserInput("e7e8")
-    engine.isPendingPromotion should be (true)
-
-    engine.completePromotion(PromotionPiece.Queen)
-
-    engine.isPendingPromotion should be (false)
-    events.exists(_.isInstanceOf[InvalidMoveEvent]) should be (true)
-  }

modules/core/src/test/scala/de/nowchess/chess/engine/GameEngineTest.scala

@@ -1,351 +0,0 @@
-package de.nowchess.chess.engine
-
-import scala.collection.mutable
-import de.nowchess.api.board.{Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import de.nowchess.chess.observer.{Observer, GameEvent, MoveExecutedEvent, CheckDetectedEvent, BoardResetEvent, InvalidMoveEvent, FiftyMoveRuleAvailableEvent, DrawClaimedEvent, MoveUndoneEvent, MoveRedoneEvent}
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class GameEngineTest extends AnyFunSuite with Matchers:
-
-  test("GameEngine starts with initial board state"):
-    val engine = new GameEngine()
-    engine.board shouldBe Board.initial
-    engine.history shouldBe GameHistory.empty
-    engine.turn shouldBe Color.White
-
-  test("GameEngine accepts Observer subscription"):
-    val engine = new GameEngine()
-    val mockObserver = new MockObserver()
-    engine.subscribe(mockObserver)
-    engine.observerCount shouldBe 1
-
-  test("GameEngine notifies observers on valid move"):
-    val engine = new GameEngine()
-    val mockObserver = new MockObserver()
-    engine.subscribe(mockObserver)
-    engine.processUserInput("e2e4")
-    mockObserver.events.size shouldBe 1
-    mockObserver.events.head shouldBe a[MoveExecutedEvent]
-
-  test("GameEngine updates state after valid move"):
-    val engine = new GameEngine()
-    val initialTurn = engine.turn
-    engine.processUserInput("e2e4")
-    engine.turn shouldNot be(initialTurn)
-    engine.turn shouldBe Color.Black
-
-  test("GameEngine notifies observers on invalid move"):
-    val engine = new GameEngine()
-    val mockObserver = new MockObserver()
-    engine.subscribe(mockObserver)
-    engine.processUserInput("invalid_move")
-    mockObserver.events.size shouldBe 1
-
-  test("GameEngine notifies multiple observers"):
-    val engine = new GameEngine()
-    val observer1 = new MockObserver()
-    val observer2 = new MockObserver()
-    engine.subscribe(observer1)
-    engine.subscribe(observer2)
-    engine.processUserInput("e2e4")
-    observer1.events.size shouldBe 1
-    observer2.events.size shouldBe 1
-
-  test("GameEngine allows observer unsubscription"):
-    val engine = new GameEngine()
-    val mockObserver = new MockObserver()
-    engine.subscribe(mockObserver)
-    engine.unsubscribe(mockObserver)
-    engine.observerCount shouldBe 0
-
-  test("GameEngine unsubscribed observer receives no events"):
-    val engine = new GameEngine()
-    val mockObserver = new MockObserver()
-    engine.subscribe(mockObserver)
-    engine.unsubscribe(mockObserver)
-    engine.processUserInput("e2e4")
-    mockObserver.events.size shouldBe 0
-
-  test("GameEngine reset notifies observers and resets state"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.reset()
-    engine.board shouldBe Board.initial
-    engine.turn shouldBe Color.White
-    observer.events.size shouldBe 1
-
-  test("GameEngine processes sequence of moves"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    observer.events.size shouldBe 2
-    engine.turn shouldBe Color.White
-
-  test("GameEngine is thread-safe for synchronized operations"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    val t = new Thread(() => engine.processUserInput("e2e4"))
-    t.start()
-    t.join()
-    observer.events.size shouldBe 1
-
-  test("GameEngine canUndo returns false initially"):
-    val engine = new GameEngine()
-    engine.canUndo shouldBe false
-
-  test("GameEngine canUndo returns true after move"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.canUndo shouldBe true
-
-  test("GameEngine canRedo returns false initially"):
-    val engine = new GameEngine()
-    engine.canRedo shouldBe false
-
-  test("GameEngine undo restores previous state"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val boardAfterMove = engine.board
-    engine.undo()
-    engine.board shouldBe Board.initial
-    engine.turn shouldBe Color.White
-
-  test("GameEngine undo notifies observers"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    observer.events.clear()
-    engine.undo()
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[MoveUndoneEvent]
-
-  test("GameEngine redo replays undone move"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val boardAfterMove = engine.board
-    engine.undo()
-    engine.redo()
-    engine.board shouldBe boardAfterMove
-    engine.turn shouldBe Color.Black
-
-  test("GameEngine canUndo false when nothing to undo"):
-    val engine = new GameEngine()
-    engine.canUndo shouldBe false
-    engine.processUserInput("e2e4")
-    engine.undo()
-    engine.canUndo shouldBe false
-
-  test("GameEngine canRedo true after undo"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.undo()
-    engine.canRedo shouldBe true
-
-  test("GameEngine canRedo false after redo"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.undo()
-    engine.redo()
-    engine.canRedo shouldBe false
-
-  test("GameEngine undo on empty history sends invalid event"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.undo()
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[InvalidMoveEvent]
-
-  test("GameEngine redo on empty redo sends invalid event"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.redo()
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[InvalidMoveEvent]
-
-  test("GameEngine undo via processUserInput"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val boardAfterMove = engine.board
-    engine.processUserInput("undo")
-    engine.board shouldBe Board.initial
-
-  test("GameEngine redo via processUserInput"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    val boardAfterMove = engine.board
-    engine.processUserInput("undo")
-    engine.processUserInput("redo")
-    engine.board shouldBe boardAfterMove
-
-  test("GameEngine handles empty input"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.processUserInput("")
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[InvalidMoveEvent]
-
-  test("GameEngine multiple undo/redo sequence"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    engine.processUserInput("g1f3")
-    
-    engine.turn shouldBe Color.Black
-    
-    engine.undo()
-    engine.turn shouldBe Color.White
-    
-    engine.undo()
-    engine.turn shouldBe Color.Black
-    
-    engine.undo()
-    engine.turn shouldBe Color.White
-    engine.board shouldBe Board.initial
-
-  test("GameEngine redo after multiple undos"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    engine.processUserInput("g1f3")
-    
-    engine.undo()
-    engine.undo()
-    engine.undo()
-    
-    engine.redo()
-    engine.turn shouldBe Color.Black
-    
-    engine.redo()
-    engine.turn shouldBe Color.White
-    
-    engine.redo()
-    engine.turn shouldBe Color.Black
-
-  test("GameEngine new move after undo clears redo history"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    engine.undo()
-    engine.canRedo shouldBe true
-    
-    engine.processUserInput("e7e6")  // Different move
-    engine.canRedo shouldBe false
-
-  test("GameEngine command history tracking"):
-    val engine = new GameEngine()
-    engine.commandHistory.size shouldBe 0
-    
-    engine.processUserInput("e2e4")
-    engine.commandHistory.size shouldBe 1
-    
-    engine.processUserInput("e7e5")
-    engine.commandHistory.size shouldBe 2
-
-  test("GameEngine quit input"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    val initialEvents = observer.events.size
-    engine.processUserInput("quit")
-    // quit should not produce an event
-    observer.events.size shouldBe initialEvents
-
-  test("GameEngine quit via q"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    val initialEvents = observer.events.size
-    engine.processUserInput("q")
-    observer.events.size shouldBe initialEvents
-  
-  test("GameEngine undo notifies with MoveUndoneEvent after successful undo"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    observer.events.clear()
-
-    engine.undo()
-
-    // Should have received a MoveUndoneEvent on undo
-    observer.events.size should be > 0
-    observer.events.exists(_.isInstanceOf[MoveUndoneEvent]) shouldBe true
-
-  test("GameEngine redo notifies with MoveRedoneEvent after successful redo"):
-    val engine = new GameEngine()
-    engine.processUserInput("e2e4")
-    engine.processUserInput("e7e5")
-    val boardAfterSecondMove = engine.board
-
-    engine.undo()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    observer.events.clear()
-
-    engine.redo()
-
-    // Should have received a MoveRedoneEvent for the redo
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[MoveRedoneEvent]
-    engine.board shouldBe boardAfterSecondMove
-    engine.turn shouldBe Color.White
-
-  // ──── 50-move rule ───────────────────────────────────────────────────
-
-  test("GameEngine: 'draw' rejected when halfMoveClock < 100"):
-    val engine = new GameEngine()
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.processUserInput("draw")
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[InvalidMoveEvent]
-
-  test("GameEngine: 'draw' accepted and fires DrawClaimedEvent when halfMoveClock >= 100"):
-    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 100))
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.processUserInput("draw")
-    observer.events.size shouldBe 1
-    observer.events.head shouldBe a[DrawClaimedEvent]
-
-  test("GameEngine: state resets to initial after draw claimed"):
-    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 100))
-    engine.processUserInput("draw")
-    engine.board shouldBe Board.initial
-    engine.history shouldBe GameHistory.empty
-    engine.turn shouldBe Color.White
-
-  test("GameEngine: FiftyMoveRuleAvailableEvent fired when move brings clock to 100"):
-    // Start at clock 99; a knight move (non-pawn, non-capture) increments to 100
-    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 99))
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.processUserInput("g1f3")  // knight move on initial board
-    // Should receive MoveExecutedEvent AND FiftyMoveRuleAvailableEvent
-    observer.events.exists(_.isInstanceOf[FiftyMoveRuleAvailableEvent]) shouldBe true
-
-  test("GameEngine: FiftyMoveRuleAvailableEvent not fired when clock is below 100 after move"):
-    val engine = new GameEngine(initialHistory = GameHistory(halfMoveClock = 5))
-    val observer = new MockObserver()
-    engine.subscribe(observer)
-    engine.processUserInput("g1f3")
-    observer.events.exists(_.isInstanceOf[FiftyMoveRuleAvailableEvent]) shouldBe false
-
-  // Mock Observer for testing
-  private class MockObserver extends Observer:
-    val events = mutable.ListBuffer[GameEvent]()
-    override def onGameEvent(event: GameEvent): Unit =
-      events += event
-

modules/core/src/test/scala/de/nowchess/chess/engine/MoveCommandDefaultsTest.scala

@@ -1,110 +0,0 @@
-package de.nowchess.chess.command
-
-import de.nowchess.api.board.{Square, File, Rank, Board, Color}
-import de.nowchess.chess.logic.GameHistory
-import org.scalatest.funsuite.AnyFunSuite
-import org.scalatest.matchers.should.Matchers
-
-class MoveCommandDefaultsTest extends AnyFunSuite with Matchers:
-  
-  private def sq(f: File, r: Rank): Square = Square(f, r)
-
-  // Tests for MoveCommand with default parameter values
-  test("MoveCommand with no moveResult defaults to None"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4)
-    )
-    cmd.moveResult shouldBe None
-    cmd.execute() shouldBe false
-
-  test("MoveCommand with no previousBoard defaults to None"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4)
-    )
-    cmd.previousBoard shouldBe None
-    cmd.undo() shouldBe false
-
-  test("MoveCommand with no previousHistory defaults to None"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4)
-    )
-    cmd.previousHistory shouldBe None
-    cmd.undo() shouldBe false
-
-  test("MoveCommand with no previousTurn defaults to None"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4)
-    )
-    cmd.previousTurn shouldBe None
-    cmd.undo() shouldBe false
-
-  test("MoveCommand description is always returned"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4)
-    )
-    cmd.description shouldBe "Move from e2 to e4"
-
-  test("MoveCommand execute returns false when moveResult is None"):
-    val cmd = MoveCommand(
-      from = sq(File.A, Rank.R1),
-      to = sq(File.B, Rank.R3)
-    )
-    cmd.execute() shouldBe false
-
-  test("MoveCommand undo returns false when any previous state is None"):
-    // Missing previousBoard
-    val cmd1 = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)),
-      previousBoard = None,
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-    cmd1.undo() shouldBe false
-
-    // Missing previousHistory
-    val cmd2 = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)),
-      previousBoard = Some(Board.initial),
-      previousHistory = None,
-      previousTurn = Some(Color.White)
-    )
-    cmd2.undo() shouldBe false
-
-    // Missing previousTurn
-    val cmd3 = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)),
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = None
-    )
-    cmd3.undo() shouldBe false
-
-  test("MoveCommand execute returns true when moveResult is defined"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None))
-    )
-    cmd.execute() shouldBe true
-
-  test("MoveCommand undo returns true when all previous states are defined"):
-    val cmd = MoveCommand(
-      from = sq(File.E, Rank.R2),
-      to = sq(File.E, Rank.R4),
-      moveResult = Some(MoveResult.Successful(Board.initial, GameHistory.empty, Color.White, None)),
-      previousBoard = Some(Board.initial),
-      previousHistory = Some(GameHistory.empty),
-      previousTurn = Some(Color.White)
-    )
-    cmd.undo() shouldBe true

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