diff --git a/run.json b/run.json
index 8e432a62d..757419363 100644
--- a/run.json
+++ b/run.json
@@ -760,7 +760,7 @@
     "kind": "running"
   },
   "status_updated_at": "2026-06-04T18:37:50.931347Z",
-  "last_event_at": "2026-06-04T18:50:05.581393Z",
+  "last_event_at": "2026-06-04T18:51:07.327718Z",
   "pending_control": null,
   "checkpoints": [
     {
@@ -1442,9 +1442,9 @@
       }
     },
     {
-      "seq": 0,
+      "seq": 314,
       "checkpoint": {
-        "timestamp": "2026-06-04T18:50:05.683532Z",
+        "timestamp": "2026-06-04T18:50:16.595608Z",
         "current_node": "impl_data",
         "completed_nodes": [
           "start",
@@ -1455,16 +1455,268 @@
           "impl_data"
         ],
         "node_retries": {},
+        "context_values": {
+          "response.impl_data": "I have successfully completed the implementation of the FreeCell solitaire game data models and state engine according to the technical specification, added a comprehensive focused unit test suite, and verified that all tests pass perfectly.\n\n### Summary of Changes\n\n1. **Pure Domain Data Model & State Engine (`card-game-app/src/card_game_tui/domain.py`)**:\n   - Implemented `Suit`, `Rank`, and `Card` representations.\n   - Built the `Deck` class supporting deterministic seeding and standard 52-card dealing.\n   - Designed the `Position` representation, covering tableau columns (0–7), free cells (0–3), and foundations (0–3).\n   - Designed `MoveRecord` with full support for tracking regular moves and recursive `auto_moves` (auto-homing).\n   - Implemented `GameState` managing all piles, validations (`validate_move`), executions (`execute_move`), full asymmetric/nested undo/redo, and win-state detection.\n   - Implemented **Auto-Homing** rules exactly as specified: cards are moved automatically to foundations if and only if they are legal moves and all cards of the opposite color of lower ranks have already been homed.\n\n2. **Comprehensive Headless Unit Tests (`card-game-app/tests/test_domain.py`)**:\n   - Built a comprehensive unit test suite covering:\n     - Standard 52-card deck deal correctness.\n     - Deterministic seeding verification.\n     - Moves to and validations of Free Cells.\n     - Moves to and validations of Foundations.\n     - Single card move rules on the Tableau (descending rank, alternating colors).\n     - Sequence/multi-card moves Tableau-to-Tableau obeying the rules & formula: `(1 + Empty Free Cells) * 2^(Empty Tableau Columns)` with destination empty-column exception.\n     - Core Auto-Homing logic.\n     - Perfect full undo/redo capabilities, including reverting auto-homing sequences.\n     - Winning state detection.\n\n3. **Status Validation**:\n   - All 13 unit tests passed flawlessly inside the Python testing framework.\n   - The CLI non-interactive `--smoke` mode executes perfectly.\n   - Wrote `status.json` with `outcome=succeeded`.",
+          "internal.retry_count.check_setup": 0,
+          "internal.thread_id": "check_setup",
+          "graph.rankdir": "LR",
+          "graph.retry_target": "impl_setup",
+          "internal.retry_count.impl_data": 0,
+          "last_response": "I have successfully completed the implementation of the FreeCell solitaire game data models and state engine according to the technical specification, added a comprehensive focused unit test suite, an",
+          "thread.verify_setup.current_node": "check_setup",
+          "thread.start.current_node": "expand_spec",
+          "failure_signature": "",
+          "failure_class": "",
+          "graph.fallback_retry_target": "impl_logic",
+          "graph.goal": "Build a terminal-based FreeCell solitaire game in Python",
+          "current_node": "impl_data",
+          "internal.retry_count.expand_spec": 0,
+          "thread.check_setup.current_node": "impl_data",
+          "response.verify_setup": "I have successfully verified the setup for the card game app.\n\n### Verified Checklist:\n1. **`card-game-app/pyproject.toml` exists:** Verified.\n2. **`card-game-app/main.py` exists:** Verified.\n3. **`card-game-app/src/card_game_tui` exists:** Verified.\n4. **Python files compile:** Verified by executing `cd card-game-app && python3 -m py_compile main.py src/card_game_tui/*.py` (which completed with exit code `0`).\n\nFindings have been written to `.ai/verify_setup.md` and `status.json` has been updated with `\"outcome\": \"succeeded\"` at the workspace root.",
+          "internal.retry_count.start": 0,
+          "graph.default_max_retries": "3",
+          "internal.work_dir": "/home/daytona/workspace/fabro",
+          "internal.run_id": "01KT9YT14FHDYA4VTV9DSFG0FY",
+          "internal.retry_count.impl_setup": 0,
+          "outcome": "succeeded",
+          "response.impl_setup": "I have successfully built the Python project skeleton for the terminal-based FreeCell solitaire game.\n\nHere is a summary of the steps completed:\n1. **Created `card-game-app/` Project Structure**:\n   - `pyproject.toml` with pytest configured and `pythonpath = [\"src\"]`.\n   - `main.py` entrypoint supporting `--smoke` test mode (without curses dependency) and regular mode.\n   - `src/card_game_tui/` package containing `__init__.py`, `domain.py` (decoupled core game logic: `Suit`, `Rank`, `Card`, `Deck`, `LocationType`, `Position`, `MoveRecord`, and `GameState` class stubs), and `tui.py` (TUI layer placeholder).\n   - `tests/` directory with `__init__.py` and `test_domain.py` containing initial unit tests.\n   - `README.md` stub explaining structure and usage.\n2. **Verified Code Compilation**:\n   - Executed: `cd card-game-app && python3 -m py_compile main.py src/card_game_tui/*.py` which compiled cleanly with exit code 0.\n3. **Smoke Tested the CLI**:\n   - Executed: `cd card-game-app && python3 main.py --smoke` which ran successfully, verifying the integrity of the domain model layout and assertions.\n4. **Wrote `status.json`**:\n   - Created `status.json` at the workspace root containing `{\"outcome\": \"succeeded\"}` as the project skeleton exists and compiles perfectly.",
+          "internal.fidelity": "compact",
+          "internal.retry_count.verify_setup": 0,
+          "thread.expand_spec.current_node": "impl_setup",
+          "last_stage": "impl_data",
+          "response.expand_spec": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Document**: `.ai/card-game-spec.md`\n- **Execution Status**: `status.json` with `\"outcome\": \"succeeded\"`\n\n### Key Specification Highlights:\n1. **Core Domain Model & Game Logic**: Complete decoupling from the curses framework. Classes like `Card`, `Suit`, `Rank`, `Deck`, `Position`, and `GameState` manage state transitions, move constraints, and game rules natively and cleanly, making them fully testable in headless CI environments.\n2. **Move Validation & Rule Logic**: Enforces all FreeCell moves, empty pile behavior, card stacking (alternating colors and descending ranks), and includes the mathematical sequence-movement rule constraint formula: \n   $$\\text{Max Cards} = (1 + \\text{Empty Free Cells}) \\times 2^{\\text{Empty Tableau Columns}}$$\n3. **Auto-Homing Mechanics**: An optional, safe automated helper that automatically moves cards to the foundations once they can no longer act as sequence-building stepping stones.\n4. **Interactive Curses UI/TUI**: A detailed layout conforming to $80 \\times 24$ terminal dimensions using memory-efficient double-buffered updates via curses, rich color pair rendering for Red vs Black suits, and a versatile keyboard cursor-based layout navigation system.\n5. **Non-Interactive Smoke Mode**: Specifies the exact behavior of `python3 main.py --smoke` for fast automated integration checks without launching interactive screens.\n6. **Robust Testing Strategy**: Details unit tests covering edge cases for game rules, deterministic seed validation, and UI input mocking scenarios.",
+          "thread.verify.current_node": "verify_setup",
+          "internal.node_visit_count": 1
+        },
+        "node_outcomes": {
+          "start": {
+            "status": "succeeded",
+            "usage": null
+          },
+          "check_setup": {
+            "status": "succeeded",
+            "notes": "Conditional node evaluated: check_setup",
+            "usage": null
+          },
+          "expand_spec": {
+            "status": "succeeded",
+            "context_updates": {
+              "last_stage": "expand_spec",
+              "response.expand_spec": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Document**: `.ai/card-game-spec.md`\n- **Execution Status**: `status.json` with `\"outcome\": \"succeeded\"`\n\n### Key Specification Highlights:\n1. **Core Domain Model & Game Logic**: Complete decoupling from the curses framework. Classes like `Card`, `Suit`, `Rank`, `Deck`, `Position`, and `GameState` manage state transitions, move constraints, and game rules natively and cleanly, making them fully testable in headless CI environments.\n2. **Move Validation & Rule Logic**: Enforces all FreeCell moves, empty pile behavior, card stacking (alternating colors and descending ranks), and includes the mathematical sequence-movement rule constraint formula: \n   $$\\text{Max Cards} = (1 + \\text{Empty Free Cells}) \\times 2^{\\text{Empty Tableau Columns}}$$\n3. **Auto-Homing Mechanics**: An optional, safe automated helper that automatically moves cards to the foundations once they can no longer act as sequence-building stepping stones.\n4. **Interactive Curses UI/TUI**: A detailed layout conforming to $80 \\times 24$ terminal dimensions using memory-efficient double-buffered updates via curses, rich color pair rendering for Red vs Black suits, and a versatile keyboard cursor-based layout navigation system.\n5. **Non-Interactive Smoke Mode**: Specifies the exact behavior of `python3 main.py --smoke` for fast automated integration checks without launching interactive screens.\n6. **Robust Testing Strategy**: Details unit tests covering edge cases for game rules, deterministic seed validation, and UI input mocking scenarios.",
+              "last_response": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Doc"
+            },
+            "notes": "Stage completed: expand_spec",
+            "usage": {
+              "input": {
+                "usage": {
+                  "model": {
+                    "provider": "gemini",
+                    "model_id": "gemini-3.5-flash"
+                  },
+                  "tokens": {
+                    "input_tokens": 85925,
+                    "output_tokens": 4840,
+                    "reasoning_tokens": 3421,
+                    "cache_read_tokens": 20271,
+                    "cache_write_tokens": 0
+                  }
+                },
+                "facts": {
+                  "algorithm": "gemini",
+                  "storage_segments": []
+                }
+              },
+              "total_usd_micros": 206276
+            },
+            "files_touched": [
+              "/home/daytona/workspace/fabro/.ai/card-game-spec.md",
+              "/home/daytona/workspace/fabro/status.json"
+            ],
+            "timing": {
+              "wall_time_ms": 0,
+              "inference_time_ms": 111896,
+              "tool_time_ms": 4207,
+              "active_time_ms": 116103
+            }
+          },
+          "impl_setup": {
+            "status": "succeeded",
+            "context_updates": {
+              "last_response": "I have successfully built the Python project skeleton for the terminal-based FreeCell solitaire game.\n\nHere is a summary of the steps completed:\n1. **Created `card-game-app/` Project Structure**:\n   -",
+              "last_stage": "impl_setup",
+              "response.impl_setup": "I have successfully built the Python project skeleton for the terminal-based FreeCell solitaire game.\n\nHere is a summary of the steps completed:\n1. **Created `card-game-app/` Project Structure**:\n   - `pyproject.toml` with pytest configured and `pythonpath = [\"src\"]`.\n   - `main.py` entrypoint supporting `--smoke` test mode (without curses dependency) and regular mode.\n   - `src/card_game_tui/` package containing `__init__.py`, `domain.py` (decoupled core game logic: `Suit`, `Rank`, `Card`, `Deck`, `LocationType`, `Position`, `MoveRecord`, and `GameState` class stubs), and `tui.py` (TUI layer placeholder).\n   - `tests/` directory with `__init__.py` and `test_domain.py` containing initial unit tests.\n   - `README.md` stub explaining structure and usage.\n2. **Verified Code Compilation**:\n   - Executed: `cd card-game-app && python3 -m py_compile main.py src/card_game_tui/*.py` which compiled cleanly with exit code 0.\n3. **Smoke Tested the CLI**:\n   - Executed: `cd card-game-app && python3 main.py --smoke` which ran successfully, verifying the integrity of the domain model layout and assertions.\n4. **Wrote `status.json`**:\n   - Created `status.json` at the workspace root containing `{\"outcome\": \"succeeded\"}` as the project skeleton exists and compiles perfectly."
+            },
+            "notes": "Stage completed: impl_setup",
+            "usage": {
+              "input": {
+                "usage": {
+                  "model": {
+                    "provider": "gemini",
+                    "model_id": "gemini-3.5-flash"
+                  },
+                  "tokens": {
+                    "input_tokens": 144122,
+                    "output_tokens": 3364,
+                    "reasoning_tokens": 3387,
+                    "cache_read_tokens": 129733,
+                    "cache_write_tokens": 0
+                  }
+                },
+                "facts": {
+                  "algorithm": "gemini",
+                  "storage_segments": []
+                }
+              },
+              "total_usd_micros": 296401
+            },
+            "files_touched": [
+              "/home/daytona/workspace/fabro/card-game-app/README.md",
+              "/home/daytona/workspace/fabro/card-game-app/main.py",
+              "/home/daytona/workspace/fabro/card-game-app/pyproject.toml",
+              "/home/daytona/workspace/fabro/card-game-app/src/card_game_tui/__init__.py",
+              "/home/daytona/workspace/fabro/card-game-app/src/card_game_tui/domain.py",
+              "/home/daytona/workspace/fabro/card-game-app/src/card_game_tui/tui.py",
+              "/home/daytona/workspace/fabro/card-game-app/tests/__init__.py",
+              "/home/daytona/workspace/fabro/card-game-app/tests/test_domain.py",
+              "/home/daytona/workspace/fabro/status.json"
+            ],
+            "timing": {
+              "wall_time_ms": 0,
+              "inference_time_ms": 54533,
+              "tool_time_ms": 18730,
+              "active_time_ms": 73263
+            }
+          },
+          "impl_data": {
+            "status": "succeeded",
+            "context_updates": {
+              "response.impl_data": "I have successfully completed the implementation of the FreeCell solitaire game data models and state engine according to the technical specification, added a comprehensive focused unit test suite, and verified that all tests pass perfectly.\n\n### Summary of Changes\n\n1. **Pure Domain Data Model & State Engine (`card-game-app/src/card_game_tui/domain.py`)**:\n   - Implemented `Suit`, `Rank`, and `Card` representations.\n   - Built the `Deck` class supporting deterministic seeding and standard 52-card dealing.\n   - Designed the `Position` representation, covering tableau columns (0–7), free cells (0–3), and foundations (0–3).\n   - Designed `MoveRecord` with full support for tracking regular moves and recursive `auto_moves` (auto-homing).\n   - Implemented `GameState` managing all piles, validations (`validate_move`), executions (`execute_move`), full asymmetric/nested undo/redo, and win-state detection.\n   - Implemented **Auto-Homing** rules exactly as specified: cards are moved automatically to foundations if and only if they are legal moves and all cards of the opposite color of lower ranks have already been homed.\n\n2. **Comprehensive Headless Unit Tests (`card-game-app/tests/test_domain.py`)**:\n   - Built a comprehensive unit test suite covering:\n     - Standard 52-card deck deal correctness.\n     - Deterministic seeding verification.\n     - Moves to and validations of Free Cells.\n     - Moves to and validations of Foundations.\n     - Single card move rules on the Tableau (descending rank, alternating colors).\n     - Sequence/multi-card moves Tableau-to-Tableau obeying the rules & formula: `(1 + Empty Free Cells) * 2^(Empty Tableau Columns)` with destination empty-column exception.\n     - Core Auto-Homing logic.\n     - Perfect full undo/redo capabilities, including reverting auto-homing sequences.\n     - Winning state detection.\n\n3. **Status Validation**:\n   - All 13 unit tests passed flawlessly inside the Python testing framework.\n   - The CLI non-interactive `--smoke` mode executes perfectly.\n   - Wrote `status.json` with `outcome=succeeded`.",
+              "last_stage": "impl_data",
+              "last_response": "I have successfully completed the implementation of the FreeCell solitaire game data models and state engine according to the technical specification, added a comprehensive focused unit test suite, an"
+            },
+            "notes": "Stage completed: impl_data",
+            "usage": {
+              "input": {
+                "usage": {
+                  "model": {
+                    "provider": "gemini",
+                    "model_id": "gemini-3.5-flash"
+                  },
+                  "tokens": {
+                    "input_tokens": 179865,
+                    "output_tokens": 10451,
+                    "reasoning_tokens": 21516,
+                    "cache_read_tokens": 641688,
+                    "cache_write_tokens": 0
+                  }
+                },
+                "facts": {
+                  "algorithm": "gemini",
+                  "storage_segments": []
+                }
+              },
+              "total_usd_micros": 653753
+            },
+            "files_touched": [
+              "/home/daytona/workspace/fabro/card-game-app/src/card_game_tui/domain.py",
+              "/home/daytona/workspace/fabro/card-game-app/tests/test_domain.py",
+              "/home/daytona/workspace/fabro/status.json"
+            ],
+            "timing": {
+              "wall_time_ms": 0,
+              "inference_time_ms": 193731,
+              "tool_time_ms": 20404,
+              "active_time_ms": 214135
+            }
+          },
+          "verify_setup": {
+            "status": "succeeded",
+            "context_updates": {
+              "last_stage": "verify_setup",
+              "response.verify_setup": "I have successfully verified the setup for the card game app.\n\n### Verified Checklist:\n1. **`card-game-app/pyproject.toml` exists:** Verified.\n2. **`card-game-app/main.py` exists:** Verified.\n3. **`card-game-app/src/card_game_tui` exists:** Verified.\n4. **Python files compile:** Verified by executing `cd card-game-app && python3 -m py_compile main.py src/card_game_tui/*.py` (which completed with exit code `0`).\n\nFindings have been written to `.ai/verify_setup.md` and `status.json` has been updated with `\"outcome\": \"succeeded\"` at the workspace root.",
+              "last_response": "I have successfully verified the setup for the card game app.\n\n### Verified Checklist:\n1. **`card-game-app/pyproject.toml` exists:** Verified.\n2. **`card-game-app/main.py` exists:** Verified.\n3. **`ca"
+            },
+            "notes": "Stage completed: verify_setup",
+            "usage": {
+              "input": {
+                "usage": {
+                  "model": {
+                    "provider": "gemini",
+                    "model_id": "gemini-3.5-flash"
+                  },
+                  "tokens": {
+                    "input_tokens": 185923,
+                    "output_tokens": 1136,
+                    "reasoning_tokens": 1068,
+                    "cache_read_tokens": 4044,
+                    "cache_write_tokens": 0
+                  }
+                },
+                "facts": {
+                  "algorithm": "gemini",
+                  "storage_segments": []
+                }
+              },
+              "total_usd_micros": 299326
+            },
+            "files_touched": [
+              "/home/daytona/workspace/fabro/.ai/verify_setup.md",
+              "/home/daytona/workspace/fabro/status.json"
+            ],
+            "timing": {
+              "wall_time_ms": 0,
+              "inference_time_ms": 33160,
+              "tool_time_ms": 20341,
+              "active_time_ms": 53501
+            }
+          }
+        },
+        "next_node_id": "verify_data",
+        "git_commit_sha": "f2b42d643921fb41e45cb4cf43c75efafe27696e",
+        "node_visits": {
+          "verify_setup": 1,
+          "start": 1,
+          "impl_setup": 1,
+          "check_setup": 1,
+          "expand_spec": 1,
+          "impl_data": 1
+        }
+      },
+      "diff": {
+        "patch": "diff --git a/card-game-app/src/card_game_tui/domain.py b/card-game-app/src/card_game_tui/domain.py\nindex db4a2fa8f..fe733cef3 100644\n--- a/card-game-app/src/card_game_tui/domain.py\n+++ b/card-game-app/src/card_game_tui/domain.py\n@@ -1,5 +1,5 @@\n import random\n-from dataclasses import dataclass\n+from dataclasses import dataclass, field\n from enum import Enum, auto\n from typing import List, Union, Dict\n \n@@ -84,6 +84,10 @@ class MoveRecord:\n     cards: List[Card]  # Captured for single or sequence moves\n     auto_moves: List['MoveRecord'] = None  # Nested moves triggered by auto-homing\n \n+    def __post_init__(self):\n+        if self.auto_moves is None:\n+            self.auto_moves = []\n+\n class GameState:\n     def __init__(self, seed: int = None):\n         self.tableaus: List[List[Card]] = Deck(seed).deal()\n@@ -107,7 +111,108 @@ class GameState:\n         \"\"\"\n         Calculates whether moving 'count' cards from from_pos to to_pos is legal.\n         \"\"\"\n-        # Placeholder for validation\n+        if count < 1:\n+            return False\n+\n+        if from_pos == to_pos:\n+            return False\n+\n+        # Validate index boundaries\n+        if from_pos.type == LocationType.TABLEAU:\n+            if not (0 <= from_pos.index < 8):\n+                return False\n+        elif from_pos.type == LocationType.FREECELL:\n+            if not (0 <= from_pos.index < 4):\n+                return False\n+            if count != 1:\n+                return False\n+        elif from_pos.type == LocationType.FOUNDATION:\n+            return False\n+        else:\n+            return False\n+\n+        if to_pos.type == LocationType.TABLEAU:\n+            if not (0 <= to_pos.index < 8):\n+                return False\n+        elif to_pos.type == LocationType.FREECELL:\n+            if not (0 <= to_pos.index < 4):\n+                return False\n+            if count != 1:\n+                return False\n+        elif to_pos.type == LocationType.FOUNDATION:\n+            if not (0 <= to_pos.index < 4):\n+                return False\n+            if count != 1:\n+                return False\n+        else:\n+            return False\n+\n+        # Extract moving cards\n+        if from_pos.type == LocationType.FREECELL:\n+            card = self.freecells[from_pos.index]\n+            if card is None:\n+                return False\n+            moving_cards = [card]\n+        elif from_pos.type == LocationType.TABLEAU:\n+            col = self.tableaus[from_pos.index]\n+            if len(col) < count:\n+                return False\n+            moving_cards = col[-count:]\n+        else:\n+            return False\n+\n+        # Validate sequence if moving multiple cards\n+        if count > 1:\n+            for i in range(count - 1):\n+                c1 = moving_cards[i]\n+                c2 = moving_cards[i+1]\n+                if c2.rank.value != c1.rank.value - 1:\n+                    return False\n+                if c2.suit.color == c1.suit.color:\n+                    return False\n+\n+        # Validate destination constraints\n+        if to_pos.type == LocationType.FREECELL:\n+            if self.freecells[to_pos.index] is not None:\n+                return False\n+\n+        elif to_pos.type == LocationType.FOUNDATION:\n+            target_suit = list(Suit)[to_pos.index]\n+            card = moving_cards[0]\n+            if card.suit != target_suit:\n+                return False\n+            \n+            foundation_pile = self.foundations[target_suit]\n+            if card.rank == Rank.ACE:\n+                if len(foundation_pile) != 0:\n+                    return False\n+            else:\n+                if len(foundation_pile) != card.rank.value - 1:\n+                    return False\n+\n+        elif to_pos.type == LocationType.TABLEAU:\n+            dest_col = self.tableaus[to_pos.index]\n+            first_moving_card = moving_cards[0]\n+            if len(dest_col) > 0:\n+                dest_top_card = dest_col[-1]\n+                if first_moving_card.rank.value != dest_top_card.rank.value - 1:\n+                    return False\n+                if first_moving_card.suit.color == dest_top_card.suit.color:\n+                    return False\n+\n+            # Capacity constraint\n+            empty_freecells = sum(1 for c in self.freecells if c is None)\n+            empty_tableaus = sum(1 for col in self.tableaus if len(col) == 0)\n+\n+            if len(dest_col) == 0:\n+                transit_empty_tableaus = max(0, empty_tableaus - 1)\n+            else:\n+                transit_empty_tableaus = empty_tableaus\n+\n+            max_cards = (1 + empty_freecells) * (2 ** transit_empty_tableaus)\n+            if count > max_cards:\n+                return False\n+\n         return True\n \n     def execute_move(self, from_pos: Position, to_pos: Position, count: int = 1) -> bool:\n@@ -116,12 +221,156 @@ class GameState:\n         \"\"\"\n         if not self.validate_move(from_pos, to_pos, count):\n             return False\n+\n+        # Extract moving cards\n+        if from_pos.type == LocationType.FREECELL:\n+            moving_cards = [self.freecells[from_pos.index]]\n+        elif from_pos.type == LocationType.TABLEAU:\n+            moving_cards = self.tableaus[from_pos.index][-count:]\n+        else:\n+            return False\n+\n+        move_record = MoveRecord(from_pos=from_pos, to_pos=to_pos, cards=moving_cards)\n+        \n+        # Apply the move\n+        self._apply_single_move(move_record)\n+        \n+        # Run auto-homing\n+        self._run_auto_homing(move_record)\n+        \n+        # Record on stacks\n+        self.undo_stack.append(move_record)\n+        self.redo_stack.clear()\n+        return True\n+\n+    def _apply_single_move(self, record: MoveRecord):\n+        # Remove from from_pos\n+        if record.from_pos.type == LocationType.FREECELL:\n+            self.freecells[record.from_pos.index] = None\n+        elif record.from_pos.type == LocationType.TABLEAU:\n+            count = len(record.cards)\n+            self.tableaus[record.from_pos.index] = self.tableaus[record.from_pos.index][:-count]\n+\n+        # Put to to_pos\n+        if record.to_pos.type == LocationType.FREECELL:\n+            self.freecells[record.to_pos.index] = record.cards[0]\n+        elif record.to_pos.type == LocationType.FOUNDATION:\n+            target_suit = list(Suit)[record.to_pos.index]\n+            self.foundations[target_suit].append(record.cards[0])\n+        elif record.to_pos.type == LocationType.TABLEAU:\n+            self.tableaus[record.to_pos.index].extend(record.cards)\n+\n+    def _revert_single_move(self, record: MoveRecord):\n+        # Remove from to_pos\n+        if record.to_pos.type == LocationType.FREECELL:\n+            self.freecells[record.to_pos.index] = None\n+        elif record.to_pos.type == LocationType.FOUNDATION:\n+            target_suit = list(Suit)[record.to_pos.index]\n+            self.foundations[target_suit].pop()\n+        elif record.to_pos.type == LocationType.TABLEAU:\n+            count = len(record.cards)\n+            self.tableaus[record.to_pos.index] = self.tableaus[record.to_pos.index][:-count]\n+\n+        # Put to from_pos\n+        if record.from_pos.type == LocationType.FREECELL:\n+            self.freecells[record.from_pos.index] = record.cards[0]\n+        elif record.from_pos.type == LocationType.TABLEAU:\n+            self.tableaus[record.from_pos.index].extend(record.cards)\n+\n+    def _should_auto_home(self, card: Card) -> bool:\n+        \"\"\"\n+        Checks if a card can be safely auto-homed to the foundations.\n+        \"\"\"\n+        target_foundation = self.foundations[card.suit]\n+        if card.rank.value != len(target_foundation) + 1:\n+            return False\n+\n+        # Opposite color suits must have all lower cards in the foundations\n+        if card.suit.color == \"RED\":\n+            opp_suits = [Suit.CLUBS, Suit.SPADES]\n+        else:\n+            opp_suits = [Suit.HEARTS, Suit.DIAMONDS]\n+\n+        for s_opp in opp_suits:\n+            if len(self.foundations[s_opp]) < card.rank.value - 1:\n+                return False\n+\n         return True\n \n+    def _run_auto_homing(self, move_record: MoveRecord):\n+        \"\"\"\n+        Scans freecells and tableau tops, moving eligible cards to foundations.\n+        Repeats until no more cards can be auto-homed.\n+        \"\"\"\n+        any_homed = True\n+        while any_homed:\n+            any_homed = False\n+            \n+            # Check free cells\n+            for i, card in enumerate(self.freecells):\n+                if card is not None and self._should_auto_home(card):\n+                    from_p = Position(LocationType.FREECELL, i)\n+                    suit_idx = list(Suit).index(card.suit)\n+                    to_p = Position(LocationType.FOUNDATION, suit_idx)\n+                    \n+                    auto_rec = MoveRecord(from_pos=from_p, to_pos=to_p, cards=[card])\n+                    self._apply_single_move(auto_rec)\n+                    move_record.auto_moves.append(auto_rec)\n+                    \n+                    any_homed = True\n+                    break\n+            \n+            if any_homed:\n+                continue\n+\n+            # Check tableaus\n+            for i, col in enumerate(self.tableaus):\n+                if col:\n+                    card = col[-1]\n+                    if self._should_auto_home(card):\n+                        from_p = Position(LocationType.TABLEAU, i)\n+                        suit_idx = list(Suit).index(card.suit)\n+                        to_p = Position(LocationType.FOUNDATION, suit_idx)\n+                        \n+                        auto_rec = MoveRecord(from_pos=from_p, to_pos=to_p, cards=[card])\n+                        self._apply_single_move(auto_rec)\n+                        move_record.auto_moves.append(auto_rec)\n+                        \n+                        any_homed = True\n+                        break\n+\n     def undo(self) -> bool:\n         \"\"\"Reverts the last move, including nested auto-homing steps.\"\"\"\n         if not self.undo_stack:\n             return False\n+        \n+        move_record = self.undo_stack.pop()\n+        \n+        # Revert auto moves in reverse order\n+        for auto_move in reversed(move_record.auto_moves):\n+            self._revert_single_move(auto_move)\n+            \n+        # Revert the main move\n+        self._revert_single_move(move_record)\n+        \n+        self.redo_stack.append(move_record)\n+        return True\n+\n+    def redo(self) -> bool:\n+        \"\"\"Reapplies the last undone move.\"\"\"\n+        if not self.redo_stack:\n+            return False\n+            \n+        move_record = self.redo_stack.pop()\n+        \n+        # Apply the main move\n+        self._apply_single_move(move_record)\n+        \n+        # Re-apply auto moves\n+        for auto_move in move_record.auto_moves:\n+            self._apply_single_move(auto_move)\n+            \n+        self.undo_stack.append(move_record)\n         return True\n \n     def check_win(self) -> bool:\ndiff --git a/card-game-app/tests/test_domain.py b/card-game-app/tests/test_domain.py\nindex 3ddb4344b..0fa4360ed 100644\n--- a/card-game-app/tests/test_domain.py\n+++ b/card-game-app/tests/test_domain.py\n@@ -1,3 +1,4 @@\n+import copy\n from card_game_tui.domain import GameState, Suit, Rank, Card, Deck, LocationType, Position\n \n def test_deck_deals_52_cards():\n@@ -18,3 +19,331 @@ def test_get_card_at():\n     card = state.get_card_at(pos)\n     assert card is not None\n     assert isinstance(card, Card)\n+\n+def test_deck_deterministic_seeding():\n+    deck1 = Deck(seed=42)\n+    deck2 = Deck(seed=42)\n+    assert deck1.cards == deck2.cards\n+\n+    # Verify uniqueness of 52 cards\n+    assert len(set(deck1.cards)) == 52\n+\n+def test_moves_to_free_cells():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    # Put a card in Tableau 0\n+    c_hearts = Card(Suit.HEARTS, Rank.TEN)\n+    state.tableaus[0] = [c_hearts]\n+\n+    from_pos = Position(LocationType.TABLEAU, 0)\n+    to_pos = Position(LocationType.FREECELL, 0)\n+\n+    # Valid single card move to empty freecell\n+    assert state.validate_move(from_pos, to_pos, count=1) is True\n+    \n+    # Try invalid sequence count to free cell\n+    assert state.validate_move(from_pos, to_pos, count=2) is False\n+\n+    # Execute move\n+    assert state.execute_move(from_pos, to_pos, count=1) is True\n+    assert state.freecells[0] == c_hearts\n+    assert len(state.tableaus[0]) == 0\n+\n+    # Try moving to occupied freecell\n+    state.tableaus[0] = [Card(Suit.SPADES, Rank.FIVE)]\n+    assert state.validate_move(from_pos, to_pos, count=1) is False\n+\n+    # Try moving to invalid freecell index\n+    invalid_to_pos = Position(LocationType.FREECELL, 4)\n+    assert state.validate_move(from_pos, invalid_to_pos, count=1) is False\n+\n+def test_moves_to_foundations():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    ace_hearts = Card(Suit.HEARTS, Rank.ACE)\n+    two_hearts = Card(Suit.HEARTS, Rank.TWO)\n+    three_hearts = Card(Suit.HEARTS, Rank.THREE)\n+    ace_diamonds = Card(Suit.DIAMONDS, Rank.ACE)\n+\n+    state.tableaus[0] = [ace_hearts]\n+    state.tableaus[1] = [two_hearts]\n+    state.tableaus[2] = [three_hearts]\n+    state.tableaus[3] = [ace_diamonds]\n+\n+    # Move Ace of Hearts to index 0 (HEARTS) foundation\n+    # list(Suit) indices: 0: HEARTS, 1: DIAMONDS, 2: CLUBS, 3: SPADES\n+    hearts_found = Position(LocationType.FOUNDATION, 0)\n+    diamonds_found = Position(LocationType.FOUNDATION, 1)\n+\n+    # Valid Ace to empty foundation\n+    assert state.validate_move(Position(LocationType.TABLEAU, 0), hearts_found, count=1) is True\n+    # Invalid non-Ace to empty foundation\n+    assert state.validate_move(Position(LocationType.TABLEAU, 1), hearts_found, count=1) is False\n+    # Invalid Ace to wrong suit foundation\n+    assert state.validate_move(Position(LocationType.TABLEAU, 3), hearts_found, count=1) is False\n+\n+    # Execute valid Ace move\n+    assert state.execute_move(Position(LocationType.TABLEAU, 0), hearts_found, count=1) is True\n+    assert state.foundations[Suit.HEARTS] == [ace_hearts]\n+\n+    # Now Two of Hearts is on Tableau 1. Can it move to Hearts foundation? Yes.\n+    assert state.validate_move(Position(LocationType.TABLEAU, 1), hearts_found, count=1) is True\n+    # Can Three of Hearts move? No, since it needs Two of Hearts first.\n+    assert state.validate_move(Position(LocationType.TABLEAU, 2), hearts_found, count=1) is False\n+\n+def test_moves_to_tableau_single_card():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    # Red 8 (Hearts) on Black 9 (Spades)\n+    c_red8 = Card(Suit.HEARTS, Rank.EIGHT)\n+    c_black9 = Card(Suit.SPADES, Rank.NINE)\n+    \n+    state.tableaus[0] = [c_red8]\n+    state.tableaus[1] = [c_black9]\n+\n+    # Test moving Red 8 onto Black 9\n+    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is True\n+\n+    # Test same color invalid move: Red 8 (Hearts) on Red 9 (Diamonds)\n+    c_red9 = Card(Suit.DIAMONDS, Rank.NINE)\n+    state.tableaus[1] = [c_red9]\n+    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is False\n+\n+    # Test wrong rank invalid move: Red 8 on Black 10 (Spades)\n+    c_black10 = Card(Suit.SPADES, Rank.TEN)\n+    state.tableaus[1] = [c_black10]\n+    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is False\n+\n+    # Test moving to empty tableau\n+    state.tableaus[1] = []\n+    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is True\n+\n+def test_sequence_moves_tableau_to_tableau():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+    \n+    # Red 10, Black 9, Red 8, Black 7, Red 6\n+    c10 = Card(Suit.HEARTS, Rank.TEN)\n+    c9 = Card(Suit.SPADES, Rank.NINE)\n+    c8 = Card(Suit.DIAMONDS, Rank.EIGHT)\n+    c7 = Card(Suit.CLUBS, Rank.SEVEN)\n+    c6 = Card(Suit.HEARTS, Rank.SIX)\n+    \n+    state.tableaus[0] = [c10, c9, c8, c7, c6]\n+    state.tableaus[1] = [Card(Suit.SPADES, Rank.JACK)]\n+    \n+    # 4 empty freecells, 6 empty tableaus.\n+    # Exclude destination: no, destination is Col 1 which has 1 card (not empty).\n+    # Transit empty tableaus = 6\n+    # Max cards = (1 + 4) * 2^6 = 5 * 64 = 320 cards.\n+    # Moving 5 cards should be valid!\n+    from_pos = Position(LocationType.TABLEAU, 0)\n+    to_pos = Position(LocationType.TABLEAU, 1)\n+    assert state.validate_move(from_pos, to_pos, count=5) is True\n+    \n+    # Restrict capacity\n+    state.freecells = [Card(Suit.CLUBS, Rank.TWO)] * 4  # 0 empty freecells\n+    for i in range(2, 8):\n+        state.tableaus[i] = [Card(Suit.DIAMONDS, Rank.KING)]  # 0 empty tableaus\n+    # Now empty freecells = 0, empty tableaus = 0\n+    # Max cards = (1 + 0) * 2^0 = 1\n+    # Moving 5 cards should be invalid\n+    assert state.validate_move(from_pos, to_pos, count=5) is False\n+\n+def test_sequence_moves_to_empty_tableau():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    # Sequence of 3 cards on Col 0: Red 10, Black 9, Red 8\n+    c10 = Card(Suit.HEARTS, Rank.TEN)\n+    c9 = Card(Suit.SPADES, Rank.NINE)\n+    c8 = Card(Suit.DIAMONDS, Rank.EIGHT)\n+    state.tableaus[0] = [c10, c9, c8]\n+\n+    # Destination is Col 1 (empty)\n+    # We want to move 2 cards: Black 9, Red 8\n+    # Capacity constraint:\n+    # Destination Col 1 is empty, so transit_empty_tableaus = empty_tableaus - 1.\n+    # Empty tableaus before move = 7.\n+    # Transit empty tableaus = 6.\n+    # Empty free cells = 4.\n+    # Max cards = (1 + 4) * 2^6 = 320.\n+    from_pos = Position(LocationType.TABLEAU, 0)\n+    to_pos = Position(LocationType.TABLEAU, 1)\n+    assert state.validate_move(from_pos, to_pos, count=2) is True\n+\n+    # Restrict capacity so Max Cards is exactly 1\n+    state.freecells = [Card(Suit.CLUBS, Rank.TWO)] * 4  # 0 empty free cells\n+    for i in range(2, 8):\n+        state.tableaus[i] = [Card(Suit.DIAMONDS, Rank.KING)]  # 0 transit empty tableaus\n+    # Empty freecells = 0, empty tableaus = 1 (Col 1).\n+    # Since Col 1 is the destination, transit_empty_tableaus = 1 - 1 = 0.\n+    # Max cards = (1 + 0) * 2^0 = 1.\n+    # Moving 2 cards should be invalid, but 1 card should be valid.\n+    assert state.validate_move(from_pos, to_pos, count=2) is False\n+    assert state.validate_move(from_pos, to_pos, count=1) is True\n+\n+def test_auto_homing_logic():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    # Hearts is RED. Opposite suits are CLUBS and SPADES.\n+    # Put Ace of Hearts in Tableau 0.\n+    state.tableaus[0] = [Card(Suit.HEARTS, Rank.ACE)]\n+    # Put King of Spades in Tableau 1 to use as a dummy move trigger.\n+    state.tableaus[1] = [Card(Suit.SPADES, Rank.KING)]\n+    \n+    assert len(state.foundations[Suit.HEARTS]) == 0\n+    \n+    # Execute move of King of Spades to FreeCell 0. This should trigger auto-homing of Ace of Hearts.\n+    from_pos = Position(LocationType.TABLEAU, 1)\n+    to_pos = Position(LocationType.FREECELL, 0)\n+    success = state.execute_move(from_pos, to_pos, count=1)\n+    assert success is True\n+    \n+    assert state.freecells[0] == Card(Suit.SPADES, Rank.KING)\n+    assert len(state.tableaus[0]) == 0\n+    assert len(state.foundations[Suit.HEARTS]) == 1\n+    assert state.foundations[Suit.HEARTS][0] == Card(Suit.HEARTS, Rank.ACE)\n+    \n+    # Two of Hearts is put in Tableau 0.\n+    # Foundations: Hearts has Ace. CLUBS has [], SPADES has [].\n+    # Opposite color (Black) lower cards are Ace of Clubs and Ace of Spades.\n+    # Since they are NOT in the foundations, Two of Hearts should NOT auto-home.\n+    state.tableaus[0] = [Card(Suit.HEARTS, Rank.TWO)]\n+    \n+    # Move King of Spades from FreeCell 0 to Tableau 1 to trigger auto-homing checks\n+    from_pos = Position(LocationType.FREECELL, 0)\n+    to_pos = Position(LocationType.TABLEAU, 1)\n+    success = state.execute_move(from_pos, to_pos, count=1)\n+    assert success is True\n+    \n+    # Two of Hearts should still be in Tableau 0 (not auto-homed)\n+    assert len(state.tableaus[0]) == 1\n+    assert state.tableaus[0][0] == Card(Suit.HEARTS, Rank.TWO)\n+    assert len(state.foundations[Suit.HEARTS]) == 1\n+    \n+    # Place Ace of Clubs and Ace of Spades in their foundations.\n+    state.foundations[Suit.CLUBS] = [Card(Suit.CLUBS, Rank.ACE)]\n+    state.foundations[Suit.SPADES] = [Card(Suit.SPADES, Rank.ACE)]\n+    \n+    # Move King of Spades back to FreeCell 0 to trigger auto-homing checks\n+    from_pos = Position(LocationType.TABLEAU, 1)\n+    to_pos = Position(LocationType.FREECELL, 0)\n+    success = state.execute_move(from_pos, to_pos, count=1)\n+    assert success is True\n+    \n+    # Two of Hearts should now have auto-homed!\n+    assert len(state.tableaus[0]) == 0\n+    assert len(state.foundations[Suit.HEARTS]) == 2\n+    assert state.foundations[Suit.HEARTS][1] == Card(Suit.HEARTS, Rank.TWO)\n+\n+def test_undo_redo_system():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    # Col 0: [Red 10 (Hearts)]\n+    # Col 1: [Black J (Spades)]\n+    c10 = Card(Suit.HEARTS, Rank.TEN)\n+    cJ = Card(Suit.SPADES, Rank.JACK)\n+    state.tableaus[0] = [c10]\n+    state.tableaus[1] = [cJ]\n+\n+    # Save original state for verification\n+    orig_tableaus = copy.deepcopy(state.tableaus)\n+    orig_freecells = copy.deepcopy(state.freecells)\n+    orig_foundations = copy.deepcopy(state.foundations)\n+\n+    # 1. Execute a move\n+    from_pos = Position(LocationType.TABLEAU, 0)\n+    to_pos = Position(LocationType.TABLEAU, 1)\n+    success = state.execute_move(from_pos, to_pos, count=1)\n+    assert success is True\n+    \n+    assert state.tableaus[0] == []\n+    assert state.tableaus[1] == [cJ, c10]\n+    \n+    # 2. Undo the move\n+    undo_success = state.undo()\n+    assert undo_success is True\n+    assert state.tableaus == orig_tableaus\n+    assert state.freecells == orig_freecells\n+    assert state.foundations == orig_foundations\n+\n+    # 3. Redo the move\n+    redo_success = state.redo()\n+    assert redo_success is True\n+    assert state.tableaus[0] == []\n+    assert state.tableaus[1] == [cJ, c10]\n+\n+    # 4. Undo again to restore\n+    assert state.undo() is True\n+    assert state.tableaus == orig_tableaus\n+\n+def test_undo_with_auto_homing():\n+    state = GameState()\n+    state.tableaus = [[] for _ in range(8)]\n+    state.freecells = [None] * 4\n+    state.foundations = {suit: [] for suit in Suit}\n+\n+    # Tableau 0: Ace of Hearts\n+    # Tableau 1: King of Spades\n+    # Move King of Spades to FreeCell 0. This will trigger auto-homing of Ace of Hearts to foundation.\n+    state.tableaus[0] = [Card(Suit.HEARTS, Rank.ACE)]\n+    state.tableaus[1] = [Card(Suit.SPADES, Rank.KING)]\n+\n+    orig_tableaus = copy.deepcopy(state.tableaus)\n+    orig_freecells = copy.deepcopy(state.freecells)\n+    orig_foundations = copy.deepcopy(state.foundations)\n+\n+    from_pos = Position(LocationType.TABLEAU, 1)\n+    to_pos = Position(LocationType.FREECELL, 0)\n+    success = state.execute_move(from_pos, to_pos, count=1)\n+    assert success is True\n+\n+    # Check state after move and auto-homing\n+    assert state.freecells[0] == Card(Suit.SPADES, Rank.KING)\n+    assert len(state.tableaus[0]) == 0\n+    assert len(state.foundations[Suit.HEARTS]) == 1\n+\n+    # Undo the move! This should revert both King of Spades and Ace of Hearts!\n+    undo_success = state.undo()\n+    assert undo_success is True\n+    assert state.tableaus == orig_tableaus\n+    assert state.freecells == orig_freecells\n+    assert state.foundations == orig_foundations\n+\n+    # Redo the move!\n+    redo_success = state.redo()\n+    assert redo_success is True\n+    assert state.freecells[0] == Card(Suit.SPADES, Rank.KING)\n+    assert len(state.tableaus[0]) == 0\n+    assert len(state.foundations[Suit.HEARTS]) == 1\n+\n+def test_win_detection():\n+    state = GameState()\n+    # Fill foundations\n+    for suit in Suit:\n+        state.foundations[suit] = [Card(suit, rank) for rank in Rank]\n+    assert state.check_win() is True\n+\n+    # Remove one card\n+    state.foundations[Suit.HEARTS].pop()\n+    assert state.check_win() is False\n",
+        "summary": {
+          "files_changed": 11,
+          "additions": 1238,
+          "deletions": 0
+        }
+      }
+    },
+    {
+      "seq": 0,
+      "checkpoint": {
+        "timestamp": "2026-06-04T18:51:07.394251Z",
+        "current_node": "verify_data",
+        "completed_nodes": [
+          "start",
+          "expand_spec",
+          "impl_setup",
+          "verify_setup",
+          "check_setup",
+          "impl_data",
+          "verify_data"
+        ],
+        "node_retries": {},
         "context_values": {
           "thread.expand_spec.current_node": "impl_setup",
           "graph.retry_target": "impl_setup",
-          "internal.thread_id": "check_setup",
+          "internal.thread_id": "verify",
           "internal.retry_count.check_setup": 0,
+          "internal.retry_count.verify_data": 0,
           "graph.default_max_retries": "3",
-          "current_node": "impl_data",
+          "current_node": "verify_data",
           "internal.fidelity": "compact",
           "graph.goal": "Build a terminal-based FreeCell solitaire game in Python",
-          "last_stage": "impl_data",
+          "last_stage": "verify_data",
           "internal.retry_count.expand_spec": 0,
           "internal.retry_count.impl_data": 0,
           "response.impl_data": "I have successfully completed the implementation of the FreeCell solitaire game data models and state engine according to the technical specification, added a comprehensive focused unit test suite, and verified that all tests pass perfectly.\n\n### Summary of Changes\n\n1. **Pure Domain Data Model & State Engine (`card-game-app/src/card_game_tui/domain.py`)**:\n   - Implemented `Suit`, `Rank`, and `Card` representations.\n   - Built the `Deck` class supporting deterministic seeding and standard 52-card dealing.\n   - Designed the `Position` representation, covering tableau columns (0–7), free cells (0–3), and foundations (0–3).\n   - Designed `MoveRecord` with full support for tracking regular moves and recursive `auto_moves` (auto-homing).\n   - Implemented `GameState` managing all piles, validations (`validate_move`), executions (`execute_move`), full asymmetric/nested undo/redo, and win-state detection.\n   - Implemented **Auto-Homing** rules exactly as specified: cards are moved automatically to foundations if and only if they are legal moves and all cards of the opposite color of lower ranks have already been homed.\n\n2. **Comprehensive Headless Unit Tests (`card-game-app/tests/test_domain.py`)**:\n   - Built a comprehensive unit test suite covering:\n     - Standard 52-card deck deal correctness.\n     - Deterministic seeding verification.\n     - Moves to and validations of Free Cells.\n     - Moves to and validations of Foundations.\n     - Single card move rules on the Tableau (descending rank, alternating colors).\n     - Sequence/multi-card moves Tableau-to-Tableau obeying the rules & formula: `(1 + Empty Free Cells) * 2^(Empty Tableau Columns)` with destination empty-column exception.\n     - Core Auto-Homing logic.\n     - Perfect full undo/redo capabilities, including reverting auto-homing sequences.\n     - Winning state detection.\n\n3. **Status Validation**:\n   - All 13 unit tests passed flawlessly inside the Python testing framework.\n   - The CLI non-interactive `--smoke` mode executes perfectly.\n   - Wrote `status.json` with `outcome=succeeded`.",
@@ -1472,10 +1724,11 @@
           "internal.work_dir": "/home/daytona/workspace/fabro",
           "internal.retry_count.start": 0,
           "response.expand_spec": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Document**: `.ai/card-game-spec.md`\n- **Execution Status**: `status.json` with `\"outcome\": \"succeeded\"`\n\n### Key Specification Highlights:\n1. **Core Domain Model & Game Logic**: Complete decoupling from the curses framework. Classes like `Card`, `Suit`, `Rank`, `Deck`, `Position`, and `GameState` manage state transitions, move constraints, and game rules natively and cleanly, making them fully testable in headless CI environments.\n2. **Move Validation & Rule Logic**: Enforces all FreeCell moves, empty pile behavior, card stacking (alternating colors and descending ranks), and includes the mathematical sequence-movement rule constraint formula: \n   $$\\text{Max Cards} = (1 + \\text{Empty Free Cells}) \\times 2^{\\text{Empty Tableau Columns}}$$\n3. **Auto-Homing Mechanics**: An optional, safe automated helper that automatically moves cards to the foundations once they can no longer act as sequence-building stepping stones.\n4. **Interactive Curses UI/TUI**: A detailed layout conforming to $80 \\times 24$ terminal dimensions using memory-efficient double-buffered updates via curses, rich color pair rendering for Red vs Black suits, and a versatile keyboard cursor-based layout navigation system.\n5. **Non-Interactive Smoke Mode**: Specifies the exact behavior of `python3 main.py --smoke` for fast automated integration checks without launching interactive screens.\n6. **Robust Testing Strategy**: Details unit tests covering edge cases for game rules, deterministic seed validation, and UI input mocking scenarios.",
-          "thread.verify.current_node": "verify_setup",
+          "thread.verify.current_node": "verify_data",
           "thread.verify_setup.current_node": "check_setup",
+          "response.verify_data": "I have completed the verification process for the card game data structures in FreeCell Solitaire. \n\n### Summary of Actions Taken:\n1. **Compilation & Tests Executed:** Ran tests and compiled python files successfully.\n   - `python3 -m pytest tests/ -v` -> All 13 tests passed.\n   - `python3 -m py_compile main.py src/card_game_tui/*.py` -> Compiled cleanly with zero syntax/import warnings.\n2. **Analysis of Core Types:** Inspected the data structures and validated:\n   - **Enums:** `Suit`, `Rank`, and `LocationType`.\n   - **Entities:** `Card` (frozen/immutable), `Position` (frozen), and `MoveRecord`.\n   - **State Manager:** `GameState` containing Tableaus, FreeCells, Foundations, and full validation/execution of standard FreeCell logic.\n3. **Advanced Mechanics Verified:**\n   - Alternate-color and descending-rank move validations.\n   - Multi-card sequential moves with correct capacity limits based on empty free cells and empty tableaus.\n   - Smart, cascading auto-homing that avoids locking cards required for lower ranks of opposing colors.\n   - Linear undo/redo stack managing primary moves alongside automatic cascades.\n4. **Output Generation:**\n   - Detailed findings recorded in `.ai/verify_data.md`.\n   - `status.json` updated with `\"outcome\": \"succeeded\"`.",
           "failure_class": "",
-          "last_response": "I have successfully completed the implementation of the FreeCell solitaire game data models and state engine according to the technical specification, added a comprehensive focused unit test suite, an",
+          "last_response": "I have completed the verification process for the card game data structures in FreeCell Solitaire. \n\n### Summary of Actions Taken:\n1. **Compilation & Tests Executed:** Ran tests and compiled python fi",
           "response.impl_setup": "I have successfully built the Python project skeleton for the terminal-based FreeCell solitaire game.\n\nHere is a summary of the steps completed:\n1. **Created `card-game-app/` Project Structure**:\n   - `pyproject.toml` with pytest configured and `pythonpath = [\"src\"]`.\n   - `main.py` entrypoint supporting `--smoke` test mode (without curses dependency) and regular mode.\n   - `src/card_game_tui/` package containing `__init__.py`, `domain.py` (decoupled core game logic: `Suit`, `Rank`, `Card`, `Deck`, `LocationType`, `Position`, `MoveRecord`, and `GameState` class stubs), and `tui.py` (TUI layer placeholder).\n   - `tests/` directory with `__init__.py` and `test_domain.py` containing initial unit tests.\n   - `README.md` stub explaining structure and usage.\n2. **Verified Code Compilation**:\n   - Executed: `cd card-game-app && python3 -m py_compile main.py src/card_game_tui/*.py` which compiled cleanly with exit code 0.\n3. **Smoke Tested the CLI**:\n   - Executed: `cd card-game-app && python3 main.py --smoke` which ran successfully, verifying the integrity of the domain model layout and assertions.\n4. **Wrote `status.json`**:\n   - Created `status.json` at the workspace root containing `{\"outcome\": \"succeeded\"}` as the project skeleton exists and compiles perfectly.",
           "failure_signature": "",
           "graph.rankdir": "LR",
@@ -1537,6 +1790,97 @@
               "active_time_ms": 73263
             }
           },
+          "verify_data": {
+            "status": "succeeded",
+            "context_updates": {
+              "last_stage": "verify_data",
+              "response.verify_data": "I have completed the verification process for the card game data structures in FreeCell Solitaire. \n\n### Summary of Actions Taken:\n1. **Compilation & Tests Executed:** Ran tests and compiled python files successfully.\n   - `python3 -m pytest tests/ -v` -> All 13 tests passed.\n   - `python3 -m py_compile main.py src/card_game_tui/*.py` -> Compiled cleanly with zero syntax/import warnings.\n2. **Analysis of Core Types:** Inspected the data structures and validated:\n   - **Enums:** `Suit`, `Rank`, and `LocationType`.\n   - **Entities:** `Card` (frozen/immutable), `Position` (frozen), and `MoveRecord`.\n   - **State Manager:** `GameState` containing Tableaus, FreeCells, Foundations, and full validation/execution of standard FreeCell logic.\n3. **Advanced Mechanics Verified:**\n   - Alternate-color and descending-rank move validations.\n   - Multi-card sequential moves with correct capacity limits based on empty free cells and empty tableaus.\n   - Smart, cascading auto-homing that avoids locking cards required for lower ranks of opposing colors.\n   - Linear undo/redo stack managing primary moves alongside automatic cascades.\n4. **Output Generation:**\n   - Detailed findings recorded in `.ai/verify_data.md`.\n   - `status.json` updated with `\"outcome\": \"succeeded\"`.",
+              "last_response": "I have completed the verification process for the card game data structures in FreeCell Solitaire. \n\n### Summary of Actions Taken:\n1. **Compilation & Tests Executed:** Ran tests and compiled python fi"
+            },
+            "notes": "Stage completed: verify_data",
+            "usage": {
+              "input": {
+                "usage": {
+                  "model": {
+                    "provider": "gemini",
+                    "model_id": "gemini-3.5-flash"
+                  },
+                  "tokens": {
+                    "input_tokens": 140156,
+                    "output_tokens": 1930,
+                    "reasoning_tokens": 1275,
+                    "cache_read_tokens": 64902,
+                    "cache_write_tokens": 0
+                  }
+                },
+                "facts": {
+                  "algorithm": "gemini",
+                  "storage_segments": []
+                }
+              },
+              "total_usd_micros": 248814
+            },
+            "files_touched": [
+              "/home/daytona/workspace/fabro/.ai/verify_data.md",
+              "/home/daytona/workspace/fabro/status.json"
+            ],
+            "timing": {
+              "wall_time_ms": 0,
+              "inference_time_ms": 42429,
+              "tool_time_ms": 1927,
+              "active_time_ms": 44356
+            }
+          },
+          "expand_spec": {
+            "status": "succeeded",
+            "context_updates": {
+              "last_stage": "expand_spec",
+              "response.expand_spec": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Document**: `.ai/card-game-spec.md`\n- **Execution Status**: `status.json` with `\"outcome\": \"succeeded\"`\n\n### Key Specification Highlights:\n1. **Core Domain Model & Game Logic**: Complete decoupling from the curses framework. Classes like `Card`, `Suit`, `Rank`, `Deck`, `Position`, and `GameState` manage state transitions, move constraints, and game rules natively and cleanly, making them fully testable in headless CI environments.\n2. **Move Validation & Rule Logic**: Enforces all FreeCell moves, empty pile behavior, card stacking (alternating colors and descending ranks), and includes the mathematical sequence-movement rule constraint formula: \n   $$\\text{Max Cards} = (1 + \\text{Empty Free Cells}) \\times 2^{\\text{Empty Tableau Columns}}$$\n3. **Auto-Homing Mechanics**: An optional, safe automated helper that automatically moves cards to the foundations once they can no longer act as sequence-building stepping stones.\n4. **Interactive Curses UI/TUI**: A detailed layout conforming to $80 \\times 24$ terminal dimensions using memory-efficient double-buffered updates via curses, rich color pair rendering for Red vs Black suits, and a versatile keyboard cursor-based layout navigation system.\n5. **Non-Interactive Smoke Mode**: Specifies the exact behavior of `python3 main.py --smoke` for fast automated integration checks without launching interactive screens.\n6. **Robust Testing Strategy**: Details unit tests covering edge cases for game rules, deterministic seed validation, and UI input mocking scenarios.",
+              "last_response": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Doc"
+            },
+            "notes": "Stage completed: expand_spec",
+            "usage": {
+              "input": {
+                "usage": {
+                  "model": {
+                    "provider": "gemini",
+                    "model_id": "gemini-3.5-flash"
+                  },
+                  "tokens": {
+                    "input_tokens": 85925,
+                    "output_tokens": 4840,
+                    "reasoning_tokens": 3421,
+                    "cache_read_tokens": 20271,
+                    "cache_write_tokens": 0
+                  }
+                },
+                "facts": {
+                  "algorithm": "gemini",
+                  "storage_segments": []
+                }
+              },
+              "total_usd_micros": 206276
+            },
+            "files_touched": [
+              "/home/daytona/workspace/fabro/.ai/card-game-spec.md",
+              "/home/daytona/workspace/fabro/status.json"
+            ],
+            "timing": {
+              "wall_time_ms": 0,
+              "inference_time_ms": 111896,
+              "tool_time_ms": 4207,
+              "active_time_ms": 116103
+            }
+          },
+          "start": {
+            "status": "succeeded",
+            "usage": null
+          },
+          "check_setup": {
+            "status": "succeeded",
+            "notes": "Conditional node evaluated: check_setup",
+            "usage": null
+          },
           "verify_setup": {
             "status": "succeeded",
             "context_updates": {
@@ -1619,64 +1963,15 @@
               "tool_time_ms": 20404,
               "active_time_ms": 214135
             }
-          },
-          "check_setup": {
-            "status": "succeeded",
-            "notes": "Conditional node evaluated: check_setup",
-            "usage": null
-          },
-          "expand_spec": {
-            "status": "succeeded",
-            "context_updates": {
-              "last_stage": "expand_spec",
-              "response.expand_spec": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Document**: `.ai/card-game-spec.md`\n- **Execution Status**: `status.json` with `\"outcome\": \"succeeded\"`\n\n### Key Specification Highlights:\n1. **Core Domain Model & Game Logic**: Complete decoupling from the curses framework. Classes like `Card`, `Suit`, `Rank`, `Deck`, `Position`, and `GameState` manage state transitions, move constraints, and game rules natively and cleanly, making them fully testable in headless CI environments.\n2. **Move Validation & Rule Logic**: Enforces all FreeCell moves, empty pile behavior, card stacking (alternating colors and descending ranks), and includes the mathematical sequence-movement rule constraint formula: \n   $$\\text{Max Cards} = (1 + \\text{Empty Free Cells}) \\times 2^{\\text{Empty Tableau Columns}}$$\n3. **Auto-Homing Mechanics**: An optional, safe automated helper that automatically moves cards to the foundations once they can no longer act as sequence-building stepping stones.\n4. **Interactive Curses UI/TUI**: A detailed layout conforming to $80 \\times 24$ terminal dimensions using memory-efficient double-buffered updates via curses, rich color pair rendering for Red vs Black suits, and a versatile keyboard cursor-based layout navigation system.\n5. **Non-Interactive Smoke Mode**: Specifies the exact behavior of `python3 main.py --smoke` for fast automated integration checks without launching interactive screens.\n6. **Robust Testing Strategy**: Details unit tests covering edge cases for game rules, deterministic seed validation, and UI input mocking scenarios.",
-              "last_response": "I have successfully written a comprehensive, detailed implementation specification for building a terminal-based FreeCell Solitaire game in Python.\n\nThe spec has been written to:\n- **Specification Doc"
-            },
-            "notes": "Stage completed: expand_spec",
-            "usage": {
-              "input": {
-                "usage": {
-                  "model": {
-                    "provider": "gemini",
-                    "model_id": "gemini-3.5-flash"
-                  },
-                  "tokens": {
-                    "input_tokens": 85925,
-                    "output_tokens": 4840,
-                    "reasoning_tokens": 3421,
-                    "cache_read_tokens": 20271,
-                    "cache_write_tokens": 0
-                  }
-                },
-                "facts": {
-                  "algorithm": "gemini",
-                  "storage_segments": []
-                }
-              },
-              "total_usd_micros": 206276
-            },
-            "files_touched": [
-              "/home/daytona/workspace/fabro/.ai/card-game-spec.md",
-              "/home/daytona/workspace/fabro/status.json"
-            ],
-            "timing": {
-              "wall_time_ms": 0,
-              "inference_time_ms": 111896,
-              "tool_time_ms": 4207,
-              "active_time_ms": 116103
-            }
-          },
-          "start": {
-            "status": "succeeded",
-            "usage": null
           }
         },
