diff --git a/.claude/implementation/NEXT_SESSION.md b/.claude/implementation/NEXT_SESSION.md
index b1e53ca..ec30729 100644
--- a/.claude/implementation/NEXT_SESSION.md
+++ b/.claude/implementation/NEXT_SESSION.md
@@ -1,973 +1,226 @@
-# Next Session Plan - Phase 3: X-Check System
+# Next Session - Phase 3E: X-Check Position Ratings
 
-**Current Status**: Phase 3 - 85% Complete (3A, 3B, 3C, 3D, 3E-Prep done; 3E-Main, 3E-Final, 3F remaining)
-**Last Commit**: `d560844` - "CLAUDE: Phase 3E-Prep - Refactor GameState to use full LineupPlayerState objects"
-**Date**: 2025-11-03
-**Remaining Work**: 15% (Phase 3E-Main, 3E-Final, 3F)
+## Current Status: Phase 3E-Main Complete ✅
+
+**Overall Phase 3E Progress: 90%**
+
+### ✅ Phase 3E-Main: Position Ratings Integration (COMPLETED)
+
+**Completion Date**: 2025-11-03
+**Commit**: `02e816a` - CLAUDE: Phase 3E-Main - Position ratings integration for X-Check resolution
+
+#### What Was Accomplished
+
+1. **PD API Client Integration**
+   - Created `app/services/pd_api_client.py` - async HTTP client using httpx
+   - Endpoint: `GET https://pd.manticorum.com/api/v2/cardpositions?player_id={id}`
+   - Supports position filtering via query parameters
+   - Tested with real API data (player 8807 - 7 positions)
+
+2. **Position Rating Service with Caching**
+   - Created `app/services/position_rating_service.py`
+   - In-memory caching (16,601x speedup: 0.214s API → 0.000s cache)
+   - League-aware: PD fetches ratings, SBA returns empty list
+   - Graceful degradation on API errors
+
+3. **GameState Integration**
+   - Added `position_rating` field to `LineupPlayerState`
+   - Added `get_defender_for_position()` using StateManager lineup cache
+   - Self-contained X-Check data - no lookups during resolution
+
+4. **League Config Pattern**
+   - Added `supports_position_ratings()` to both league configs
+   - PD: Returns True (uses API)
+   - SBA: Returns False (uses defaults)
+
+5. **PlayResolver Updates**
+   - Integrated StateManager for O(1) defender lookups
+   - Uses actual position ratings when available
+   - Falls back to defaults (range=3, error=15) for SBA or missing data
+
+6. **Game Engine Updates**
+   - Added `_load_position_ratings_for_lineup()` method
+   - Loads ratings at game start for both teams (PD league only)
+   - Updated PlayResolver instantiation with state_manager
+
+7. **Comprehensive Testing**
+   - Live API integration test (`test_pd_api_live.py`)
+   - Mock API test for CI/CD (`test_pd_api_mock.py`)
+   - Pytest integration suite (`tests/integration/test_position_ratings_api.py`)
+   - Verified full flow: API → Cache → GameState → X-Check resolution
+
+#### Live Test Results
+
+**Player 8807** (7 positions verified):
+```
+Position   Range    Error    Arm      Innings
+CF         3        2        3        372
+2B         3        8        3        212
+SS         4        12       4        159
+RF         2        2        2        74
+LF         3        2        3        62
+1B         4        0        3        46
+3B         3        65       2        34
+```
+
+**Performance Metrics**:
+- API call: 0.214s
+- Cache hit: 0.000013s
+- Speedup: 16,601x
 
 ---
 
-## Quick Start for Next AI Agent
+## 🎯 Phase 3E-Final: Remaining Work (10%)
 
-### 🎯 Where to Begin
-1. Read this entire document first
-2. Review `@.claude/implementation/phase-3e-websocket-events.md` for Phase 3E details
-3. Review files in "Files to Review Before Starting" section
-4. Start with Task 1 (Understanding Phase 3E requirements)
-5. Run test commands after each implementation
+### Tasks to Complete
 
-### 📍 Current Context
+#### 1. WebSocket Event Handlers for X-Check UI
+**Priority**: HIGH
+**Estimate**: 2-3 hours
 
-**Phase 3 (Weeks 7-9): X-Check Play System** is 85% complete. We have successfully implemented:
-- ✅ **Phase 3A**: X-Check data models (XCheckResult, PositionRating, PlayOutcome.X_CHECK)
-- ✅ **Phase 3B**: League config tables (defense tables, error charts, helper functions)
-- ✅ **Phase 3C**: Complete X-Check resolution logic in PlayResolver (397 lines, 6 helper methods)
-- ✅ **Phase 3D**: X-Check runner advancement tables (690 lines, 59 tests, all passing)
-- ✅ **Phase 3E-Prep**: GameState refactor - unified player references (all full objects)
+- [ ] Create `handle_xcheck_confirm` event handler
+- [ ] Emit `xcheck_result` events with defender ratings
+- [ ] Update frontend WebSocket listeners
+- [ ] Test real-time X-Check flow end-to-end
 
-**Next priority**: **Phase 3E-Main - Position Ratings & Self-Contained State**. This phase adds position ratings to LineupPlayerState and loads them at game start from the PD API with Redis caching. This makes GameState fully self-contained with everything needed for X-Check resolution.
+**Files to Modify**:
+- `app/websocket/game_events.py`
+- Frontend Socket.io listeners (both leagues)
 
----
+#### 2. Upgrade to Redis Caching
+**Priority**: MEDIUM
+**Estimate**: 3-4 hours
 
-## What We Just Completed ✅
+- [ ] Add redis-py to requirements.txt
+- [ ] Create Redis connection pool in app startup
+- [ ] Migrate `position_rating_service.py` from in-memory to Redis
+- [ ] Set TTL on cached ratings (e.g., 24 hours)
+- [ ] Add Redis cache warming on game start
+- [ ] Test cache invalidation and recovery
 
-### Phase 3A: X-Check Data Models (2025-11-01)
-**Commit**: `a1f42a9`
+**Files to Modify**:
+- `requirements.txt`
+- `app/main.py` (startup/shutdown events)
+- `app/services/position_rating_service.py`
 
