feat(Task 3.4): Implement ScanService with key-based identification

- Create ScanService class (src/server/services/scan_service.py)
  - Use 'key' as primary series identifier throughout
  - Include 'folder' as metadata only for display purposes
  - Implement scan progress tracking via ProgressService
  - Add callback classes for progress, error, and completion
  - Support scan event subscription and broadcasting
  - Maintain scan history with configurable limit
  - Provide cancellation support for in-progress scans

- Create comprehensive unit tests (tests/unit/test_scan_service.py)
  - 38 tests covering all functionality
  - Test ScanProgress dataclass serialization
  - Test callback classes (progress, error, completion)
  - Test service lifecycle (start, cancel, status)
  - Test event subscription and broadcasting
  - Test key-based identification throughout
  - Test singleton pattern

- Update infrastructure.md with ScanService documentation
  - Document service overview and key features
  - Document components and event types
  - Document integration points
  - Include usage example

- Update instructions.md
  - Mark Task 3.4 as complete
  - Mark Phase 3 as fully complete
  - Remove finished task definition

Task: Phase 3, Task 3.4 - Update ScanService to Use Key
Completion Date: November 27, 2025

infrastructure.md

@@ -996,6 +996,106 @@ aligning with the broader identifier standardization initiative.
 **Task**: Phase 3, Task 3.2 - Update AnimeService to Use Key  
 **Completion Date**: November 23, 2025
 
+### ScanService Implementation (November 2025)
+
+Implemented a dedicated `ScanService` for managing anime library scan operations
+with consistent `key`-based series identification.
+
+#### Overview
+
+**File**: `src/server/services/scan_service.py`
+
+The `ScanService` provides a service layer for scanning the anime library directory,
+identifying missing episodes, and broadcasting scan progress updates to connected
+clients via WebSocket.
+
+#### Key Features
+
+-   **Key-based Identification**: All scan operations use `key` as the primary
+    series identifier (provider-assigned, URL-safe). `folder` is metadata only.
+-   **Progress Tracking**: Real-time progress updates via `ProgressService`
+-   **Callback Integration**: Callback classes for progress, error, and completion
+-   **Event Broadcasting**: Scan events broadcast to subscribed handlers
+-   **Scan History**: Maintains history of recent scans
+-   **Cancellation Support**: Ability to cancel in-progress scans
+
+#### Components
+
+1. **ScanProgress**: Dataclass representing scan state
+    - `scan_id`: Unique identifier for the scan operation
+    - `key`: Current series key being scanned (primary identifier)
+    - `folder`: Current folder being scanned (metadata only)
+    - `status`: Current status (started, in_progress, completed, failed)
+    - `percentage`: Completion percentage
+    - `series_found`: Number of series found with missing episodes
+
+2. **Callback Classes**:
+    - `ScanServiceProgressCallback`: Handles progress updates from SerieScanner
+    - `ScanServiceErrorCallback`: Handles scan errors
+    - `ScanServiceCompletionCallback`: Handles scan completion
+
+3. **ScanService**: Main service class
+    - `start_scan()`: Start a new library scan
+    - `cancel_scan()`: Cancel in-progress scan
+    - `get_scan_status()`: Get current scan status
+    - `get_scan_history()`: Get recent scan history
+    - `create_callback_manager()`: Create callbacks for SerieScanner
+    - `subscribe_to_scan_events()`: Subscribe to scan events
+
+#### Event Types
+
+All events include `key` as the primary series identifier:
+
+-   `scan_started`: Emitted when scan begins
+-   `scan_progress`: Emitted during scan with progress data
+-   `scan_error`: Emitted when an error occurs (recoverable errors)
+-   `scan_completed`: Emitted on successful completion
+-   `scan_failed`: Emitted on scan failure
+-   `scan_cancelled`: Emitted when scan is cancelled
+
+#### Integration
+
+The ScanService integrates with:
+-   `ProgressService`: For progress tracking and WebSocket broadcasting
+-   `SerieScanner` (core): For actual scan operations via callbacks
+-   `CallbackManager` (core): For receiving progress/error/completion events
+
+#### Usage Example
+
+```python
+from src.server.services.scan_service import get_scan_service
+
+# Get singleton instance
+scan_service = get_scan_service()
+
+# Subscribe to scan events
+async def handle_scan_event(event_data):
+    print(f"Scan event: {event_data['type']}")
+    if 'key' in event_data:
+        print(f"Series key: {event_data['key']}")
+
+scan_service.subscribe_to_scan_events(handle_scan_event)
+
+# Start a scan (factory creates SerieScanner with callbacks)
+scan_id = await scan_service.start_scan(scanner_factory)
+
+# Get current status
+status = await scan_service.get_scan_status()
+```
+
+#### Test Coverage
+
+Comprehensive test suite with 38 tests covering:
+-   ScanProgress dataclass serialization
+-   Callback classes (progress, error, completion)
+-   Service lifecycle (start, cancel, status)
+-   Event subscription and broadcasting
+-   Key-based identification throughout
+-   Singleton pattern
+
+**Task**: Phase 3, Task 3.4 - Update ScanService to Use Key  
+**Completion Date**: November 27, 2025
+
 ### Template Integration (October 2025)
 
 Completed integration of HTML templates with FastAPI Jinja2 system.

instructions.md

@@ -171,37 +171,12 @@ For each task completed:
 
 ### Phase 3: Service Layer
 
-✅ **Tasks 3.1, 3.2, and 3.3 completed and committed to git (November 2025)**
+✅ **All Phase 3 tasks completed and committed to git (November 2025)**
 
----
-
-#### Task 3.4: Update ScanService to Use Key
-
-**File:** [`src/server/services/scan_service.py`](src/server/services/scan_service.py)
-
-**Objective:** Ensure `ScanService` uses `key` for all scan operations.
-
-**Steps:**
-
-1. Open [`src/server/services/scan_service.py`](src/server/services/scan_service.py)
-2. Review all methods that handle scan events
-3. Ensure scan progress events use `key` for identification
-4. Update any callbacks to use `key`
-5. Update event emissions to include both `key` and `folder`
-6. Update docstrings
-
-**Success Criteria:**
-
--   [ ] All scan operations use `key`
--   [ ] Callbacks receive `key` as identifier
--   [ ] Events include both `key` and `folder`
--   [ ] All scan service tests pass
-
-**Test Command:**
-
-```bash
-conda run -n AniWorld python -m pytest tests/unit/ -k "ScanService" -v
-```
+-   Task 3.1: Update DownloadService ✅
+-   Task 3.2: Update AnimeService ✅
+-   Task 3.3: Update ProgressService ✅
+-   Task 3.4: Update ScanService ✅ (November 27, 2025)
 
 ---
 