-        "next_node_id": "verify_data",
+        "next_node_id": "check_data",
         "node_visits": {
           "check_setup": 1,
           "start": 1,
           "expand_spec": 1,
           "impl_setup": 1,
+          "verify_data": 1,
           "impl_data": 1,
           "verify_setup": 1
         }
@@ -1959,7 +2254,12 @@
       "first_event_seq": 211,
       "prompt": null,
       "response": null,
-      "completion": null,
+      "completion": {
+        "outcome": "succeeded",
+        "notes": "Stage completed: impl_data",
+        "failure_reason": null,
+        "timestamp": "2026-06-04T18:50:05.683371Z"
+      },
       "provider_used": {
         "mode": "agent",
         "provider": "gemini",
@@ -1972,6 +2272,12 @@
       "output": null,
       "started_at": "2026-06-04T18:46:21.635293Z",
       "handler": "agent",
+      "timing": {
+        "wall_time_ms": 224047,
+        "inference_time_ms": 193731,
+        "tool_time_ms": 20404,
+        "active_time_ms": 214135
+      },
       "usage": {
         "input_tokens": 179865,
         "output_tokens": 10451,
@@ -2153,7 +2459,7 @@
         ],
         "warnings": []
       },
-      "state": "running"
+      "state": "succeeded"
     },
     "start@1": {
       "first_event_seq": 18,
@@ -2189,6 +2495,206 @@
       },
       "state": "succeeded"
     },