-**Files Created/Modified**:
-- `backend/app/models/game_models.py` - Added `XCheckResult` dataclass with 13 fields
-- `backend/app/models/player_models.py` - Added `PositionRating` dataclass (range, error, arm)
-- `backend/app/config/result_charts.py` - Added `PlayOutcome.X_CHECK` enum value
-
-**Implementation**:
-- Complete XCheckResult tracking: position, dice rolls, defender ratings, result progression
-- PositionRating for defensive player attributes (range 1-5, error 0-88, arm 1-5)
-- PlayOutcome.X_CHECK for outcome routing
-
-**Testing**: Integrated into existing model tests
-
----
-
-### Phase 3B: X-Check League Config Tables (2025-11-01)
-**Commit**: `0b6076d` (tables), `cc5bf43` (error charts)
-
-**Files Created**:
-- `backend/app/config/common_x_check_tables.py` (12KB) - Complete table system
-- `tests/unit/config/test_x_check_tables.py` (36 tests) - Comprehensive validation
-
-**Files Modified**:
-- `backend/app/config/league_configs.py` - Imported tables into SbaConfig and PdConfig
-- `backend/app/core/runner_advancement.py` - Added 6 X-Check placeholder functions
-- `tests/unit/core/test_runner_advancement.py` - Added 9 placeholder tests
-
-**Implementation Details**:
-
-1. **Defense Range Tables** (Complete):
-   - INFIELD_DEFENSE_TABLE (20×5) - P, C, 1B, 2B, 3B, SS
-   - OUTFIELD_DEFENSE_TABLE (20×5) - LF, CF, RF
-   - CATCHER_DEFENSE_TABLE (20×5) - Special catcher-specific results
-   - Maps d20 roll + range (1-5) → result code (G1, F2, SI2, SPD, etc.)
-
-2. **Error Charts** (Complete):
-   - LF_RF_ERROR_CHART (26 ratings: 0-25)
-   - CF_ERROR_CHART (26 ratings: 0-25)
-   - PITCHER_ERROR_CHART (40 ratings: 0-51, sparse)
-   - CATCHER_ERROR_CHART (17 ratings: 0-16)
-   - FIRST_BASE_ERROR_CHART (31 ratings: 0-30)
-   - SECOND_BASE_ERROR_CHART (40 ratings: 0-71, sparse)
-   - THIRD_BASE_ERROR_CHART (45 ratings: 0-65, sparse)
-   - SHORTSTOP_ERROR_CHART (43 ratings: 0-88, sparse)
-   - All 9 positions complete! Maps 3d6 + error rating → error type (NO, E1, E2, E3, RP)
-
-3. **Helper Functions** (Complete):
-   - `get_fielders_holding_runners(runner_bases, batter_hand)` - Full implementation
-   - `get_error_chart_for_position(position)` - Maps position to chart
-
-4. **X-Check Placeholders** (Ready for Phase 3D):
-   - `x_check_g1(on_base_code, defender_in, error_result)` → AdvancementResult
-   - `x_check_g2(on_base_code, defender_in, error_result)` → AdvancementResult
-   - `x_check_g3(on_base_code, defender_in, error_result)` → AdvancementResult
-   - `x_check_f1(on_base_code, error_result)` → AdvancementResult
-   - `x_check_f2(on_base_code, error_result)` → AdvancementResult
-   - `x_check_f3(on_base_code, error_result)` → AdvancementResult
-
-**Testing**: 45/45 tests passing (36 table tests + 9 placeholder tests)
-
----
-
-### Phase 3C: X-Check Resolution Logic (2025-11-02)
-**Commit**: `10515cb`, documented in `7f74dc6`
-
-**Files Modified**:
-- `backend/app/core/play_resolver.py` (+397 lines, -2 lines)
-- `backend/CLAUDE.md` (+114 lines documentation)
-
-**Implementation Details**:
-
-1. **Main Resolution Method**: `_resolve_x_check()` (92 lines)
-   - 10-step resolution process: dice → defense → SPD → conversion → error → outcome
-   - Rolls 1d20 for defense table lookup
-   - Rolls 3d6 for error chart lookup
-   - Creates complete XCheckResult audit trail
-   - Returns PlayResult with x_check_details
-
-2. **Helper Methods** (6 new methods, 305 lines total):
-   - `_adjust_range_for_defensive_position()` - Playing in logic (+1 range, max 5)
-   - `_lookup_defense_table()` - Maps d20 + range → result code
-   - `_apply_hash_conversion()` - G2#/G3# → SI2 if conditions met
-   - `_lookup_error_chart()` - Maps 3d6 + error rating → error type
-   - `_determine_final_x_check_outcome()` - Maps result + error → PlayOutcome
-
-3. **Integration Points**:
-   - Added X_CHECK case to `resolve_outcome()` method
-   - Extended PlayResult dataclass with `x_check_details: Optional[XCheckResult]`
-   - Imported all Phase 3B tables and helpers
-
-**Key Features**:
-- Defense table lookup selects correct table (infield/outfield/catcher)
-- Range adjustment: corners_in or infield_in adds +1 to range (max 5)
-- Hash conversion: G2#/G3# → SI2 if playing in OR holding runner
-- Error priority: RP > E3 > E2 > E1 > NO
-- Error overrides outs: If base result is out + error occurs → ERROR outcome
-- Rare play handling: RP treated as ERROR for stats
-
-**Placeholders** (Future Work):
-1. Defender retrieval - Currently uses placeholder ratings (TODO: lineup integration)
-2. SPD test - Currently defaults to G3 fail (TODO: batter speed rating)
-3. Batter handedness - Currently hardcoded 'R' (TODO: player model)
-4. Runner advancement - Currently returns empty list (TODO Phase 3D)
-
-**Testing**:
-- 325/327 total tests passing (99.4%)
-- All 9 PlayResolver tests passing
-- All 36 X-Check table tests passing
-- All 51 runner advancement tests passing
-- 2 pre-existing failures (unrelated: dice history, config URL)
-
----
-
-### Phase 3D: X-Check Runner Advancement Tables (2025-11-02)
-**Commit**: `fb282a5` (includes critical bug fixes)
-
-**Files Created**:
-- `backend/app/core/x_check_advancement_tables.py` (690 lines) - Complete advancement system
-- `tests/unit/core/test_x_check_advancement_tables.py` (786 lines, 59 tests)
-- `.claude/implementation/GROUNDBALL_CHART_REFERENCE.md` (158 lines) - Official chart documentation
-- `.claude/implementation/PHASE_3D_CRITICAL_FIX.md` (353 lines) - Bug fix documentation
-- `.claude/implementation/XCHECK_TEST_VALIDATION.md` (342 lines) - Test validation guide
-
-**Files Modified**:
-- `backend/app/core/runner_advancement.py` - Implemented 6 X-Check functions (no longer placeholders)
-- `backend/app/core/play_resolver.py` - Updated dice rolling to use proper audit trail
-- `backend/CLAUDE.md` - Added Phase 3D documentation
-
-**Implementation Details**:
-
-1. **Groundball Advancement Tables** (Complete):
-   - `G1_ADVANCEMENT_TABLE` - 8 base codes × 2 positions × 5 errors = 80 entries
-   - `G2_ADVANCEMENT_TABLE` - 8 base codes × 2 positions × 5 errors = 80 entries
-   - `G3_ADVANCEMENT_TABLE` - 8 base codes × 2 positions × 5 errors = 80 entries
-   - Maps to GroundballResultType enum (13 result types)
-   - Defender position matters: Normal vs Infield In affects advancement
-
-2. **Flyball Advancement Tables** (Complete):
-   - `F1_ADVANCEMENT_TABLE` - 8 base codes × 5 errors = 40 entries
-   - `F2_ADVANCEMENT_TABLE` - 8 base codes × 5 errors = 40 entries
-   - `F3_ADVANCEMENT_TABLE` - 8 base codes × 5 errors = 40 entries
-   - Returns RunnerMovement lists directly
-   - Deeper flyballs allow more aggressive advancement
-
-3. **Helper Functions** (Complete):
-   - `build_advancement_from_code()` - Converts on_base_code (0-7) to runner movements
-   - `build_flyball_advancement_with_error()` - Applies error bonuses to flyball advancement
-   - `get_groundball_advancement()` - Looks up groundball table entry
-   - `get_flyball_advancement()` - Looks up flyball table entry
-
-4. **X-Check Functions in runner_advancement.py** (Implemented):
-   - `x_check_g1()`, `x_check_g2()`, `x_check_g3()` - Groundball advancement
-   - `x_check_f1()`, `x_check_f2()`, `x_check_f3()` - Flyball advancement
-   - All map table results to existing groundball/flyball functions
-   - All return proper AdvancementResult objects
-
-**Critical Bugs Fixed**:
-
-1. **Bug #1: on_base_code Mapping Error**
-   - WRONG: Treated as bit field (Code 3 = 0b011 = R1+R2)
-   - CORRECT: Sequential mapping (Code 3 = R3 only, Code 4 = R1+R2)
-   - Fixed in: `build_advancement_from_code()`, `build_flyball_advancement_with_error()`
-   - Impact: 13 test values corrected (Code 3↔4 swapped)
-
-2. **Bug #2: Table Data vs Official Charts**
-   - 7 entries in G1/G2 tables didn't match official rulebook
-   - All 7 corrected to match provided charts
-   - Documented in GROUNDBALL_CHART_REFERENCE.md
-
-3. **Improvement: Dice Audit Trail**
-   - Changed from manual `dice.roll_d6(3)` to `dice_system.roll_fielding()`
-   - Benefits: Automatic error_total calculation, position tracking, consistent patterns
-   - Updated in `play_resolver.py:_resolve_x_check()`
-
-**Testing**: 59/59 tests passing (100%)
-- 24 tests for G1 advancement (all base codes, positions, errors)
-- 24 tests for G2 advancement
-- 11 tests for G3 advancement (strategic subset)
-- All groundball and flyball function tests passing
-- PlayResolver integration tests passing
-
----
-
-### Phase 3E-Prep: GameState Refactor (2025-11-03)
-**Commit**: `d560844`
-
-**Files Modified**:
-- `backend/app/models/game_models.py` - Changed current_batter/pitcher/catcher to full objects
-- `backend/app/core/game_engine.py` - Updated _prepare_next_play() to populate full objects
-- `backend/app/core/state_manager.py` - Create placeholder batter on game creation
-- `tests/unit/models/test_game_models.py` - Updated all 27 GameState tests (all passing)
-
-**Files Created**:
-- `.claude/implementation/GAMESTATE_REFACTOR_PLAN.md` - Complete refactor documentation
-
-**Implementation**: Architectural improvement for consistency and Phase 3E readiness
-
-**BEFORE (Inconsistent)**:
+**Technical Notes**:
 ```python
-# Runners were full objects
-on_first: Optional[LineupPlayerState] = None
-on_second: Optional[LineupPlayerState] = None
-on_third: Optional[LineupPlayerState] = None
-
-# But current players were just IDs
-current_batter_lineup_id: int
-current_pitcher_lineup_id: Optional[int] = None
-current_catcher_lineup_id: Optional[int] = None
+# Redis key pattern: "position_ratings:{card_id}:{position}"
+# TTL: 86400 seconds (24 hours)
+# Store as JSON serialized PositionRating.model_dump()
 ```
 