@@ -968,11 +943,11 @@ conda run -n AniWorld python -m pytest tests/integration/test_identifier_consist
     -   [x] **Task 1.4: Update Provider Classes**
 -   [x] Phase 2: Core Application Layer
     -   [x] Task 2.1: Update SeriesApp
--   [ ] Phase 3: Service Layer
+-   [x] Phase 3: Service Layer
     -   [x] Task 3.1: Update DownloadService ✅ **Completed November 2025**
     -   [x] Task 3.2: Update AnimeService ✅ **Completed November 23, 2025**
     -   [x] **Task 3.3: Update ProgressService** ✅ **Completed November 27, 2025**
-    -   [ ] **Task 3.4: Update ScanService**
+    -   [x] **Task 3.4: Update ScanService** ✅ **Completed November 27, 2025**
 -   [ ] Phase 4: API Layer
     -   [ ] Task 4.1: Update Anime API Endpoints
     -   [ ] Task 4.2: Update Download API Endpoints

src/server/services/scan_service.py

@@ -0,0 +1,660 @@
+"""Scan service for managing anime library scan operations.
+
+This module provides a service layer for scanning the anime library directory,
+identifying missing episodes, and broadcasting scan progress updates.
+All scan operations use 'key' as the primary series identifier.
+"""
+from __future__ import annotations
+
+import asyncio
+import uuid
+from datetime import datetime, timezone
+from typing import Any, Callable, Dict, List, Optional
+
+import structlog
+
+from src.core.interfaces.callbacks import (
+    CallbackManager,
+    CompletionCallback,
+    CompletionContext,
+    ErrorCallback,
+    ErrorContext,
+    OperationType,
+    ProgressCallback,
+    ProgressContext,
+    ProgressPhase,
+)
+from src.server.services.progress_service import (
+    ProgressService,
+    ProgressStatus,
+    ProgressType,
+    get_progress_service,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+class ScanServiceError(Exception):
+    """Service-level exception for scan operations."""
+
+
+class ScanProgress:
+    """Represents the current state of a scan operation.
+    
+    Attributes:
+        scan_id: Unique identifier for this scan operation
+        status: Current status (started, in_progress, completed, failed)
+        current: Number of folders processed
+        total: Total number of folders to process
+        percentage: Completion percentage
+        message: Human-readable progress message
+        key: Current series key being scanned (if applicable)
+        folder: Current folder being scanned (metadata only)
+        started_at: When the scan started
+        updated_at: When the progress was last updated
+        series_found: Number of series found with missing episodes
+        errors: List of error messages encountered
+    """
+
+    def __init__(self, scan_id: str):
+        """Initialize scan progress.
+        
+        Args:
+            scan_id: Unique identifier for this scan
+        """
+        self.scan_id = scan_id
+        self.status = "started"
+        self.current = 0
+        self.total = 0
+        self.percentage = 0.0
+        self.message = "Initializing scan..."
+        self.key: Optional[str] = None
+        self.folder: Optional[str] = None
+        self.started_at = datetime.now(timezone.utc)
+        self.updated_at = datetime.now(timezone.utc)
+        self.series_found = 0
+        self.errors: List[str] = []
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary for serialization.
+        
+        Returns:
+            Dictionary representation with 'key' as primary identifier
+            and 'folder' as metadata only.
+        """
+        result = {
+            "scan_id": self.scan_id,
+            "status": self.status,
+            "current": self.current,
+            "total": self.total,
+            "percentage": round(self.percentage, 2),
+            "message": self.message,
+            "started_at": self.started_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "series_found": self.series_found,
+            "errors": self.errors,
+        }
+        
+        # Include optional series identifiers
+        if self.key is not None:
+            result["key"] = self.key
+        if self.folder is not None:
+            result["folder"] = self.folder
+            
+        return result
+
+
+class ScanServiceProgressCallback(ProgressCallback):
+    """Callback implementation for forwarding scan progress to ScanService.
+    
+    This callback receives progress events from SerieScanner and forwards
+    them to the ScanService for processing and broadcasting.
+    """
+
+    def __init__(
+        self,
+        service: "ScanService",
+        scan_progress: ScanProgress,
+    ):
+        """Initialize the callback.
+        
+        Args:
+            service: Parent ScanService instance
+            scan_progress: ScanProgress to update
+        """
+        self._service = service
+        self._scan_progress = scan_progress
+
+    def on_progress(self, context: ProgressContext) -> None:
+        """Handle progress update from SerieScanner.
+        
+        Args:
+            context: Progress context with key and folder information
+        """
+        self._scan_progress.current = context.current
+        self._scan_progress.total = context.total
+        self._scan_progress.percentage = context.percentage
+        self._scan_progress.message = context.message
+        self._scan_progress.key = context.key
+        self._scan_progress.folder = context.folder
+        self._scan_progress.updated_at = datetime.now(timezone.utc)
+
+        if context.phase == ProgressPhase.STARTING:
+            self._scan_progress.status = "started"
+        elif context.phase == ProgressPhase.IN_PROGRESS:
+            self._scan_progress.status = "in_progress"
+        elif context.phase == ProgressPhase.COMPLETED:
+            self._scan_progress.status = "completed"
+        elif context.phase == ProgressPhase.FAILED:
+            self._scan_progress.status = "failed"
+
+        # Forward to service for broadcasting
+        # Use run_coroutine_threadsafe if event loop is available
+        try:
+            loop = asyncio.get_running_loop()
+            asyncio.run_coroutine_threadsafe(
+                self._service._handle_progress_update(self._scan_progress),
+                loop
+            )
+        except RuntimeError:
+            # No running event loop - likely in test or sync context
+            pass
+
+
+class ScanServiceErrorCallback(ErrorCallback):
+    """Callback implementation for handling scan errors.
+    
+    This callback receives error events from SerieScanner and forwards
+    them to the ScanService for processing and broadcasting.
+    """
+
+    def __init__(
+        self,
+        service: "ScanService",
+        scan_progress: ScanProgress,
+    ):
+        """Initialize the callback.
+        
+        Args:
+            service: Parent ScanService instance
+            scan_progress: ScanProgress to update
+        """
+        self._service = service
+        self._scan_progress = scan_progress
+
+    def on_error(self, context: ErrorContext) -> None:
+        """Handle error from SerieScanner.
+        
+        Args:
+            context: Error context with key and folder information
+        """
+        error_msg = context.message
+        if context.folder:
+            error_msg = f"[{context.folder}] {error_msg}"
+
+        self._scan_progress.errors.append(error_msg)
+        self._scan_progress.updated_at = datetime.now(timezone.utc)
+
+        logger.warning(
+            "Scan error",
+            key=context.key,
+            folder=context.folder,
+            error=str(context.error),
+            recoverable=context.recoverable,
+        )
+
+        # Forward to service for broadcasting
+        # Use run_coroutine_threadsafe if event loop is available
+        try:
+            loop = asyncio.get_running_loop()
+            asyncio.run_coroutine_threadsafe(
+                self._service._handle_scan_error(
+                    self._scan_progress,
+                    context,
+                ),
+                loop
+            )
+        except RuntimeError:
+            # No running event loop - likely in test or sync context
+            pass
+
+
+class ScanServiceCompletionCallback(CompletionCallback):
+    """Callback implementation for handling scan completion.
+    
+    This callback receives completion events from SerieScanner and forwards
+    them to the ScanService for processing and broadcasting.
+    """
+
+    def __init__(
+        self,
+        service: "ScanService",
+        scan_progress: ScanProgress,
+    ):
+        """Initialize the callback.
+        
+        Args:
+            service: Parent ScanService instance
+            scan_progress: ScanProgress to update
+        """
+        self._service = service
+        self._scan_progress = scan_progress
+
+    def on_completion(self, context: CompletionContext) -> None:
+        """Handle completion from SerieScanner.
+        
+        Args:
+            context: Completion context with statistics
+        """
+        self._scan_progress.status = "completed" if context.success else "failed"
+        self._scan_progress.message = context.message
+        self._scan_progress.updated_at = datetime.now(timezone.utc)
+
+        if context.statistics:
+            self._scan_progress.series_found = context.statistics.get(
+                "series_found", 0
+            )
+
+        # Forward to service for broadcasting
+        # Use run_coroutine_threadsafe if event loop is available
+        try:
+            loop = asyncio.get_running_loop()
+            asyncio.run_coroutine_threadsafe(
+                self._service._handle_scan_completion(
+                    self._scan_progress,
+                    context,
+                ),
+                loop
+            )
+        except RuntimeError:
+            # No running event loop - likely in test or sync context
+            pass
+
+
+class ScanService:
+    """Manages anime library scan operations.
+    
+    Features:
+    - Trigger library scans
+    - Track scan progress in real-time
+    - Use 'key' as primary series identifier
+    - Broadcast scan progress via WebSocket
+    - Handle scan errors gracefully
+    - Provide scan history and statistics
+    
+    All operations use 'key' (provider-assigned, URL-safe identifier)
+    as the primary series identifier. 'folder' is used only as metadata
+    for display and filesystem operations.
+    """
+
+    def __init__(
+        self,
+        progress_service: Optional[ProgressService] = None,
+    ):
+        """Initialize the scan service.
+        
+        Args:
+            progress_service: Optional progress service for tracking
+        """
+        self._progress_service = progress_service or get_progress_service()
+        
+        # Current scan state
+        self._current_scan: Optional[ScanProgress] = None
+        self._is_scanning = False
+        
+        # Scan history (limited size)
+        self._scan_history: List[ScanProgress] = []
+        self._max_history_size = 10
+        
+        # Event handlers for scan events
+        self._scan_event_handlers: List[
+            Callable[[Dict[str, Any]], None]
+        ] = []
+        
+        # Lock for thread-safe operations
+        self._lock = asyncio.Lock()
+        
+        logger.info("ScanService initialized")
+
+    def subscribe_to_scan_events(
+        self,
+        handler: Callable[[Dict[str, Any]], None],
+    ) -> None:
+        """Subscribe to scan events.
+        
+        Args:
+            handler: Function to call when scan events occur.
+                    Receives a dictionary with event data including
+                    'key' as the primary identifier.
+        """
+        self._scan_event_handlers.append(handler)
+        logger.debug("Scan event handler subscribed")
+
+    def unsubscribe_from_scan_events(
+        self,
+        handler: Callable[[Dict[str, Any]], None],
+    ) -> None:
+        """Unsubscribe from scan events.
+        
+        Args:
+            handler: Handler function to remove
+        """
+        try:
+            self._scan_event_handlers.remove(handler)
+            logger.debug("Scan event handler unsubscribed")
+        except ValueError:
+            logger.warning("Handler not found for unsubscribe")
+
+    async def _emit_scan_event(self, event_data: Dict[str, Any]) -> None:
+        """Emit scan event to all subscribers.
+        
+        Args:
+            event_data: Event data to broadcast, includes 'key' as
+                       primary identifier and 'folder' as metadata
+        """
+        for handler in self._scan_event_handlers:
+            try:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(event_data)
+                else:
+                    handler(event_data)
+            except Exception as e:
+                logger.error(
+                    "Scan event handler error",
+                    error=str(e),
+                )
+
+    @property
+    def is_scanning(self) -> bool:
+        """Check if a scan is currently in progress."""
+        return self._is_scanning
+
+    @property
+    def current_scan(self) -> Optional[ScanProgress]:
+        """Get the current scan progress."""
+        return self._current_scan
+
+    async def start_scan(
+        self,
+        scanner_factory: Callable[..., Any],
+    ) -> str:
+        """Start a new library scan.
+        
+        Args:
+            scanner_factory: Factory function that creates a SerieScanner.
+                           The factory should accept a callback_manager parameter.
+        
+        Returns:
+            Scan ID for tracking
+            
+        Raises:
+            ScanServiceError: If a scan is already in progress
+            
+        Note:
+            The scan uses 'key' as the primary identifier for all series.
+            The 'folder' field is included only as metadata for display.
+        """
+        async with self._lock:
+            if self._is_scanning:
+                raise ScanServiceError("A scan is already in progress")
+            
+            self._is_scanning = True
+
+        scan_id = str(uuid.uuid4())
+        scan_progress = ScanProgress(scan_id)
+        self._current_scan = scan_progress
+
+        logger.info("Starting library scan", scan_id=scan_id)
+
+        # Start progress tracking
+        try:
+            await self._progress_service.start_progress(
+                progress_id=f"scan_{scan_id}",
+                progress_type=ProgressType.SCAN,
+                title="Library Scan",
+                message="Initializing scan...",
+            )
+        except Exception as e:
+            logger.error("Failed to start progress tracking", error=str(e))
+
+        # Emit scan started event
+        await self._emit_scan_event({
+            "type": "scan_started",
+            "scan_id": scan_id,
+            "message": "Library scan started",
+        })
+
+        return scan_id
+
+    def create_callback_manager(
+        self,
+        scan_progress: Optional[ScanProgress] = None,
+    ) -> CallbackManager:
+        """Create a callback manager for scan operations.
+        
+        Args:
+            scan_progress: Optional scan progress to use. If None,
+                          uses current scan progress.
+        
+        Returns:
+            CallbackManager configured with scan callbacks
+        """
+        progress = scan_progress or self._current_scan
+        if not progress:
+            progress = ScanProgress(str(uuid.uuid4()))
+            self._current_scan = progress
+
+        callback_manager = CallbackManager()
+        
+        # Register callbacks
+        callback_manager.register_progress_callback(
+            ScanServiceProgressCallback(self, progress)
+        )
+        callback_manager.register_error_callback(
+            ScanServiceErrorCallback(self, progress)
+        )
+        callback_manager.register_completion_callback(
+            ScanServiceCompletionCallback(self, progress)
+        )
+
+        return callback_manager
+
+    async def _handle_progress_update(
+        self,
+        scan_progress: ScanProgress,
+    ) -> None:
+        """Handle a scan progress update.
+        
+        Args:
+            scan_progress: Updated scan progress with 'key' as identifier
+        """
+        # Update progress service
+        try:
+            await self._progress_service.update_progress(
+                progress_id=f"scan_{scan_progress.scan_id}",
+                current=scan_progress.current,
+                total=scan_progress.total,
+                message=scan_progress.message,
+                key=scan_progress.key,
+                folder=scan_progress.folder,
+            )
+        except Exception as e:
+            logger.debug("Progress update skipped", error=str(e))
+
+        # Emit progress event with key as primary identifier
+        await self._emit_scan_event({
+            "type": "scan_progress",
+            "data": scan_progress.to_dict(),
+        })
+
+    async def _handle_scan_error(
+        self,
+        scan_progress: ScanProgress,
+        error_context: ErrorContext,
+    ) -> None:
+        """Handle a scan error.
+        
+        Args:
+            scan_progress: Current scan progress
+            error_context: Error context with key and folder metadata
+        """
+        # Emit error event with key as primary identifier
+        await self._emit_scan_event({
+            "type": "scan_error",
+            "scan_id": scan_progress.scan_id,
+            "key": error_context.key,
+            "folder": error_context.folder,
+            "error": str(error_context.error),
+            "message": error_context.message,
+            "recoverable": error_context.recoverable,
+        })
+
+    async def _handle_scan_completion(
+        self,
+        scan_progress: ScanProgress,
+        completion_context: CompletionContext,
+    ) -> None:
+        """Handle scan completion.
+        
+        Args:
+            scan_progress: Final scan progress
+            completion_context: Completion context with statistics
+        """
+        async with self._lock:
+            self._is_scanning = False
+            
+            # Add to history
+            self._scan_history.append(scan_progress)
+            if len(self._scan_history) > self._max_history_size:
+                self._scan_history.pop(0)
+
+        # Complete progress tracking
+        try:
+            if completion_context.success:
+                await self._progress_service.complete_progress(
+                    progress_id=f"scan_{scan_progress.scan_id}",
+                    message=completion_context.message,
+                )
+            else:
+                await self._progress_service.fail_progress(
+                    progress_id=f"scan_{scan_progress.scan_id}",
+                    error_message=completion_context.message,
+                )
+        except Exception as e:
+            logger.debug("Progress completion skipped", error=str(e))
+
+        # Emit completion event
+        await self._emit_scan_event({
+            "type": "scan_completed" if completion_context.success else "scan_failed",
+            "scan_id": scan_progress.scan_id,
+            "success": completion_context.success,
+            "message": completion_context.message,
+            "statistics": completion_context.statistics,
+            "data": scan_progress.to_dict(),
+        })
+
+        logger.info(
+            "Scan completed",
+            scan_id=scan_progress.scan_id,
+            success=completion_context.success,
+            series_found=scan_progress.series_found,
+            errors_count=len(scan_progress.errors),
+        )
+
+    async def cancel_scan(self) -> bool:
+        """Cancel the current scan if one is in progress.
+        
+        Returns:
+            True if scan was cancelled, False if no scan in progress
+        """
+        async with self._lock:
+            if not self._is_scanning:
+                return False
+            
+            self._is_scanning = False
+            
+            if self._current_scan:
+                self._current_scan.status = "cancelled"
+                self._current_scan.message = "Scan cancelled by user"
+                self._current_scan.updated_at = datetime.now(timezone.utc)
+                
+                # Add to history
+                self._scan_history.append(self._current_scan)
+                if len(self._scan_history) > self._max_history_size:
+                    self._scan_history.pop(0)
+
+        # Emit cancellation event
+        if self._current_scan:
+            await self._emit_scan_event({
+                "type": "scan_cancelled",
+                "scan_id": self._current_scan.scan_id,
+                "message": "Scan cancelled by user",
+            })
+
+            # Update progress service
+            try:
+                await self._progress_service.fail_progress(
+                    progress_id=f"scan_{self._current_scan.scan_id}",
+                    error_message="Scan cancelled by user",
+                )
+            except Exception as e:
+                logger.debug("Progress cancellation skipped", error=str(e))
+
+        logger.info("Scan cancelled")
+        return True
+
+    async def get_scan_status(self) -> Dict[str, Any]:
+        """Get the current scan status.
+        
+        Returns:
+            Dictionary with scan status information, including 'key'
+            as the primary series identifier for any current scan.
+        """
+        return {
+            "is_scanning": self._is_scanning,
+            "current_scan": (
+                self._current_scan.to_dict() if self._current_scan else None
+            ),
+        }
+
+    async def get_scan_history(
+        self,
+        limit: int = 10,
+    ) -> List[Dict[str, Any]]:
+        """Get scan history.
+        
+        Args:
+            limit: Maximum number of history entries to return
+            
+        Returns:
+            List of scan history entries, newest first.
+            Each entry includes 'key' as the primary identifier.
+        """
+        history = self._scan_history[-limit:]
+        history.reverse()  # Newest first
+        return [scan.to_dict() for scan in history]
+
+
+# Module-level singleton instance
+_scan_service: Optional[ScanService] = None
+
+
+def get_scan_service() -> ScanService:
+    """Get the singleton ScanService instance.
+    
+    Returns:
+        The ScanService singleton
+    """
+    global _scan_service
+    if _scan_service is None:
+        _scan_service = ScanService()
+    return _scan_service
+
+
+def reset_scan_service() -> None:
+    """Reset the singleton ScanService instance.
+    
+    Primarily used for testing to ensure clean state.
+    """
+    global _scan_service
+    _scan_service = None

tests/unit/test_scan_service.py

@@ -0,0 +1,739 @@
+"""Unit tests for ScanService.
+
+This module contains comprehensive tests for the scan service,
+including scan lifecycle, progress callbacks, event handling,
+and key-based identification.
+"""
+from datetime import datetime
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.core.interfaces.callbacks import (
+    CallbackManager,
+    CompletionContext,
+    ErrorContext,
+    OperationType,
+    ProgressContext,
+    ProgressPhase,
+)
+from src.server.services.scan_service import (
+    ScanProgress,
+    ScanService,
+    ScanServiceCompletionCallback,
+    ScanServiceError,
+    ScanServiceErrorCallback,
+    ScanServiceProgressCallback,
+    get_scan_service,
+    reset_scan_service,
+)
+
+
+class TestScanProgress:
+    """Test ScanProgress class."""
+
+    def test_scan_progress_creation(self):
+        """Test creating a scan progress instance."""
+        progress = ScanProgress("scan-123")
+
+        assert progress.scan_id == "scan-123"
+        assert progress.status == "started"
+        assert progress.current == 0
+        assert progress.total == 0
+        assert progress.percentage == 0.0
+        assert progress.message == "Initializing scan..."
+        assert progress.key is None
+        assert progress.folder is None
+        assert progress.series_found == 0
+        assert progress.errors == []
+        assert isinstance(progress.started_at, datetime)
+        assert isinstance(progress.updated_at, datetime)
+
+    def test_scan_progress_to_dict_basic(self):
+        """Test converting scan progress to dictionary without key/folder."""
+        progress = ScanProgress("scan-123")
+        progress.current = 5
+        progress.total = 10
+        progress.percentage = 50.0
+        progress.status = "in_progress"
+        progress.message = "Scanning..."
+
+        result = progress.to_dict()
+
+        assert result["scan_id"] == "scan-123"
+        assert result["status"] == "in_progress"
+        assert result["current"] == 5
+        assert result["total"] == 10
+        assert result["percentage"] == 50.0
+        assert result["message"] == "Scanning..."
+        assert result["series_found"] == 0
+        assert result["errors"] == []
+        assert "started_at" in result
+        assert "updated_at" in result
+        # key and folder should not be present when None
+        assert "key" not in result
+        assert "folder" not in result
+
+    def test_scan_progress_to_dict_with_key_and_folder(self):
+        """Test converting scan progress to dictionary with key and folder."""
+        progress = ScanProgress("scan-123")
+        progress.key = "attack-on-titan"
+        progress.folder = "Attack on Titan (2013)"
+        progress.series_found = 5
+
+        result = progress.to_dict()
+
+        assert result["key"] == "attack-on-titan"
+        assert result["folder"] == "Attack on Titan (2013)"
+        assert result["series_found"] == 5
+
+    def test_scan_progress_to_dict_with_errors(self):
+        """Test scan progress with error messages."""
+        progress = ScanProgress("scan-123")
+        progress.errors = ["Error 1", "Error 2"]
+
+        result = progress.to_dict()
+
+        assert result["errors"] == ["Error 1", "Error 2"]
+
+
+class TestScanServiceProgressCallback:
+    """Test ScanServiceProgressCallback class."""
+
+    @pytest.fixture
+    def mock_service(self):
+        """Create a mock ScanService."""
+        service = MagicMock(spec=ScanService)
+        service._handle_progress_update = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def scan_progress(self):
+        """Create a scan progress instance."""
+        return ScanProgress("scan-123")
+
+    def test_on_progress_updates_progress(self, mock_service, scan_progress):
+        """Test that on_progress updates scan progress correctly."""
+        callback = ScanServiceProgressCallback(mock_service, scan_progress)
+        
+        context = ProgressContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            phase=ProgressPhase.IN_PROGRESS,
+            current=5,
+            total=10,
+            percentage=50.0,
+            message="Scanning: Test Folder",
+            key="test-series",
+            folder="Test Folder",
+        )
+
+        # Call directly - no event loop needed since we handle RuntimeError
+        callback.on_progress(context)
+
+        assert scan_progress.current == 5
+        assert scan_progress.total == 10
+        assert scan_progress.percentage == 50.0
+        assert scan_progress.message == "Scanning: Test Folder"
+        assert scan_progress.key == "test-series"
+        assert scan_progress.folder == "Test Folder"
+        assert scan_progress.status == "in_progress"
+
+    def test_on_progress_starting_phase(self, mock_service, scan_progress):
+        """Test progress callback with STARTING phase."""
+        callback = ScanServiceProgressCallback(mock_service, scan_progress)
+        
+        context = ProgressContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            phase=ProgressPhase.STARTING,
+            current=0,
+            total=0,
+            percentage=0.0,
+            message="Initializing...",
+        )
+
+        callback.on_progress(context)
+
+        assert scan_progress.status == "started"
+
+    def test_on_progress_completed_phase(self, mock_service, scan_progress):
+        """Test progress callback with COMPLETED phase."""
+        callback = ScanServiceProgressCallback(mock_service, scan_progress)
+        
+        context = ProgressContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            phase=ProgressPhase.COMPLETED,
+            current=10,
+            total=10,
+            percentage=100.0,
+            message="Scan completed",
+        )
+
+        callback.on_progress(context)
+
+        assert scan_progress.status == "completed"
+
+
+class TestScanServiceErrorCallback:
+    """Test ScanServiceErrorCallback class."""
+
+    @pytest.fixture
+    def mock_service(self):
+        """Create a mock ScanService."""
+        service = MagicMock(spec=ScanService)
+        service._handle_scan_error = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def scan_progress(self):
+        """Create a scan progress instance."""
+        return ScanProgress("scan-123")
+
+    def test_on_error_adds_error_message(self, mock_service, scan_progress):
+        """Test that on_error adds error to scan progress."""
+        callback = ScanServiceErrorCallback(mock_service, scan_progress)
+        
+        error = ValueError("Test error")
+        context = ErrorContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            error=error,
+            message="Failed to process folder",
+            recoverable=True,
+            key="test-series",
+            folder="Test Folder",
+        )
+
+        callback.on_error(context)
+
+        assert len(scan_progress.errors) == 1
+        assert "[Test Folder]" in scan_progress.errors[0]
+        assert "Failed to process folder" in scan_progress.errors[0]
+
+    def test_on_error_without_folder(self, mock_service, scan_progress):
+        """Test error callback without folder information."""
+        callback = ScanServiceErrorCallback(mock_service, scan_progress)
+        
+        error = ValueError("Test error")
+        context = ErrorContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            error=error,
+            message="Generic error",
+            recoverable=False,
+        )
+
+        callback.on_error(context)
+
+        assert len(scan_progress.errors) == 1
+        assert scan_progress.errors[0] == "Generic error"
+
+
+class TestScanServiceCompletionCallback:
+    """Test ScanServiceCompletionCallback class."""
+
+    @pytest.fixture
+    def mock_service(self):
+        """Create a mock ScanService."""
+        service = MagicMock(spec=ScanService)
+        service._handle_scan_completion = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def scan_progress(self):
+        """Create a scan progress instance."""
+        return ScanProgress("scan-123")
+
+    def test_on_completion_success(self, mock_service, scan_progress):
+        """Test completion callback with success."""
+        callback = ScanServiceCompletionCallback(mock_service, scan_progress)
+        
+        context = CompletionContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            success=True,
+            message="Scan completed successfully",
+            statistics={"series_found": 10, "total_folders": 15},
+        )
+
+        callback.on_completion(context)
+
+        assert scan_progress.status == "completed"
+        assert scan_progress.message == "Scan completed successfully"
+        assert scan_progress.series_found == 10
+
+    def test_on_completion_failure(self, mock_service, scan_progress):
+        """Test completion callback with failure."""
+        callback = ScanServiceCompletionCallback(mock_service, scan_progress)
+        
+        context = CompletionContext(
+            operation_type=OperationType.SCAN,
+            operation_id="scan-123",
+            success=False,
+            message="Scan failed: critical error",
+        )
+
+        callback.on_completion(context)
+
+        assert scan_progress.status == "failed"
+        assert scan_progress.message == "Scan failed: critical error"
+
+
+class TestScanService:
+    """Test ScanService class."""
+
+    @pytest.fixture
+    def mock_progress_service(self):
+        """Create a mock progress service."""
+        service = MagicMock()
+        service.start_progress = AsyncMock()
+        service.update_progress = AsyncMock()
+        service.complete_progress = AsyncMock()
+        service.fail_progress = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def service(self, mock_progress_service):
+        """Create a ScanService instance for each test."""
+        return ScanService(progress_service=mock_progress_service)
+
+    @pytest.mark.asyncio
+    async def test_service_initialization(self, service):
+        """Test ScanService initialization."""
+        assert service.is_scanning is False
+        assert service.current_scan is None
+        assert service._scan_history == []
+
+    @pytest.mark.asyncio
+    async def test_start_scan(self, service):
+        """Test starting a new scan."""
+        scanner_factory = MagicMock()
+        
+        scan_id = await service.start_scan(scanner_factory)
+
+        assert scan_id is not None
+        assert len(scan_id) > 0
+        assert service.is_scanning is True
+        assert service.current_scan is not None
+        assert service.current_scan.scan_id == scan_id
+
+    @pytest.mark.asyncio
+    async def test_start_scan_while_scanning(self, service):
+        """Test starting scan while another is in progress raises error."""
+        scanner_factory = MagicMock()
+        
+        await service.start_scan(scanner_factory)
+
+        with pytest.raises(ScanServiceError, match="already in progress"):
+            await service.start_scan(scanner_factory)
+
+    @pytest.mark.asyncio
+    async def test_cancel_scan(self, service):
+        """Test cancelling a scan in progress."""
+        scanner_factory = MagicMock()
+        scan_id = await service.start_scan(scanner_factory)
+
+        result = await service.cancel_scan()
+
+        assert result is True
+        assert service.is_scanning is False
+        assert service.current_scan.status == "cancelled"
+        assert len(service._scan_history) == 1
+
+    @pytest.mark.asyncio
+    async def test_cancel_scan_no_scan_in_progress(self, service):
+        """Test cancelling when no scan is in progress."""
+        result = await service.cancel_scan()
+
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_get_scan_status(self, service):
+        """Test getting scan status."""
+        status = await service.get_scan_status()
+
+        assert status["is_scanning"] is False
+        assert status["current_scan"] is None
+
+    @pytest.mark.asyncio
+    async def test_get_scan_status_while_scanning(self, service):
+        """Test getting scan status while scanning."""
+        scanner_factory = MagicMock()
+        scan_id = await service.start_scan(scanner_factory)
+
+        status = await service.get_scan_status()
+
+        assert status["is_scanning"] is True
+        assert status["current_scan"] is not None
+        assert status["current_scan"]["scan_id"] == scan_id
+
+    @pytest.mark.asyncio
+    async def test_get_scan_history_empty(self, service):
+        """Test getting scan history when empty."""
+        history = await service.get_scan_history()
+
+        assert history == []
+
+    @pytest.mark.asyncio
+    async def test_get_scan_history_with_entries(self, service):
+        """Test getting scan history with entries."""
+        # Start and cancel multiple scans to populate history
+        scanner_factory = MagicMock()
+        
+        await service.start_scan(scanner_factory)
+        await service.cancel_scan()
+        
+        await service.start_scan(scanner_factory)
+        await service.cancel_scan()
+
+        history = await service.get_scan_history()
+
+        assert len(history) == 2
+        # Should be newest first
+        assert history[0]["status"] == "cancelled"
+
+    @pytest.mark.asyncio
+    async def test_get_scan_history_limit(self, service):
+        """Test scan history respects limit."""
+        scanner_factory = MagicMock()
+        
+        # Create 3 history entries
+        for _ in range(3):
+            await service.start_scan(scanner_factory)
+            await service.cancel_scan()
+
+        history = await service.get_scan_history(limit=2)
+
+        assert len(history) == 2
+
+    @pytest.mark.asyncio
+    async def test_subscribe_to_scan_events(self, service):
+        """Test subscribing to scan events."""
+        handler = MagicMock()
+        
+        service.subscribe_to_scan_events(handler)
+
+        assert handler in service._scan_event_handlers
+
+    @pytest.mark.asyncio
+    async def test_unsubscribe_from_scan_events(self, service):
+        """Test unsubscribing from scan events."""
+        handler = MagicMock()
+        service.subscribe_to_scan_events(handler)
+        
+        service.unsubscribe_from_scan_events(handler)
+
+        assert handler not in service._scan_event_handlers
+
+    @pytest.mark.asyncio
+    async def test_emit_scan_event(self, service):
+        """Test emitting scan events to handlers."""
+        handler = AsyncMock()
+        service.subscribe_to_scan_events(handler)
+
+        await service._emit_scan_event({
+            "type": "scan_progress",
+            "key": "test-series",
+            "folder": "Test Folder",
+        })
+
+        handler.assert_called_once_with({
+            "type": "scan_progress",
+            "key": "test-series",
+            "folder": "Test Folder",
+        })
+
+    @pytest.mark.asyncio
+    async def test_emit_scan_event_sync_handler(self, service):
+        """Test emitting scan events to sync handlers."""
+        handler = MagicMock()
+        service.subscribe_to_scan_events(handler)
+
+        await service._emit_scan_event({
+            "type": "scan_progress",
+            "data": {"key": "test-series"},
+        })
+
+        handler.assert_called_once()
+
+    @pytest.mark.asyncio
+    async def test_create_callback_manager(self, service):
+        """Test creating a callback manager."""
+        scanner_factory = MagicMock()
+        await service.start_scan(scanner_factory)
+        
+        callback_manager = service.create_callback_manager()
+
+        assert callback_manager is not None
+        assert isinstance(callback_manager, CallbackManager)
+
+    @pytest.mark.asyncio
+    async def test_create_callback_manager_no_current_scan(self, service):
+        """Test creating callback manager without current scan."""
+        callback_manager = service.create_callback_manager()
+
+        assert callback_manager is not None
+        assert service.current_scan is not None
+
+    @pytest.mark.asyncio
+    async def test_handle_progress_update(
+        self, service, mock_progress_service
+    ):
+        """Test handling progress update."""
+        scanner_factory = MagicMock()
+        await service.start_scan(scanner_factory)
+        
+        scan_progress = service.current_scan
+        scan_progress.current = 5
+        scan_progress.total = 10
+        scan_progress.percentage = 50.0
+        scan_progress.message = "Processing..."
+        scan_progress.key = "test-series"
+        scan_progress.folder = "Test Folder"
+
+        await service._handle_progress_update(scan_progress)
+
+        mock_progress_service.update_progress.assert_called_once()
+        call_kwargs = mock_progress_service.update_progress.call_args.kwargs
+        assert call_kwargs["key"] == "test-series"
+        assert call_kwargs["folder"] == "Test Folder"
+
+    @pytest.mark.asyncio
+    async def test_handle_scan_error(self, service):
+        """Test handling scan error."""
+        handler = AsyncMock()
+        service.subscribe_to_scan_events(handler)
+        
+        scanner_factory = MagicMock()
+        await service.start_scan(scanner_factory)
+        
+        scan_progress = service.current_scan
+        error_context = ErrorContext(
+            operation_type=OperationType.SCAN,
+            operation_id=scan_progress.scan_id,
+            error=ValueError("Test error"),
+            message="Test error message",
+            recoverable=True,
+            key="test-series",
+            folder="Test Folder",
+        )
+
+        await service._handle_scan_error(scan_progress, error_context)
+
+        # Handler is called twice: once for start, once for error
+        assert handler.call_count == 2
+        # Get the error event (second call)
+        error_event = handler.call_args_list[1][0][0]
+        assert error_event["type"] == "scan_error"
+        assert error_event["key"] == "test-series"
+        assert error_event["folder"] == "Test Folder"
+
+    @pytest.mark.asyncio
+    async def test_handle_scan_completion_success(
+        self, service, mock_progress_service
+    ):
+        """Test handling successful scan completion."""
+        handler = AsyncMock()
+        service.subscribe_to_scan_events(handler)
+        
+        scanner_factory = MagicMock()
+        scan_id = await service.start_scan(scanner_factory)
+        
+        scan_progress = service.current_scan
+        completion_context = CompletionContext(
+            operation_type=OperationType.SCAN,
+            operation_id=scan_id,
+            success=True,
+            message="Scan completed",
+            statistics={"series_found": 5, "total_folders": 10},
+        )
+
+        await service._handle_scan_completion(
+            scan_progress, completion_context
+        )
+
+        assert service.is_scanning is False
+        assert len(service._scan_history) == 1
+        mock_progress_service.complete_progress.assert_called_once()
+        # Handler is called twice: once for start, once for completion
+        assert handler.call_count == 2
+        # Get the completion event (second call)
+        completion_event = handler.call_args_list[1][0][0]
+        assert completion_event["type"] == "scan_completed"
+        assert completion_event["success"] is True
+
+    @pytest.mark.asyncio
+    async def test_handle_scan_completion_failure(
+        self, service, mock_progress_service
+    ):
+        """Test handling failed scan completion."""
+        handler = AsyncMock()
+        service.subscribe_to_scan_events(handler)
+        
+        scanner_factory = MagicMock()
+        scan_id = await service.start_scan(scanner_factory)
+        
+        scan_progress = service.current_scan
+        completion_context = CompletionContext(
+            operation_type=OperationType.SCAN,
+            operation_id=scan_id,
+            success=False,
+            message="Scan failed: critical error",
+        )
+
+        await service._handle_scan_completion(
+            scan_progress, completion_context
+        )
+
+        assert service.is_scanning is False
+        mock_progress_service.fail_progress.assert_called_once()
+        # Handler is called twice: once for start, once for failure
+        assert handler.call_count == 2
+        # Get the failure event (second call)
+        failure_event = handler.call_args_list[1][0][0]
+        assert failure_event["type"] == "scan_failed"
+        assert failure_event["success"] is False
+
+
+class TestScanServiceSingleton:
+    """Test ScanService singleton functions."""
+
+    def test_get_scan_service_returns_singleton(self):
+        """Test that get_scan_service returns a singleton."""
+        reset_scan_service()
+        
+        service1 = get_scan_service()
+        service2 = get_scan_service()
+
+        assert service1 is service2
+
+    def test_reset_scan_service(self):
+        """Test that reset_scan_service clears the singleton."""
+        reset_scan_service()
+        service1 = get_scan_service()
+        
+        reset_scan_service()
+        service2 = get_scan_service()
+
+        assert service1 is not service2
+
+
+class TestScanServiceKeyIdentification:
+    """Test that ScanService uses key as primary identifier."""
+
+    @pytest.fixture
+    def mock_progress_service(self):
+        """Create a mock progress service."""
+        service = MagicMock()
+        service.start_progress = AsyncMock()
+        service.update_progress = AsyncMock()
+        service.complete_progress = AsyncMock()
+        service.fail_progress = AsyncMock()
+        return service
+
+    @pytest.fixture
+    def service(self, mock_progress_service):
+        """Create a ScanService instance."""
+        return ScanService(progress_service=mock_progress_service)
+
+    @pytest.mark.asyncio
+    async def test_progress_update_includes_key(
+        self, service, mock_progress_service
+    ):
+        """Test that progress updates include key as primary identifier."""
+        scanner_factory = MagicMock()
+        await service.start_scan(scanner_factory)
+        
+        scan_progress = service.current_scan
+        scan_progress.key = "attack-on-titan"
+        scan_progress.folder = "Attack on Titan (2013)"
+
+        await service._handle_progress_update(scan_progress)
+
+        call_kwargs = mock_progress_service.update_progress.call_args.kwargs
+        assert call_kwargs["key"] == "attack-on-titan"
+        assert call_kwargs["folder"] == "Attack on Titan (2013)"
+
+    @pytest.mark.asyncio
+    async def test_scan_event_includes_key(self, service):
+        """Test that scan events include key as primary identifier."""
+        events_received = []
+        
+        async def capture_event(event):
+            events_received.append(event)
+        
+        service.subscribe_to_scan_events(capture_event)
+
+        await service._emit_scan_event({
+            "type": "scan_progress",
+            "key": "my-hero-academia",
+            "folder": "My Hero Academia (2016)",
+            "data": {"status": "in_progress"},
+        })
+
+        assert len(events_received) == 1
+        assert events_received[0]["key"] == "my-hero-academia"
+        assert events_received[0]["folder"] == "My Hero Academia (2016)"
+
+    @pytest.mark.asyncio
+    async def test_error_event_includes_key(self, service):
+        """Test that error events include key as primary identifier."""
+        events_received = []
+        
+        async def capture_event(event):
+            events_received.append(event)
+        
+        service.subscribe_to_scan_events(capture_event)
+        
+        scanner_factory = MagicMock()
+        await service.start_scan(scanner_factory)
+        
+        scan_progress = service.current_scan
+        error_context = ErrorContext(
+            operation_type=OperationType.SCAN,
+            operation_id=scan_progress.scan_id,
+            error=ValueError("Test"),
+            message="Error message",
+            key="demon-slayer",
+            folder="Demon Slayer (2019)",
+        )
+
+        await service._handle_scan_error(scan_progress, error_context)
+
+        assert len(events_received) == 2  # Started + error
+        error_event = events_received[1]
+        assert error_event["type"] == "scan_error"
+        assert error_event["key"] == "demon-slayer"
+        assert error_event["folder"] == "Demon Slayer (2019)"
+
+    @pytest.mark.asyncio
+    async def test_scan_status_includes_key(self, service):
+        """Test that scan status includes key in current scan."""
+        scanner_factory = MagicMock()
+        await service.start_scan(scanner_factory)
+        
+        service.current_scan.key = "one-piece"
+        service.current_scan.folder = "One Piece (1999)"
+
+        status = await service.get_scan_status()
+
+        assert status["current_scan"]["key"] == "one-piece"
+        assert status["current_scan"]["folder"] == "One Piece (1999)"
+
+    @pytest.mark.asyncio
+    async def test_scan_history_includes_key(self, service):
+        """Test that scan history includes key in entries."""
+        scanner_factory = MagicMock()
+        
+        await service.start_scan(scanner_factory)
+        service.current_scan.key = "naruto"
+        service.current_scan.folder = "Naruto (2002)"
+        await service.cancel_scan()
+
+        history = await service.get_scan_history()
+
+        assert len(history) == 1
+        assert history[0]["key"] == "naruto"
+        assert history[0]["folder"] == "Naruto (2002)"