+    "verify_data@1": {
+      "first_event_seq": 317,
+      "prompt": null,
+      "response": null,
+      "completion": null,
+      "provider_used": {
+        "mode": "agent",
+        "provider": "gemini",
+        "model": "gemini-3.5-flash"
+      },
+      "diff": null,
+      "script_invocation": null,
+      "script_timing": null,
+      "parallel_results": null,
+      "output": null,
+      "started_at": "2026-06-04T18:50:16.595827Z",
+      "handler": "agent",
+      "usage": {
+        "input_tokens": 140156,
+        "output_tokens": 1930,
+        "total_tokens": 208263,
+        "reasoning_tokens": 1275,
+        "cache_read_tokens": 64902,
+        "cache_write_tokens": 0,
+        "total_usd_micros": 248814
+      },
+      "model": {
+        "provider": "gemini",
+        "model_id": "gemini-3.5-flash"
+      },
+      "permission_level": "full",
+      "agent_tools": [
+        {
+          "name": "close_agent",
+          "description": "Close a running subagent that is no longer needed.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "subagent",
+          "invoked": false
+        },
+        {
+          "name": "edit_file",
+          "description": "Edit a file by replacing an exact string. The old_string must be an exact match and unique unless replace_all is true; include surrounding context when needed. Read the file first and preserve existing indentation.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "write",
+          "invoked": false
+        },
+        {
+          "name": "glob",
+          "description": "Find files by file names using a glob pattern. Use path to choose the search root. Prefer this over shell find or ls when locating repository files.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "read",
+          "invoked": true
+        },
+        {
+          "name": "grep",
+          "description": "Search file contents with a regex pattern. Use path to choose the search root, glob_filter to limit matching files, case_insensitive for case folding, and max_results to cap output.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "read",
+          "invoked": false
+        },
+        {
+          "name": "list_dir",
+          "description": "List directory contents with depth control",
+          "source": {
+            "kind": "native"
+          },
+          "category": "read",
+          "invoked": true
+        },
+        {
+          "name": "read_file",
+          "description": "Read files before editing them. Returns line-numbered text and supports offset/limit for large files. Use this instead of shell cat, head, tail, or sed when inspecting repository files.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "read",
+          "invoked": true
+        },
+        {
+          "name": "read_many_files",
+          "description": "Read multiple files at once",
+          "source": {
+            "kind": "native"
+          },
+          "category": "read",
+          "invoked": false
+        },
+        {
+          "name": "send_input",
+          "description": "Send a follow-up message to a running subagent when new information or corrected instructions are needed.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "subagent",
+          "invoked": false
+        },
+        {
+          "name": "shell",
+          "description": "Execute shell commands for terminal operations, package managers, tests and builds. Use dedicated tools for file reads, file edits, filename searches, and content searches. Provide timeout_ms for long-running commands.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "shell",
+          "invoked": true
+        },
+        {
+          "name": "spawn_agent",
+          "description": "Spawn a subagent for independent work or context isolation. Use it for tasks that can proceed separately, and avoid duplicating the same work in the parent session.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "subagent",
+          "invoked": false
+        },
+        {
+          "name": "wait",
+          "description": "Wait for a subagent to complete, then use the result to synthesize the outcome for the user.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "subagent",
+          "invoked": false
+        },
+        {
+          "name": "web_fetch",
+          "description": "Fetch content from a URL that starts with http:// or https://. Pass a prompt to extract specific information or summarize the page; omit prompt to return the page content.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "other",
+          "invoked": false
+        },
+        {
+          "name": "web_search",
+          "description": "Search the web using Brave Search when current external information is needed. Returns result titles, URLs, and descriptions; use web_fetch for a specific URL.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "other",
+          "invoked": false
+        },
+        {
+          "name": "write_file",
+          "description": "Create new files, or overwrite an existing file only when replacement is explicitly intended. Prefer edit_file for targeted changes to existing files because write_file overwrites the full file content.",
+          "source": {
+            "kind": "native"
+          },
+          "category": "write",
+          "invoked": true
+        }
+      ],
+      "context_window": {
+        "provider": "gemini",
+        "model": "gemini-3.5-flash",
+        "context_window_tokens": 1048576,
+        "input_tokens": 22891,
+        "usage_percent": 2.183055877685547,
+        "count_method": "response_usage_scaled_breakdown",
+        "staleness": "live",
+        "generated_at": "2026-06-04T18:51:07.327001Z",
+        "event_seq": 368,
+        "breakdown": [
+          {
+            "category": "system_prompt",
+            "tokens": 1679,
+            "usage_percent": 0.16012191772460938
+          },
+          {
+            "category": "tools",
+            "tokens": 1744,
+            "usage_percent": 0.16632080078125
+          },
+          {
+            "category": "memory",
+            "tokens": 4722,
+            "usage_percent": 0.45032501220703125
+          },
+          {
+            "category": "conversation",
+            "tokens": 14740,
+            "usage_percent": 1.4057159423828125
+          },
+          {
+            "category": "other",
+            "tokens": 6,
+            "usage_percent": 0.00057220458984375
+          }
+        ],
+        "warnings": []
+      },
+      "state": "running"
+    },
     "verify_setup@1": {
       "first_event_seq": 130,
       "prompt": null,
diff --git a/stages/006-impl_data@1/diff.patch b/stages/006-impl_data@1/diff.patch
new file mode 100644
index 000000000..dcfee9cbf
--- /dev/null
+++ b/stages/006-impl_data@1/diff.patch
@@ -0,0 +1,630 @@
+diff --git a/card-game-app/src/card_game_tui/domain.py b/card-game-app/src/card_game_tui/domain.py
+index db4a2fa8f..fe733cef3 100644
+--- a/card-game-app/src/card_game_tui/domain.py
++++ b/card-game-app/src/card_game_tui/domain.py
+@@ -1,5 +1,5 @@
+ import random
+-from dataclasses import dataclass
++from dataclasses import dataclass, field
+ from enum import Enum, auto
+ from typing import List, Union, Dict
+ 
+@@ -84,6 +84,10 @@ class MoveRecord:
+     cards: List[Card]  # Captured for single or sequence moves
+     auto_moves: List['MoveRecord'] = None  # Nested moves triggered by auto-homing
+ 
++    def __post_init__(self):
++        if self.auto_moves is None:
++            self.auto_moves = []
++
+ class GameState:
+     def __init__(self, seed: int = None):
+         self.tableaus: List[List[Card]] = Deck(seed).deal()
+@@ -107,7 +111,108 @@ class GameState:
+         """
+         Calculates whether moving 'count' cards from from_pos to to_pos is legal.
+         """
+-        # Placeholder for validation
++        if count < 1:
++            return False
++
++        if from_pos == to_pos:
++            return False
++
++        # Validate index boundaries
++        if from_pos.type == LocationType.TABLEAU:
++            if not (0 <= from_pos.index < 8):
++                return False
++        elif from_pos.type == LocationType.FREECELL:
++            if not (0 <= from_pos.index < 4):
++                return False
++            if count != 1:
++                return False
++        elif from_pos.type == LocationType.FOUNDATION:
++            return False
++        else:
++            return False
++
++        if to_pos.type == LocationType.TABLEAU:
++            if not (0 <= to_pos.index < 8):
++                return False
++        elif to_pos.type == LocationType.FREECELL:
++            if not (0 <= to_pos.index < 4):
++                return False
++            if count != 1:
++                return False
++        elif to_pos.type == LocationType.FOUNDATION:
++            if not (0 <= to_pos.index < 4):
++                return False
++            if count != 1:
++                return False
++        else:
++            return False
++
++        # Extract moving cards
++        if from_pos.type == LocationType.FREECELL:
++            card = self.freecells[from_pos.index]
++            if card is None:
++                return False
++            moving_cards = [card]
++        elif from_pos.type == LocationType.TABLEAU:
++            col = self.tableaus[from_pos.index]
++            if len(col) < count:
++                return False
++            moving_cards = col[-count:]
++        else:
++            return False
++
++        # Validate sequence if moving multiple cards
++        if count > 1:
++            for i in range(count - 1):
++                c1 = moving_cards[i]
++                c2 = moving_cards[i+1]
++                if c2.rank.value != c1.rank.value - 1:
++                    return False
++                if c2.suit.color == c1.suit.color:
++                    return False
++
++        # Validate destination constraints
++        if to_pos.type == LocationType.FREECELL:
++            if self.freecells[to_pos.index] is not None:
++                return False
++
++        elif to_pos.type == LocationType.FOUNDATION:
++            target_suit = list(Suit)[to_pos.index]
++            card = moving_cards[0]
++            if card.suit != target_suit:
++                return False
++            
++            foundation_pile = self.foundations[target_suit]
++            if card.rank == Rank.ACE:
++                if len(foundation_pile) != 0:
++                    return False
++            else:
++                if len(foundation_pile) != card.rank.value - 1:
++                    return False
++
++        elif to_pos.type == LocationType.TABLEAU:
++            dest_col = self.tableaus[to_pos.index]
++            first_moving_card = moving_cards[0]
++            if len(dest_col) > 0:
++                dest_top_card = dest_col[-1]
++                if first_moving_card.rank.value != dest_top_card.rank.value - 1:
++                    return False
++                if first_moving_card.suit.color == dest_top_card.suit.color:
++                    return False
++
++            # Capacity constraint
++            empty_freecells = sum(1 for c in self.freecells if c is None)
++            empty_tableaus = sum(1 for col in self.tableaus if len(col) == 0)
++
++            if len(dest_col) == 0:
++                transit_empty_tableaus = max(0, empty_tableaus - 1)
++            else:
++                transit_empty_tableaus = empty_tableaus
++
++            max_cards = (1 + empty_freecells) * (2 ** transit_empty_tableaus)
++            if count > max_cards:
++                return False
++
+         return True
+ 
+     def execute_move(self, from_pos: Position, to_pos: Position, count: int = 1) -> bool:
+@@ -116,12 +221,156 @@ class GameState:
+         """
+         if not self.validate_move(from_pos, to_pos, count):
+             return False
++
++        # Extract moving cards
++        if from_pos.type == LocationType.FREECELL:
++            moving_cards = [self.freecells[from_pos.index]]
++        elif from_pos.type == LocationType.TABLEAU:
++            moving_cards = self.tableaus[from_pos.index][-count:]
++        else:
++            return False
++
++        move_record = MoveRecord(from_pos=from_pos, to_pos=to_pos, cards=moving_cards)
++        
++        # Apply the move
++        self._apply_single_move(move_record)
++        
++        # Run auto-homing
++        self._run_auto_homing(move_record)
++        
++        # Record on stacks
++        self.undo_stack.append(move_record)
++        self.redo_stack.clear()
++        return True
++
++    def _apply_single_move(self, record: MoveRecord):
++        # Remove from from_pos
++        if record.from_pos.type == LocationType.FREECELL:
++            self.freecells[record.from_pos.index] = None
++        elif record.from_pos.type == LocationType.TABLEAU:
++            count = len(record.cards)
++            self.tableaus[record.from_pos.index] = self.tableaus[record.from_pos.index][:-count]
++
++        # Put to to_pos
++        if record.to_pos.type == LocationType.FREECELL:
++            self.freecells[record.to_pos.index] = record.cards[0]
++        elif record.to_pos.type == LocationType.FOUNDATION:
++            target_suit = list(Suit)[record.to_pos.index]
++            self.foundations[target_suit].append(record.cards[0])
++        elif record.to_pos.type == LocationType.TABLEAU:
++            self.tableaus[record.to_pos.index].extend(record.cards)
++
++    def _revert_single_move(self, record: MoveRecord):
++        # Remove from to_pos
++        if record.to_pos.type == LocationType.FREECELL:
++            self.freecells[record.to_pos.index] = None
++        elif record.to_pos.type == LocationType.FOUNDATION:
++            target_suit = list(Suit)[record.to_pos.index]
++            self.foundations[target_suit].pop()
++        elif record.to_pos.type == LocationType.TABLEAU:
++            count = len(record.cards)
++            self.tableaus[record.to_pos.index] = self.tableaus[record.to_pos.index][:-count]
++
++        # Put to from_pos
++        if record.from_pos.type == LocationType.FREECELL:
++            self.freecells[record.from_pos.index] = record.cards[0]
++        elif record.from_pos.type == LocationType.TABLEAU:
++            self.tableaus[record.from_pos.index].extend(record.cards)
++
++    def _should_auto_home(self, card: Card) -> bool:
++        """
++        Checks if a card can be safely auto-homed to the foundations.
++        """
++        target_foundation = self.foundations[card.suit]
++        if card.rank.value != len(target_foundation) + 1:
++            return False
++
++        # Opposite color suits must have all lower cards in the foundations
++        if card.suit.color == "RED":
++            opp_suits = [Suit.CLUBS, Suit.SPADES]
++        else:
++            opp_suits = [Suit.HEARTS, Suit.DIAMONDS]
++
++        for s_opp in opp_suits:
++            if len(self.foundations[s_opp]) < card.rank.value - 1:
++                return False
++
+         return True
+ 
++    def _run_auto_homing(self, move_record: MoveRecord):
++        """
++        Scans freecells and tableau tops, moving eligible cards to foundations.
++        Repeats until no more cards can be auto-homed.
++        """
++        any_homed = True
++        while any_homed:
++            any_homed = False
++            
++            # Check free cells
++            for i, card in enumerate(self.freecells):
++                if card is not None and self._should_auto_home(card):
++                    from_p = Position(LocationType.FREECELL, i)
++                    suit_idx = list(Suit).index(card.suit)
++                    to_p = Position(LocationType.FOUNDATION, suit_idx)
++                    
++                    auto_rec = MoveRecord(from_pos=from_p, to_pos=to_p, cards=[card])
++                    self._apply_single_move(auto_rec)
++                    move_record.auto_moves.append(auto_rec)
++                    
++                    any_homed = True
++                    break
++            
++            if any_homed:
++                continue
++
++            # Check tableaus
++            for i, col in enumerate(self.tableaus):
++                if col:
++                    card = col[-1]
++                    if self._should_auto_home(card):
++                        from_p = Position(LocationType.TABLEAU, i)
++                        suit_idx = list(Suit).index(card.suit)
++                        to_p = Position(LocationType.FOUNDATION, suit_idx)
++                        
++                        auto_rec = MoveRecord(from_pos=from_p, to_pos=to_p, cards=[card])
++                        self._apply_single_move(auto_rec)
++                        move_record.auto_moves.append(auto_rec)
++                        
++                        any_homed = True
++                        break
++
+     def undo(self) -> bool:
+         """Reverts the last move, including nested auto-homing steps."""
+         if not self.undo_stack:
+             return False
++        
++        move_record = self.undo_stack.pop()
++        
++        # Revert auto moves in reverse order
++        for auto_move in reversed(move_record.auto_moves):
++            self._revert_single_move(auto_move)
++            
++        # Revert the main move
++        self._revert_single_move(move_record)
++        
++        self.redo_stack.append(move_record)
++        return True
++
++    def redo(self) -> bool:
++        """Reapplies the last undone move."""
++        if not self.redo_stack:
++            return False
++            
++        move_record = self.redo_stack.pop()
++        
++        # Apply the main move
++        self._apply_single_move(move_record)
++        
++        # Re-apply auto moves
++        for auto_move in move_record.auto_moves:
++            self._apply_single_move(auto_move)
++            
++        self.undo_stack.append(move_record)
+         return True
+ 
+     def check_win(self) -> bool:
+diff --git a/card-game-app/tests/test_domain.py b/card-game-app/tests/test_domain.py
+index 3ddb4344b..0fa4360ed 100644
+--- a/card-game-app/tests/test_domain.py
++++ b/card-game-app/tests/test_domain.py
+@@ -1,3 +1,4 @@
++import copy
+ from card_game_tui.domain import GameState, Suit, Rank, Card, Deck, LocationType, Position
+ 
+ def test_deck_deals_52_cards():
+@@ -18,3 +19,331 @@ def test_get_card_at():
+     card = state.get_card_at(pos)
+     assert card is not None
+     assert isinstance(card, Card)
++
++def test_deck_deterministic_seeding():
++    deck1 = Deck(seed=42)
++    deck2 = Deck(seed=42)
++    assert deck1.cards == deck2.cards
++
++    # Verify uniqueness of 52 cards
++    assert len(set(deck1.cards)) == 52
++
++def test_moves_to_free_cells():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    # Put a card in Tableau 0
++    c_hearts = Card(Suit.HEARTS, Rank.TEN)
++    state.tableaus[0] = [c_hearts]
++
++    from_pos = Position(LocationType.TABLEAU, 0)
++    to_pos = Position(LocationType.FREECELL, 0)
++
++    # Valid single card move to empty freecell
++    assert state.validate_move(from_pos, to_pos, count=1) is True
++    
++    # Try invalid sequence count to free cell
++    assert state.validate_move(from_pos, to_pos, count=2) is False
++
++    # Execute move
++    assert state.execute_move(from_pos, to_pos, count=1) is True
++    assert state.freecells[0] == c_hearts
++    assert len(state.tableaus[0]) == 0
++
++    # Try moving to occupied freecell
++    state.tableaus[0] = [Card(Suit.SPADES, Rank.FIVE)]
++    assert state.validate_move(from_pos, to_pos, count=1) is False
++
++    # Try moving to invalid freecell index
++    invalid_to_pos = Position(LocationType.FREECELL, 4)
++    assert state.validate_move(from_pos, invalid_to_pos, count=1) is False
++
++def test_moves_to_foundations():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    ace_hearts = Card(Suit.HEARTS, Rank.ACE)
++    two_hearts = Card(Suit.HEARTS, Rank.TWO)
++    three_hearts = Card(Suit.HEARTS, Rank.THREE)
++    ace_diamonds = Card(Suit.DIAMONDS, Rank.ACE)
++
++    state.tableaus[0] = [ace_hearts]
++    state.tableaus[1] = [two_hearts]
++    state.tableaus[2] = [three_hearts]
++    state.tableaus[3] = [ace_diamonds]
++
++    # Move Ace of Hearts to index 0 (HEARTS) foundation
++    # list(Suit) indices: 0: HEARTS, 1: DIAMONDS, 2: CLUBS, 3: SPADES
++    hearts_found = Position(LocationType.FOUNDATION, 0)
++    diamonds_found = Position(LocationType.FOUNDATION, 1)
++
++    # Valid Ace to empty foundation
++    assert state.validate_move(Position(LocationType.TABLEAU, 0), hearts_found, count=1) is True
++    # Invalid non-Ace to empty foundation
++    assert state.validate_move(Position(LocationType.TABLEAU, 1), hearts_found, count=1) is False
++    # Invalid Ace to wrong suit foundation
++    assert state.validate_move(Position(LocationType.TABLEAU, 3), hearts_found, count=1) is False
++
++    # Execute valid Ace move
++    assert state.execute_move(Position(LocationType.TABLEAU, 0), hearts_found, count=1) is True
++    assert state.foundations[Suit.HEARTS] == [ace_hearts]
++
++    # Now Two of Hearts is on Tableau 1. Can it move to Hearts foundation? Yes.
++    assert state.validate_move(Position(LocationType.TABLEAU, 1), hearts_found, count=1) is True
++    # Can Three of Hearts move? No, since it needs Two of Hearts first.
++    assert state.validate_move(Position(LocationType.TABLEAU, 2), hearts_found, count=1) is False
++
++def test_moves_to_tableau_single_card():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    # Red 8 (Hearts) on Black 9 (Spades)
++    c_red8 = Card(Suit.HEARTS, Rank.EIGHT)
++    c_black9 = Card(Suit.SPADES, Rank.NINE)
++    
++    state.tableaus[0] = [c_red8]
++    state.tableaus[1] = [c_black9]
++
++    # Test moving Red 8 onto Black 9
++    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is True
++
++    # Test same color invalid move: Red 8 (Hearts) on Red 9 (Diamonds)
++    c_red9 = Card(Suit.DIAMONDS, Rank.NINE)
++    state.tableaus[1] = [c_red9]
++    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is False
++
++    # Test wrong rank invalid move: Red 8 on Black 10 (Spades)
++    c_black10 = Card(Suit.SPADES, Rank.TEN)
++    state.tableaus[1] = [c_black10]
++    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is False
++
++    # Test moving to empty tableau
++    state.tableaus[1] = []
++    assert state.validate_move(Position(LocationType.TABLEAU, 0), Position(LocationType.TABLEAU, 1), count=1) is True
++
++def test_sequence_moves_tableau_to_tableau():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++    
++    # Red 10, Black 9, Red 8, Black 7, Red 6
++    c10 = Card(Suit.HEARTS, Rank.TEN)
++    c9 = Card(Suit.SPADES, Rank.NINE)
++    c8 = Card(Suit.DIAMONDS, Rank.EIGHT)
++    c7 = Card(Suit.CLUBS, Rank.SEVEN)
++    c6 = Card(Suit.HEARTS, Rank.SIX)
++    
++    state.tableaus[0] = [c10, c9, c8, c7, c6]
++    state.tableaus[1] = [Card(Suit.SPADES, Rank.JACK)]
++    
++    # 4 empty freecells, 6 empty tableaus.
++    # Exclude destination: no, destination is Col 1 which has 1 card (not empty).
++    # Transit empty tableaus = 6
++    # Max cards = (1 + 4) * 2^6 = 5 * 64 = 320 cards.
++    # Moving 5 cards should be valid!
++    from_pos = Position(LocationType.TABLEAU, 0)
++    to_pos = Position(LocationType.TABLEAU, 1)
++    assert state.validate_move(from_pos, to_pos, count=5) is True
++    
++    # Restrict capacity
++    state.freecells = [Card(Suit.CLUBS, Rank.TWO)] * 4  # 0 empty freecells
++    for i in range(2, 8):
++        state.tableaus[i] = [Card(Suit.DIAMONDS, Rank.KING)]  # 0 empty tableaus
++    # Now empty freecells = 0, empty tableaus = 0
++    # Max cards = (1 + 0) * 2^0 = 1
++    # Moving 5 cards should be invalid
++    assert state.validate_move(from_pos, to_pos, count=5) is False
++
++def test_sequence_moves_to_empty_tableau():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    # Sequence of 3 cards on Col 0: Red 10, Black 9, Red 8
++    c10 = Card(Suit.HEARTS, Rank.TEN)
++    c9 = Card(Suit.SPADES, Rank.NINE)
++    c8 = Card(Suit.DIAMONDS, Rank.EIGHT)
++    state.tableaus[0] = [c10, c9, c8]
++
++    # Destination is Col 1 (empty)
++    # We want to move 2 cards: Black 9, Red 8
++    # Capacity constraint:
++    # Destination Col 1 is empty, so transit_empty_tableaus = empty_tableaus - 1.
++    # Empty tableaus before move = 7.
++    # Transit empty tableaus = 6.
++    # Empty free cells = 4.
++    # Max cards = (1 + 4) * 2^6 = 320.
++    from_pos = Position(LocationType.TABLEAU, 0)
++    to_pos = Position(LocationType.TABLEAU, 1)
++    assert state.validate_move(from_pos, to_pos, count=2) is True
++
++    # Restrict capacity so Max Cards is exactly 1
++    state.freecells = [Card(Suit.CLUBS, Rank.TWO)] * 4  # 0 empty free cells
++    for i in range(2, 8):
++        state.tableaus[i] = [Card(Suit.DIAMONDS, Rank.KING)]  # 0 transit empty tableaus
++    # Empty freecells = 0, empty tableaus = 1 (Col 1).
++    # Since Col 1 is the destination, transit_empty_tableaus = 1 - 1 = 0.
++    # Max cards = (1 + 0) * 2^0 = 1.
++    # Moving 2 cards should be invalid, but 1 card should be valid.
++    assert state.validate_move(from_pos, to_pos, count=2) is False
++    assert state.validate_move(from_pos, to_pos, count=1) is True
++
++def test_auto_homing_logic():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    # Hearts is RED. Opposite suits are CLUBS and SPADES.
++    # Put Ace of Hearts in Tableau 0.
++    state.tableaus[0] = [Card(Suit.HEARTS, Rank.ACE)]
++    # Put King of Spades in Tableau 1 to use as a dummy move trigger.
++    state.tableaus[1] = [Card(Suit.SPADES, Rank.KING)]
++    
++    assert len(state.foundations[Suit.HEARTS]) == 0
++    
++    # Execute move of King of Spades to FreeCell 0. This should trigger auto-homing of Ace of Hearts.
++    from_pos = Position(LocationType.TABLEAU, 1)
++    to_pos = Position(LocationType.FREECELL, 0)
++    success = state.execute_move(from_pos, to_pos, count=1)
++    assert success is True
++    
++    assert state.freecells[0] == Card(Suit.SPADES, Rank.KING)
++    assert len(state.tableaus[0]) == 0
++    assert len(state.foundations[Suit.HEARTS]) == 1
++    assert state.foundations[Suit.HEARTS][0] == Card(Suit.HEARTS, Rank.ACE)
++    
++    # Two of Hearts is put in Tableau 0.
++    # Foundations: Hearts has Ace. CLUBS has [], SPADES has [].
++    # Opposite color (Black) lower cards are Ace of Clubs and Ace of Spades.
++    # Since they are NOT in the foundations, Two of Hearts should NOT auto-home.
++    state.tableaus[0] = [Card(Suit.HEARTS, Rank.TWO)]
++    
++    # Move King of Spades from FreeCell 0 to Tableau 1 to trigger auto-homing checks
++    from_pos = Position(LocationType.FREECELL, 0)
++    to_pos = Position(LocationType.TABLEAU, 1)
++    success = state.execute_move(from_pos, to_pos, count=1)
++    assert success is True
++    
++    # Two of Hearts should still be in Tableau 0 (not auto-homed)
++    assert len(state.tableaus[0]) == 1
++    assert state.tableaus[0][0] == Card(Suit.HEARTS, Rank.TWO)
++    assert len(state.foundations[Suit.HEARTS]) == 1
++    
++    # Place Ace of Clubs and Ace of Spades in their foundations.
++    state.foundations[Suit.CLUBS] = [Card(Suit.CLUBS, Rank.ACE)]
++    state.foundations[Suit.SPADES] = [Card(Suit.SPADES, Rank.ACE)]
++    
++    # Move King of Spades back to FreeCell 0 to trigger auto-homing checks
++    from_pos = Position(LocationType.TABLEAU, 1)
++    to_pos = Position(LocationType.FREECELL, 0)
++    success = state.execute_move(from_pos, to_pos, count=1)
++    assert success is True
++    
++    # Two of Hearts should now have auto-homed!
++    assert len(state.tableaus[0]) == 0
++    assert len(state.foundations[Suit.HEARTS]) == 2
++    assert state.foundations[Suit.HEARTS][1] == Card(Suit.HEARTS, Rank.TWO)
++
++def test_undo_redo_system():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    # Col 0: [Red 10 (Hearts)]
++    # Col 1: [Black J (Spades)]
++    c10 = Card(Suit.HEARTS, Rank.TEN)
++    cJ = Card(Suit.SPADES, Rank.JACK)
++    state.tableaus[0] = [c10]
++    state.tableaus[1] = [cJ]
++
++    # Save original state for verification
++    orig_tableaus = copy.deepcopy(state.tableaus)
++    orig_freecells = copy.deepcopy(state.freecells)
++    orig_foundations = copy.deepcopy(state.foundations)
++
++    # 1. Execute a move
++    from_pos = Position(LocationType.TABLEAU, 0)
++    to_pos = Position(LocationType.TABLEAU, 1)
++    success = state.execute_move(from_pos, to_pos, count=1)
++    assert success is True
++    
++    assert state.tableaus[0] == []
++    assert state.tableaus[1] == [cJ, c10]
++    
++    # 2. Undo the move
++    undo_success = state.undo()
++    assert undo_success is True
++    assert state.tableaus == orig_tableaus
++    assert state.freecells == orig_freecells
++    assert state.foundations == orig_foundations
++
++    # 3. Redo the move
++    redo_success = state.redo()
++    assert redo_success is True
++    assert state.tableaus[0] == []
++    assert state.tableaus[1] == [cJ, c10]
++
++    # 4. Undo again to restore
++    assert state.undo() is True
++    assert state.tableaus == orig_tableaus
++
++def test_undo_with_auto_homing():
++    state = GameState()
++    state.tableaus = [[] for _ in range(8)]
++    state.freecells = [None] * 4
++    state.foundations = {suit: [] for suit in Suit}
++
++    # Tableau 0: Ace of Hearts
++    # Tableau 1: King of Spades
++    # Move King of Spades to FreeCell 0. This will trigger auto-homing of Ace of Hearts to foundation.
++    state.tableaus[0] = [Card(Suit.HEARTS, Rank.ACE)]
++    state.tableaus[1] = [Card(Suit.SPADES, Rank.KING)]
++
++    orig_tableaus = copy.deepcopy(state.tableaus)
++    orig_freecells = copy.deepcopy(state.freecells)
++    orig_foundations = copy.deepcopy(state.foundations)
++
++    from_pos = Position(LocationType.TABLEAU, 1)
++    to_pos = Position(LocationType.FREECELL, 0)
++    success = state.execute_move(from_pos, to_pos, count=1)
++    assert success is True
++
++    # Check state after move and auto-homing
++    assert state.freecells[0] == Card(Suit.SPADES, Rank.KING)
++    assert len(state.tableaus[0]) == 0
++    assert len(state.foundations[Suit.HEARTS]) == 1
++
++    # Undo the move! This should revert both King of Spades and Ace of Hearts!
++    undo_success = state.undo()
++    assert undo_success is True
++    assert state.tableaus == orig_tableaus
++    assert state.freecells == orig_freecells
++    assert state.foundations == orig_foundations
++
++    # Redo the move!
++    redo_success = state.redo()
++    assert redo_success is True
++    assert state.freecells[0] == Card(Suit.SPADES, Rank.KING)
++    assert len(state.tableaus[0]) == 0
++    assert len(state.foundations[Suit.HEARTS]) == 1
++
++def test_win_detection():
++    state = GameState()
++    # Fill foundations
++    for suit in Suit:
++        state.foundations[suit] = [Card(suit, rank) for rank in Rank]
++    assert state.check_win() is True
++
++    # Remove one card
++    state.foundations[Suit.HEARTS].pop()
++    assert state.check_win() is False
diff --git a/stages/006-impl_data@1/status.json b/stages/006-impl_data@1/status.json
new file mode 100644
index 000000000..291765d52
--- /dev/null
+++ b/stages/006-impl_data@1/status.json
@@ -0,0 +1,6 @@
+{
+  "outcome": "succeeded",
+  "notes": "Stage completed: impl_data",
+  "failure_reason": null,
+  "timestamp": "2026-06-04T18:50:05.683371Z"
+}
\ No newline at end of file
diff --git a/stages/007-verify_data@1/prompt.md b/stages/007-verify_data@1/prompt.md
new file mode 100644
index 000000000..5701ce292
--- /dev/null
+++ b/stages/007-verify_data@1/prompt.md
@@ -0,0 +1,27 @@
+Goal: Build a terminal-based FreeCell solitaire game in Python
+
+## Completed stages
+- **expand_spec**: succeeded
+  - Model: gemini-3.5-flash, 85.9k tokens in / 8.3k out
+  - Files: /home/daytona/workspace/fabro/.ai/card-game-spec.md, /home/daytona/workspace/fabro/status.json
+- **impl_setup**: succeeded
+  - Model: gemini-3.5-flash, 144.1k tokens in / 6.8k out
+  - Files: /home/daytona/workspace/fabro/card-game-app/README.md, /home/daytona/workspace/fabro/card-game-app/main.py, /home/daytona/workspace/fabro/card-game-app/pyproject.toml, /home/daytona/workspace/fabro/card-game-app/src/card_game_tui/__init__.py, /home/daytona/workspace/fabro/card-game-app/src/card_game_tui/domain.py, /home/daytona/workspace/fabro/card-game-app/src/card_game_tui/tui.py, /home/daytona/workspace/fabro/card-game-app/tests/__init__.py, /home/daytona/workspace/fabro/card-game-app/tests/test_domain.py, /home/daytona/workspace/fabro/status.json
+- **verify_setup**: succeeded
+  - Model: gemini-3.5-flash, 185.9k tokens in / 2.2k out
+  - Files: /home/daytona/workspace/fabro/.ai/verify_setup.md, /home/daytona/workspace/fabro/status.json
+- **check_setup**: succeeded
+- **impl_data**: succeeded
+  - Model: gemini-3.5-flash, 179.9k tokens in / 32.0k out
+  - Files: /home/daytona/workspace/fabro/card-game-app/src/card_game_tui/domain.py, /home/daytona/workspace/fabro/card-game-app/tests/test_domain.py, /home/daytona/workspace/fabro/status.json
+
+
+Verify the card game data structures.
+
+Run:
+cd card-game-app && python3 -m pytest tests/ -v && python3 -m py_compile main.py src/card_game_tui/*.py
+
+Check that the core game-state types are defined and basic operations work.
+
+Write findings to .ai/verify_data.md.
+Write status.json at workspace root: outcome=succeeded if all checks pass, outcome=failed with failure_reason otherwise.
\ No newline at end of file
diff --git a/stages/007-verify_data@1/provider_used.json b/stages/007-verify_data@1/provider_used.json
new file mode 100644
index 000000000..0bb716dde
--- /dev/null
+++ b/stages/007-verify_data@1/provider_used.json
@@ -0,0 +1,5 @@
+{
+  "mode": "agent",
+  "provider": "gemini",
+  "model": "gemini-3.5-flash"
+}
\ No newline at end of file
diff --git a/stages/007-verify_data@1/response.md b/stages/007-verify_data@1/response.md
new file mode 100644
index 000000000..d835c6615
--- /dev/null
+++ b/stages/007-verify_data@1/response.md
@@ -0,0 +1,18 @@
+I have completed the verification process for the card game data structures in FreeCell Solitaire. 
+
+### Summary of Actions Taken:
+1. **Compilation & Tests Executed:** Ran tests and compiled python files successfully.
+   - `python3 -m pytest tests/ -v` -> All 13 tests passed.
+   - `python3 -m py_compile main.py src/card_game_tui/*.py` -> Compiled cleanly with zero syntax/import warnings.
+2. **Analysis of Core Types:** Inspected the data structures and validated:
+   - **Enums:** `Suit`, `Rank`, and `LocationType`.
+   - **Entities:** `Card` (frozen/immutable), `Position` (frozen), and `MoveRecord`.
+   - **State Manager:** `GameState` containing Tableaus, FreeCells, Foundations, and full validation/execution of standard FreeCell logic.
+3. **Advanced Mechanics Verified:**
+   - Alternate-color and descending-rank move validations.
+   - Multi-card sequential moves with correct capacity limits based on empty free cells and empty tableaus.
+   - Smart, cascading auto-homing that avoids locking cards required for lower ranks of opposing colors.
+   - Linear undo/redo stack managing primary moves alongside automatic cascades.
+4. **Output Generation:**
+   - Detailed findings recorded in `.ai/verify_data.md`.
+   - `status.json` updated with `"outcome": "succeeded"`.
\ No newline at end of file