-**AFTER (Consistent)**:
-```python
-# All player references are now full objects
-on_first: Optional[LineupPlayerState] = None
-on_second: Optional[LineupPlayerState] = None
-on_third: Optional[LineupPlayerState] = None
-current_batter: LineupPlayerState
-current_pitcher: Optional[LineupPlayerState] = None
-current_catcher: Optional[LineupPlayerState] = None
-```
+#### 3. Full Defensive Lineup in GameState
+**Priority**: LOW
+**Estimate**: 1-2 hours
 
-**Benefits**:
-1. **Consistent API**: All player references use same type (LineupPlayerState objects)
-2. **Self-contained State**: GameState has everything needed for resolution
-3. **No lookups needed**: Direct access to player data (`state.current_batter.card_id`)
-4. **Foundation for Phase 3E-Main**: Easy to add `position_rating` field to objects
+Currently only `current_pitcher` and `current_catcher` are direct fields.
+Consider adding full defensive positions for easier access:
 
-**Database Operations**:
-- No schema changes needed (Play table still stores IDs)
-- IDs extracted from objects when saving: `state.current_batter.lineup_id`
-- Maintains referential integrity
+- [ ] Add optional `defensive_positions: Dict[str, int]` to GameState
+- [ ] Map position → lineup_id for all 9 fielders
+- [ ] Update on lineup changes and substitutions
+- [ ] Evaluate if this improves performance vs current StateManager lookup
 
-**Testing**: All 27 GameState tests passing, no regressions
+**Evaluation Needed**: May not be necessary since StateManager lookup is already O(1).
 
-**Rationale**: Sets foundation for Phase 3E-Main where we'll add position ratings to LineupPlayerState. This refactor makes GameState truly self-contained - everything needed for X-Check resolution will be in the state object.
+#### 4. Manual vs Auto Mode X-Check Workflows
+**Priority**: MEDIUM
+**Estimate**: 2 hours
+
+- [ ] Document manual mode flow (player confirms chart reads)
+- [ ] Document auto mode flow (immediate resolution)
+- [ ] Ensure UI shows defender ratings in both modes
+- [ ] Add confirmation step in manual mode before advancing
 
 ---
 
-## Key Architecture Decisions Made
+## 📊 Phase 3 Overall Progress
 
-### 1. **X-Check as First-Class PlayOutcome**
-- **Decision**: Add PlayOutcome.X_CHECK as explicit outcome type
-- **Rationale**:
-  - X-Checks are distinct from standard groundball/flyball outcomes
-  - Require different resolution path (defense tables + error charts)
-  - Need detailed audit trail (XCheckResult)
-- **Impact**: Clean separation of X-Check logic in PlayResolver
-
-### 2. **Comprehensive Error Chart System**
-- **Decision**: Implement complete error charts for all 9 defensive positions
-- **Rationale**:
-  - Different positions have vastly different error profiles
-  - Infield charts sparse (up to rating 88 for SS)
-  - Outfield charts dense (ratings 0-25)
-  - Matches physical rulebook structure
-- **Impact**: Accurate error simulation for all defensive scenarios
-
-### 3. **Hash Conversion Dual Conditions**
-- **Decision**: G2#/G3# converts to SI2 if playing in OR holding runner
-- **Rationale**:
-  - Playing in: Defender closer to plate, more likely to reach ball late
-  - Holding runner: Defender can't get full jump on ball
-  - OR logic: Either condition independently causes conversion
-- **Impact**: Realistic strategic tradeoffs for defensive positioning
-
-### 4. **Error Overrides Outs**
-- **Decision**: When error occurs on out result, final outcome becomes ERROR
-- **Rationale**:
-  - Error prevents out from being recorded
-  - Matches physical game rules
-  - Affects scoring (unearned runs)
-- **Impact**: Accurate simulation of defensive mistakes
-
-### 5. **Placeholder Pattern for Phase 3D**
-- **Decision**: Create empty X-Check advancement functions now, fill in Phase 3D
-- **Rationale**:
-  - Tables are complex (G1/G2/G3 each have 8 base codes × 2 positions × 5 errors)
-  - Better to implement resolution logic first, then tackle tables
-  - Clean separation of concerns
-- **Impact**: Phase 3C complete without blocking on table data
-
-### 6. **Unified Player References in GameState** (Phase 3E-Prep)
-- **Decision**: Change current_batter/pitcher/catcher from IDs to full LineupPlayerState objects
-- **Rationale**:
-  - Inconsistency: runners (on_first/second/third) were objects but current players were IDs
-  - Self-contained state: everything needed for resolution in one place
-  - Foundation for Phase 3E: easy to add position_rating field to existing objects
-  - No lookups: direct access to player data without StateManager queries
-- **Impact**:
-  - GameState is now fully self-contained
-  - No external lookups needed during play resolution
-  - Clean foundation for adding position ratings
-  - Database unchanged (IDs extracted when saving)
+| Phase | Status | Progress |
+|-------|--------|----------|
+| 3A: Core Models | ✅ Complete | 100% |
+| 3B: Play Validation | ✅ Complete | 100% |
+| 3C: Result Charts | ✅ Complete | 100% |
+| 3D: Dice & Resolution | ✅ Complete | 100% |
+| 3E-Prep: Refactoring | ✅ Complete | 100% |
+| **3E-Main: Position Ratings** | ✅ Complete | **100%** |
+| **3E-Final: UI & Redis** | ⏳ In Progress | **0%** |
+| **Overall Phase 3** | ⏳ In Progress | **~95%** |
 
 ---
 
-## Blockers Encountered 🚧
+## 🚀 Quick Start for Next Session
 
-None - all phases (3A, 3B, 3C, 3D, 3E-Prep) completed successfully without major blockers.
+### To continue Phase 3E-Final:
 
-**Minor Issues Resolved**:
-- Import order required XCheckResult in game_models.py before play_resolver.py import
-- Dice system needed d6 rolling method (already existed as `roll_d6()`)
-- Error chart lookup needed fallback for missing ratings (uses rating 0 as default)
-- Phase 3D: on_base_code misunderstood as bit field (corrected to sequential mapping)
-- Phase 3D: 7 table entries corrected to match official rulebook charts
-
----
-
-## Outstanding Questions ❓
-
-### 1. **Runner Advancement Table Data Source** ✅ RESOLVED
-   - **Resolution**: Complete rulebook data obtained and implemented in Phase 3D
-   - **Result**: All 6 advancement tables (G1, G2, G3, F1, F2, F3) complete with 420 total entries
-   - **Validation**: 59 tests passing, all tables match official charts (7 corrections made)
-   - **Status**: Phase 3D 100% complete
-
-### 2. **Defender Lookup Integration** 🔲 ACTIVE (Phase 3E)
-   - **Question**: When should we integrate actual defender retrieval from lineup?
-   - **Context**: Phase 3C uses placeholder ratings; need lineup access to get actual defender
-   - **Impact**: Currently X-Check can't run in real games (no actual defender data)
-   - **Recommendation**: Address in Phase 3E (WebSocket integration) when full game context available
-
-### 3. **SPD Test Batter Speed Source**
-   - **Question**: Where do we store/access batter speed ratings?
-   - **Context**: SPD test needs batter's speed (0-20) for 1d20 comparison
-   - **Options**:
-     - (A) Add to BasePlayer model (all players have speed)
-     - (B) Add to PositionRating (speed varies by card)
-     - (C) Add to GameState (pre-loaded for current batter)
-   - **Impact**: Affects player model architecture
-   - **Recommendation**: Option B - PositionRating includes speed (matches rulebook structure)
-
----
-
-## Tasks for Next Session
-
-### Phase 3E-Main Focus: Position Ratings & Self-Contained State
-
-**Simplified Approach**: With Phase 3E-Prep complete, GameState now uses full LineupPlayerState objects. We just need to:
-1. Add PositionRating dataclass (if not already exists from Phase 3A)
-2. Add `position_rating` field to LineupPlayerState
-3. Load ratings at game start and attach to objects
-4. X-Check resolution already has access via `state.current_batter.position_rating`
-
----
-
-### Task 1: Create/Verify PositionRating Dataclass (30 mins)
-
-**File(s)**: `backend/app/models/player_models.py`
-
-**Goal**: Ensure PositionRating dataclass exists with all needed fields for X-Check resolution.
-
-**Check If Exists**: Phase 3A may have created this already. Verify fields include:
-```python
-@dataclass
-class PositionRating:
-    """Defensive ratings for a player at a specific position."""
-    position: str       # Position code (SS, 3B, LF, etc.)
-    range: int          # Range rating (1-5)
-    error: int          # Error rating (0-88 depending on position)
-    arm: int            # Arm strength (1-5)
-    speed: Optional[int] = None  # Speed rating (0-20) for SPD tests
-```
-
-**Test Command**:
-```bash
-pytest tests/unit/models/test_player_models.py -v -k PositionRating
-```
-
-**Acceptance Criteria**:
-- [ ] PositionRating dataclass exists with all fields
-- [ ] Tests exist for PositionRating
-- [ ] Documented in player_models.py
-
----
-
-### Task 2: Add position_rating Field to LineupPlayerState (30 mins)
-
-**File(s)**: `backend/app/models/game_models.py`
-
-**Goal**: Add position_rating field to LineupPlayerState so ratings can be attached at game start.
-
-**Changes**:
-```python
-class LineupPlayerState(BaseModel):
-    lineup_id: int
-    card_id: int
-    position: str
-    batting_order: Optional[int] = None
-    is_active: bool = True
-
-    # NEW: Position rating (loaded at game start for PD league)
-    position_rating: Optional[PositionRating] = None
-```
-
-**Test Command**:
-```bash
-pytest tests/unit/models/test_game_models.py::TestLineupPlayerState -v
-```
-
-**Acceptance Criteria**:
-- [ ] position_rating field added
-- [ ] Optional (SBA won't have ratings)
-- [ ] Tests updated
-- [ ] No breaking changes to existing tests
-
----
-
-### Task 3: Create PD API Client for Position Ratings (1-2 hours)
-
-**File(s)**: `backend/app/services/pd_api_client.py` (NEW)
-
-**Goal**: Create service to fetch player position ratings from PD API.
-
-**Changes**:
-1. Create new module:
-   ```python
-   """
-   PD API client for fetching player position ratings.
-
-   Integrates with Paper Dynasty API to retrieve defensive ratings
-   for use in X-Check resolution.
-
-   Author: Claude
-   Date: 2025-11-02
-   """
-   import logging
-   import httpx
-   from typing import Optional
-   from app.models.player_models import PositionRating
-   from app.config.settings import get_settings
-
-   logger = logging.getLogger(f'{__name__}.PdApiClient')
-
-   class PdApiClient:
-       """Client for PD API position rating lookups."""
-
-       async def get_position_rating(
-           self,
-           player_id: int,
-           position: str
-       ) -> Optional[PositionRating]:
-           """Fetch position rating for player at given position."""
-           # Implementation
-   ```
-
-2. Add settings for PD API URL and authentication
-3. Implement async HTTP client with timeout/retry logic
-4. Parse API response to PositionRating model
-
-**Test Command**:
-```bash
-export PYTHONPATH=. && pytest tests/unit/services/test_pd_api_client.py -v
-```
-
-**Acceptance Criteria**:
-- [ ] PdApiClient class created
-- [ ] get_position_rating() method implemented
-- [ ] Proper error handling for API failures
-- [ ] Returns PositionRating or None
-- [ ] At least 10 unit tests with mocked responses
-
----
-
-### Task 3: Implement Redis Caching for Position Ratings (1-2 hours)
-
-**File(s)**: `backend/app/services/position_rating_service.py` (NEW)
-
-**Goal**: Create caching layer to reduce API calls for position ratings.
-
-**Changes**:
-1. Create new service module:
-   ```python
-   """
-   Position rating service with Redis caching.
-
-   Provides cached access to position ratings with automatic
-   expiration and fallback to API.
-
-   Author: Claude
-   Date: 2025-11-02
-   """
-   import logging
-   from typing import Optional
-   from app.models.player_models import PositionRating
-   from app.services.pd_api_client import PdApiClient
-   from app.core.cache import RedisCache
-
-   logger = logging.getLogger(f'{__name__}.PositionRatingService')
-
-   class PositionRatingService:
-       """Service for position rating lookup with caching."""
-
-       async def get_rating(
-           self,
-           player_id: int,
-           position: str,
-           league_id: str
-       ) -> Optional[PositionRating]:
-           """Get position rating with Redis cache."""
-           # Check cache first
-           # If miss, fetch from API and cache
-           # Return rating or None
-   ```
-
-2. Cache key format: `position_rating:{league_id}:{player_id}:{position}`
-3. TTL: 24 hours (ratings don't change mid-game)
-4. Serialize PositionRating to JSON for Redis storage
-
-**Test Command**:
-```bash
-export PYTHONPATH=. && pytest tests/unit/services/test_position_rating_service.py -v
-```
-
-**Acceptance Criteria**:
-- [ ] PositionRatingService class created
-- [ ] Redis caching implemented with 24h TTL
-- [ ] Cache hit/miss logic working
-- [ ] Graceful degradation if Redis unavailable
-- [ ] At least 15 unit tests (cache hits, misses, failures)
-
----
-
-### Task 4: Update PlayResolver to Use Actual Defender Ratings (1 hour)
-
-**File(s)**: `backend/app/core/play_resolver.py`
-
-**Goal**: Replace placeholder defender ratings with actual lookups.
-
-**Changes**:
-1. Add PositionRatingService dependency to PlayResolver constructor
-2. Update `_resolve_x_check()` method (lines 620-640):
-   ```python
-   # OLD (placeholder):
-   defender_range = 3
-   defender_error = 10
-
-   # NEW (actual lookup):
-   position_rating = await self.position_service.get_rating(
-       player_id=defender.player_id,
-       position=check_position,
-       league_id=state.league_id
-   )
-
-   if position_rating:
-       defender_range = position_rating.range
-       defender_error = position_rating.error
-   else:
-       # Fallback to league average
-       logger.warning(f"No rating for {defender.player_id} at {check_position}, using defaults")
-       defender_range = 3
-       defender_error = 15
-   ```
-
-3. Add defender retrieval from lineup (replace placeholder)
-4. Handle SBA league gracefully (may not have ratings)
-
-**Test Command**:
-```bash
-export PYTHONPATH=. && pytest tests/unit/core/test_play_resolver.py -v
-```
-
-**Acceptance Criteria**:
-- [ ] PositionRatingService integrated into PlayResolver
-- [ ] Actual defender lookup from lineup
-- [ ] Actual rating lookup from service (with cache)
-- [ ] Graceful fallback for missing ratings
-- [ ] All PlayResolver tests still passing
-
----
-
-### Task 5: Implement WebSocket Events for X-Check (1-2 hours)
-
-**File(s)**: `backend/app/websocket/game_handlers.py`
-
-**Goal**: Add WebSocket event handlers for X-Check flows.
-
-**Changes**:
-1. Add new events:
-   - `x_check_auto_result` - Broadcast auto-resolved result with Accept/Reject options
-   - `x_check_manual_options` - Broadcast dice + legal outcome options
-   - `confirm_x_check_result` - User accepts auto-result
-   - `reject_x_check_result` - User rejects, provide manual options
-   - `submit_x_check_manual` - User submits manual outcome selection
-
-2. Event payloads:
-   ```python
-   # x_check_auto_result
-   {
-       "result": {
-           "outcome": "GROUNDOUT",
-           "check_position": "SS",
-           "defender_range": 4,
-           "range_roll": 12,
-           "error_roll": 10,
-           "error_result": "NO",
-           "advancement": [...]
-       },
-       "can_accept": true,
-       "can_reject": true
-   }
-
-   # x_check_manual_options
-   {
-       "dice": {
-           "range_roll": 12,
-           "error_roll": 10
-       },
-       "legal_outcomes": ["GROUNDOUT", "SINGLE", "ERROR"],
-       "position": "SS"
-   }
-   ```
-
-3. Update game engine to emit appropriate events based on mode
-
-**Test Command**:
-```bash
-export PYTHONPATH=. && pytest tests/websocket/test_x_check_events.py -v
-```
-
-**Acceptance Criteria**:
-- [ ] All 5 event handlers implemented
-- [ ] Event payloads match specification
-- [ ] Mode detection working (Auto/Manual/Semi-Auto)
-- [ ] Override logging on rejection
-- [ ] At least 12 WebSocket event tests
-
----
-
-### Task 6: Update Documentation (30 mins)
-
-**File(s)**: `backend/CLAUDE.md`, `.claude/implementation/NEXT_SESSION.md`
-
-**Goal**: Document Phase 3E completion.
-
-**Changes**:
-1. Add Phase 3E section to backend/CLAUDE.md
-2. Update NEXT_SESSION.md to reflect Phase 3E complete (100% Phase 3)
-3. Document API client, caching, and WebSocket events
-4. Update test counts
-
-**Acceptance Criteria**:
-- [ ] Phase 3E documented in CLAUDE.md
-- [ ] NEXT_SESSION.md updated for Phase 3F
-- [ ] Test counts updated
-- [ ] Architecture decisions documented
-
----
-
-## Files to Review Before Starting
-
-Critical files for Phase 3E work:
-
-1. **`@.claude/implementation/phase-3e-websocket-events.md`** - Complete Phase 3E specification
-   - WebSocket event flows
-   - API client requirements
-   - Caching strategy
-   - Testing requirements
-
-2. **`backend/app/core/play_resolver.py:589-731`** - _resolve_x_check() method
-   - Lines 620-640: Placeholder defender ratings (need actual lookup)
-   - See complete X-Check resolution flow
-   - Integration point for PositionRatingService
-
-3. **`backend/app/websocket/game_handlers.py`** - Existing WebSocket handlers
-   - Pattern for new X-Check event handlers
-   - Event structure and payload formats
-   - Error handling patterns
-
-4. **`backend/app/models/player_models.py`** - PositionRating model
-   - Already defined in Phase 3A
-   - Fields: range (1-5), error (0-88), arm (1-5)
-   - Used by API client and caching service
-
-5. **`backend/app/config/settings.py`** - Application settings
-   - Need to add PD_API_URL setting
-   - Need to add PD_API_TOKEN setting
-   - Redis configuration already exists
-
-6. **`backend/app/core/cache.py`** - Redis cache utilities (if exists)
-   - Check for existing Redis patterns
-   - May need to create if doesn't exist
-
-7. **`backend/app/models/game_models.py:147-180`** - XCheckResult model
-   - Contains all X-Check resolution details
-   - Used in WebSocket event payloads
-   - Review fields for event serialization
-
-8. **Existing API client patterns** - Check for similar service modules
-   - Look for existing HTTP clients (httpx usage)
-   - Review async/await patterns
-   - Check error handling conventions
-
----
-
-## Verification Steps
-
-After completing all Phase 3E tasks:
-
-1. **Run all tests**:
+1. **Start with WebSocket handlers** (highest user impact):
    ```bash
-   # Service tests
-   export PYTHONPATH=. && pytest tests/unit/services/ -v
-
-   # Core tests (PlayResolver with actual ratings)
-   export PYTHONPATH=. && pytest tests/unit/core/test_play_resolver.py -v
-
-   # WebSocket tests
-   export PYTHONPATH=. && pytest tests/websocket/test_x_check_events.py -v
+   cd /mnt/NV2/Development/strat-gameplay-webapp/backend
+   source venv/bin/activate
    ```
 
-2. **Manual testing** (with Redis and API):
+2. **Test current implementation**:
    ```bash
+   export PYTHONPATH=.
+   python test_pd_api_live.py  # Verify API still works
+   ```
+
+3. **Add Redis** (requires Redis server running):
+   ```bash
+   # Install Redis if needed
+   sudo dnf install redis  # or brew install redis
+
    # Start Redis
-   redis-server
+   sudo systemctl start redis
 
-   # Run backend with PD API credentials
-   export PD_API_URL="https://api.paperdynasty.com"
-   export PD_API_TOKEN="your_token_here"
-   python -m uvicorn app.main:app --reload
-
-   # Test X-Check flow in terminal client
-   python -m terminal_client
-   > new_game
-   > start_game
-   > defensive
-   > offensive
-   > resolve  # Should fetch defender ratings, resolve X-Check
-   > status
+   # Add to requirements
+   echo "redis>=5.0.0" >> requirements.txt
+   pip install redis
    ```
 
-3. **Verify Redis caching**:
+4. **Run existing tests**:
    ```bash
-   # Check cache keys
-   redis-cli KEYS "position_rating:*"
-
-   # Verify TTL
-   redis-cli TTL "position_rating:pd:12345:SS"
-
-   # Should show ~86400 seconds (24 hours)
-   ```
-
-4. **Test WebSocket events** (using WebSocket client):
-   ```javascript
-   // Connect to game
-   socket.emit('join_game', {game_id: 'xxx'});
-
-   // Trigger X-Check
-   // Should receive x_check_auto_result or x_check_manual_options
-
-   // Accept auto result
-   socket.emit('confirm_x_check_result', {game_id: 'xxx'});
-
-   // Or reject and choose manually
-   socket.emit('reject_x_check_result', {game_id: 'xxx'});
-   socket.emit('submit_x_check_manual', {
-       game_id: 'xxx',
-       outcome: 'SINGLE'
-   });
-   ```
-
-5. **Commit changes**:
-   ```bash
-   git add backend/app/services/pd_api_client.py \
-           backend/app/services/position_rating_service.py \
-           backend/app/core/play_resolver.py \
-           backend/app/websocket/game_handlers.py \
-           backend/CLAUDE.md \
-           tests/unit/services/ \
-           tests/websocket/test_x_check_events.py \
-           .claude/implementation/NEXT_SESSION.md
-
-   git commit -m "CLAUDE: Implement Phase 3E - WebSocket Events & UI Integration
-
-   Complete X-Check WebSocket integration with position rating service:
-   - Created PdApiClient for fetching position ratings from API
-   - Created PositionRatingService with Redis caching (24h TTL)
-   - Updated PlayResolver to use actual defender ratings (not placeholders)
-   - Implemented 5 WebSocket events for X-Check flows
-   - Support for Auto, Manual, and Semi-Auto modes
-   - Accept/Reject workflow for auto-resolved plays
-   - Override logging for rejected auto-results
-
-   Testing:
-   - 10+ tests for PD API client
-   - 15+ tests for position rating service (cache hits/misses)
-   - 12+ tests for WebSocket events
-   - All existing tests still passing
-
-   Phase 3E Status: 100% COMPLETE ✅
-   Ready for Phase 3F (Testing & Integration)
-
-   🤖 Generated with [Claude Code](https://claude.com/claude-code)
-
-   Co-Authored-By: Claude <noreply@anthropic.com>"
+   pytest tests/integration/test_position_ratings_api.py -v
    ```
 
 ---
 
-## Success Criteria
+## 📝 Important Notes
 
-Phase 3E will be **100% complete** when:
+### Architecture Decisions
+- **In-memory cache is temporary**: Intentional technical debt, Redis upgrade planned
+- **StateManager pattern**: O(1) defender lookups, no DB queries during play resolution
+- **League-agnostic design**: Config-driven behavior, easy to extend to new leagues
+- **Graceful degradation**: Always works even if API/cache is down
 
-- [ ] PdApiClient created for position rating API calls
-- [ ] PositionRatingService created with Redis caching
-- [ ] PlayResolver uses actual defender ratings (not placeholders)
-- [ ] Defender lookup from lineup implemented
-- [ ] All 5 WebSocket events implemented (auto_result, manual_options, confirm, reject, submit)
-- [ ] Auto/Manual/Semi-Auto mode detection working
-- [ ] Accept/Reject workflow functional
-- [ ] Override logging implemented
-- [ ] At least 10 tests for API client
-- [ ] At least 15 tests for position rating service
-- [ ] At least 12 tests for WebSocket events
-- [ ] All existing tests still passing
-- [ ] Documentation updated (CLAUDE.md, NEXT_SESSION.md)
-- [ ] Git commit created with Phase 3E completion
+### API Details
+- **Base URL**: `https://pd.manticorum.com`
+- **Endpoint**: `GET /api/v2/cardpositions?player_id={id}&position={pos}`
+- **Rate Limiting**: Unknown - caching mitigates this risk
+- **Error Handling**: Returns empty list on API errors, uses defaults
 
-**Expected Test Count After Phase 3E**: ~427 tests (390 current + ~37 new service/WebSocket tests)
+### Testing Strategy
+- **Live tests**: Use player 8807 (7 positions) for comprehensive testing
+- **Mock tests**: For CI/CD without API dependency
+- **Integration tests**: Full flow from API → GameState → X-Check
+
+### Performance
+- Cache is critical: 16,000x+ speedup
+- Load ratings at game start (not during play resolution)
+- Redis will enable cross-instance sharing and persistence
 
 ---
 
-## Quick Reference
+## 🔗 Related Documentation
 
-**Current Test Count**: ~390 tests passing (after Phase 3D)
-**Last Test Run**: All X-Check advancement tests passing (2025-11-02)
-**Branch**: `implement-phase-3`
-**Python**: 3.13.3
-**Virtual Env**: `backend/venv/`
-**Redis**: Required for Phase 3E (position rating cache)
-
-**Key Imports for Next Session**:
-```python
-# Services (NEW in Phase 3E)
-from app.services.pd_api_client import PdApiClient
-from app.services.position_rating_service import PositionRatingService
-
-# Models
-from app.models.player_models import PositionRating
-from app.models.game_models import XCheckResult, GameState
-
-# Play resolution
-from app.core.play_resolver import PlayResolver
-
-# WebSocket
-from app.websocket.game_handlers import (
-    handle_x_check_auto_result,
-    handle_confirm_x_check_result,
-    handle_reject_x_check_result,
-    handle_submit_x_check_manual,
-)
-
-# Testing
-import pytest
-from unittest.mock import Mock, AsyncMock, patch
-import httpx
-```
-
-**Recent Commit History** (Last 5):
-```
-fb282a5 - CLAUDE: Fix critical X-Check bugs and improve dice rolling (most recent)
-7f74dc6 - CLAUDE: Update documentation for Phase 3C completion
-10515cb - CLAUDE: Implement Phase 3C - X-Check Resolution Logic
-cc5bf43 - CLAUDE: Complete Phase 3B - Add all 6 infield error charts
-0b6076d - CLAUDE: Implement Phase 3B - X-Check league config tables
-```
+- **Full implementation details**: `backend/CLAUDE.md` lines 2132-2264
+- **Phase 3E-Main commit**: `02e816a`
+- **PD API client**: `app/services/pd_api_client.py`
+- **Position rating service**: `app/services/position_rating_service.py`
+- **Live integration test**: `test_pd_api_live.py`
 
 ---
 
-## Context for AI Agent Resume
-
-**If the next agent needs to understand the bigger picture**:
-- Overall project: See `@prd-web-scorecard-1.1.md` and `@backend/CLAUDE.md`
-- Architecture: See `@.claude/implementation/00-index.md`
-- Phase 3 overview: See `@.claude/implementation/PHASE_3_OVERVIEW.md`
-- Phase 3E details: See `@.claude/implementation/phase-3e-websocket-events.md`
-- X-Check resolution: See `@backend/app/core/play_resolver.py:589-731`
-
-**Critical files in current focus area**:
-1. `backend/app/core/play_resolver.py` - X-Check resolution (lines 620-640 need defender lookup)
-2. `backend/app/websocket/game_handlers.py` - WebSocket event patterns
-3. `backend/app/models/player_models.py` - PositionRating model
-4. `backend/app/models/game_models.py` - XCheckResult for event payloads
-5. `.claude/implementation/phase-3e-websocket-events.md` - Complete Phase 3E spec
-6. `backend/app/config/settings.py` - Add PD API settings
-
-**What NOT to do**:
-- ❌ Don't use Python's `datetime` (use Pendulum)
-- ❌ Don't return `Optional` unless required ("Raise or Return" pattern)
-- ❌ Don't disable type checking globally (use targeted `# type: ignore`)
-- ❌ Don't forget `export PYTHONPATH=.` when running tests
-- ❌ Don't run all integration tests at once (connection pooling issues)
-- ❌ Don't commit without "CLAUDE: " prefix
-- ❌ Don't modify Phase 3A-3D code (foundation complete)
-- ❌ Don't hardcode API credentials (use environment variables)
-
-**Patterns to follow**:
-- ✅ Async HTTP pattern: Use httpx.AsyncClient for API calls
-- ✅ Redis caching pattern: Check existing cache utilities
-- ✅ WebSocket event pattern: See existing game_handlers.py events
-- ✅ Service pattern: Create services/ directory if doesn't exist
-- ✅ Mock pattern: Use AsyncMock for async functions in tests
-
----
-
-**Estimated Time for Next Session**: 5-7 hours (6 tasks)
-**Priority**: High - Enables real-world X-Check usage
-**Blocking Other Work**: No - Phase 3F can proceed with manual testing
-**Next Milestone After This**: Phase 3F - Testing & Integration (final validation before production)
-
----
-
-## Phase 3 Progress Summary
-
-**Phase 3: X-Check Play System** (Weeks 7-9)
-
-| Sub-Phase | Status | Completion | Key Deliverables |
-|-----------|--------|------------|------------------|
-| 3A - Data Models | ✅ Complete | 100% | XCheckResult, PositionRating, PlayOutcome.X_CHECK |
-| 3B - Config Tables | ✅ Complete | 100% | Defense tables (3), Error charts (9), Helper functions (2) |
-| 3C - Resolution Logic | ✅ Complete | 100% | _resolve_x_check() + 6 helpers (397 lines) |
-| 3D - Advancement Tables | ✅ Complete | 100% | 6 advancement tables (420 entries), 6 x_check functions, 59 tests |
-| 3E - WebSocket/UI | 🟡 Next | 0% | API client, Redis cache, 5 WebSocket events, defender lookup |
-| 3F - Testing | 🔲 Pending | 0% | Integration testing, performance validation |
-
-**Overall Phase 3 Progress**: 80% complete (4/5 sub-phases done, 1 in progress)
-
-**Timeline**:
-- Phase 3A-C: 2 days (2025-11-01 to 2025-11-02) ✅
-- Phase 3D: 1 day (2025-11-02) ✅
-- Phase 3E: Estimated 1-2 days (5-7 hours)
-- Phase 3F: Estimated 1 day (4-5 hours)
-- **Total remaining**: 2-3 days
-
----
-
-**Status**: ✅ Ready for Phase 3E - All core X-Check logic complete!
+**Last Updated**: 2025-11-03
+**Next Session Focus**: WebSocket handlers + Redis caching (Phase 3E-Final)
diff --git a/backend/CLAUDE.md b/backend/CLAUDE.md
index c3eefbf..801507b 100644
--- a/backend/CLAUDE.md
+++ b/backend/CLAUDE.md
@@ -2129,5 +2129,136 @@ app/core/play_resolver.py  (+397 lines, -2 lines)
 
 ---
 
-**Updated**: 2025-11-02
-**Total Unit Tests**: 325 passing (2 pre-existing failures in unrelated systems)
\ No newline at end of file
+## Phase 3E-Main: Position Ratings Integration (2025-11-03)
+
+Integrated position ratings system enabling X-Check defensive plays to use actual player ratings from PD API with intelligent fallbacks for SBA.
+
+**Status**: ✅ Complete - Live API verified with player 8807
+
+### Components Implemented
+
+1. **PD API Client** (`app/services/pd_api_client.py`)
+   - Endpoint: `GET /api/v2/cardpositions?player_id={id}&position={pos}`
+   - Async HTTP client using httpx
+   - Optional position filtering: `get_position_ratings(8807, ['SS', '2B'])`
+   - Returns `List[PositionRating]` for all positions
+   - Handles both list and dict response formats
+   - Comprehensive error handling
+
+2. **Position Rating Service** (`app/services/position_rating_service.py`)
+   - In-memory caching (16,601x performance improvement)
+   - `get_ratings_for_card(card_id, league_id)` - All positions
+   - `get_rating_for_position(card_id, position, league_id)` - Specific position
+   - Singleton pattern: `position_rating_service` instance
+   - TODO Phase 3E-Final: Upgrade to Redis
+
+3. **GameState Integration** (`app/models/game_models.py`)
+   - LineupPlayerState: Added `position_rating` field (Optional[PositionRating])
+   - GameState: Added `get_defender_for_position(position, state_manager)` method
+   - Uses StateManager's lineup cache to find active defender
+   - No database lookups during play resolution
+
+4. **League Configuration** (`app/config/league_configs.py`)
+   - SbaConfig: `supports_position_ratings()` → False
+   - PdConfig: `supports_position_ratings()` → True
+   - Enables league-specific behavior without hardcoded conditionals
+
+5. **PlayResolver Integration** (`app/core/play_resolver.py`)
+   - Added `state_manager` parameter to constructor
+   - `_resolve_x_check()`: Replaced placeholder ratings with actual lookup
+   - Uses league config check: `config.supports_position_ratings()`
+   - Falls back to defaults (range=3, error=15) if unavailable
+
+6. **Game Start Rating Loader** (`app/core/game_engine.py`)
+   - `_load_position_ratings_for_lineup()` method
+   - Loads all position ratings at game start for PD league
+   - Skips loading for SBA (league config check)
+   - Called in `start_game()` for both teams
+   - Logs: "Loaded X/9 position ratings for team Y"
+
+### Live API Testing
+
+**Verified with Player 8807** (7 positions):
+```
+Position   Range    Error    Innings
+CF         3        2        372
+2B         3        8        212
+SS         4        12       159
+RF         2        2        74
+LF         3        2        62
+1B         4        0        46
+3B         3        65       34
+```
+
+**Performance**:
+- API call: 0.214s
+- Cache hit: 0.000s
+- Speedup: 16,601x
+
+### X-Check Resolution Flow
+
+1. Check league config: `supports_position_ratings()`?
+2. Get defender: `state.get_defender_for_position(pos, state_manager)`
+3. If PD + `defender.position_rating` exists: Use actual range/error
+4. Else if defender found: Use defaults (range=3, error=15)
+5. Else: Log warning, use defaults
+
+### Testing
+
+**Live Integration**:
+- ✅ Real API: Player 8807 → 7 positions retrieved
+- ✅ Caching: 16,601x performance improvement
+- ✅ League configs: SBA skips API, PD fetches ratings
+- ✅ GameState: Defender lookup working
+- ✅ Existing tests: 27/28 config tests passing
+
+**Test Files Created**:
+- `test_pd_api_live.py` - Live API integration test
+- `test_pd_api_mock.py` - Mock test for CI/CD
+- `tests/integration/test_position_ratings_api.py` - Pytest suite
+
+### Files Created/Modified
+
+**Created**:
+```
+app/services/__init__.py              - Package exports
+app/services/pd_api_client.py         - PD API client (97 lines)
+app/services/position_rating_service.py - Caching service (120 lines)
+```
+
+**Modified**:
+```
+app/models/game_models.py             - Added position_rating field, get_defender_for_position()
+app/config/league_configs.py          - Added supports_position_ratings()
+app/core/play_resolver.py             - Integrated actual ratings lookup
+app/core/game_engine.py                - Load ratings at game start
+```
+
+### Key Features
+
+**League-Aware Behavior**:
+- PD: Fetches ratings from API with caching
+- SBA: Skips API calls, uses defaults
+
+**Self-Contained GameState**:
+- All X-Check data in memory (no lookups during resolution)
+- Direct access: `defender.position_rating.range`
+
+**Graceful Degradation**:
+- API unavailable → Use defaults
+- Player has no rating → Use defaults
+- Defaults: range=3 (average), error=15 (average)
+
+### Next Phase
+
+**Phase 3E-Final**: WebSocket Events & Full Integration
+- WebSocket event handlers for X-Check UI
+- Upgrade to Redis caching
+- Full defensive lineup in GameState (all 9 positions)
+- Manual vs Auto mode workflows
+
+---
+
+**Updated**: 2025-11-03
+**Total Unit Tests**: 325 passing (2 pre-existing failures in unrelated systems)
+**Live API**: Verified with PD player 8807
\ No newline at end of file