diff --git a/IMPROVEMENTS.md b/IMPROVEMENTS.md
index 1fbc019b..2ca95fbe 100644
--- a/IMPROVEMENTS.md
+++ b/IMPROVEMENTS.md
@@ -46,52 +46,11 @@
 
 ### High Priority
 
-- **Fix excessive `as any` type casts bypassing type safety** → [Issue #29](https://github.com/mchestr/plex-manager/issues/29)
-  - **Files affected**:
-    - `actions/maintenance.ts:75, 108` - `criteria: validated.criteria as any`
-    - `lib/maintenance/scanner.ts:230` - `const criteria = rule.criteria as any`
-    - `lib/maintenance/rule-evaluator.ts:219` - `return (item as any)[fieldKey]`
-  - **Problem**: Prisma's JSON type doesn't recognize Zod's validated types, using `as any` defeats TypeScript's purpose
-  - **Fix**: Use proper Prisma.JsonValue casting or Record<string, unknown> for dynamic access
-  - **Impact**: Type safety violations could cause runtime errors
-  - **Reference**: TypeScript strict mode enabled in project (CLAUDE.md)
-
-- **Fix dynamic require() in production code** → [Issue #30](https://github.com/mchestr/plex-manager/issues/30)
-  - **File**: `lib/maintenance/rule-evaluator.ts:76`
-  - **Code**: `const { migrateLegacyRuleCriteria } = require('@/lib/validations/maintenance')`
-  - **Problem**: Using `require()` in ESM project causes potential tree-shaking issues and runtime errors
-  - **Fix**: Move to top-level import or make migration explicit
-  - **Impact**: Could break in production builds, prevents proper code optimization
-
-- **Fix unguarded dynamic object property access** → [Issue #31](https://github.com/mchestr/plex-manager/issues/31)
-  - **File**: `lib/maintenance/rule-evaluator.ts:219`
-  - **Code**: `return (item as any)[fieldKey]`
-  - **Problem**: Dynamic property access with `as any` bypasses type checking
-  - **Fix**: Use `Record<string, unknown>` type instead of `any`
-  - **Impact**: No type safety for field access, could access undefined properties
+-
 
 ### Medium Priority
 
-- **Complete or remove incomplete worker implementation** → [Issue #32](https://github.com/mchestr/plex-manager/issues/32)
-  - **File**: `lib/maintenance/worker.ts`
-  - **Lines**: 32-46 (scanner returns `{ candidatesFound: 0 }`), 82-96 (deleter returns `{ deletedCount: 0 }`)
-  - **Problem**: Worker file exists but functions are not implemented, just return empty results
-  - **Fix**: Either complete implementation or remove file if not needed yet
-  - **Impact**: Dead code in production, could confuse developers
-
-- **Add error context to scanner error messages** → [Issue #33](https://github.com/mchestr/plex-manager/issues/33)
-  - **File**: `lib/maintenance/scanner.ts:246-249`
-  - **Problem**: Throws generic errors without rule/library context for debugging
-  - **Fix**: Include rule name, ID, and media type in error messages
-  - **Example**: `throw new Error(\`${mediaType} rules must specify libraryIds. Rule: ${rule.name} (${ruleId})\`)`
-  - **Impact**: Harder to debug issues in production
-
-- **Replace magic numbers with named constants** → [Issue #34](https://github.com/mchestr/plex-manager/issues/34)
-  - **File**: `lib/maintenance/scanner.ts`
-  - **Lines**: 72 (`length: 10000`), 284 (`itemsScanned % 10 === 0`)
-  - **Problem**: Hardcoded pagination limits and progress intervals reduce maintainability
-  - **Fix**: Extract to named constants (e.g., `MAX_LIBRARY_ITEMS`, `PROGRESS_REPORT_INTERVAL`)
-  - **Impact**: Harder to adjust thresholds, unclear intent
+-
 
 ### Low Priority
 
@@ -125,57 +84,9 @@
   - **Why**: Ensures consistent styling, behavior, and accessibility across the app
   - **When adding new UI**: First check if a component exists in `components/ui/` before creating anything new
 
-- **Split large maintenance components exceeding file size guidelines** → [Issue #35](https://github.com/mchestr/plex-manager/issues/35)
-  - **Files affected**:
-    - `components/maintenance/condition-value-input.tsx` - 486 lines (guideline: <200-300)
-    - `app/admin/maintenance/candidates/page.tsx` - 381 lines
-    - `app/admin/maintenance/rules/page.tsx` - 318 lines
-  - **Problem**: Large components violate Single Responsibility Principle and file size guidelines
-  - **Fix for condition-value-input.tsx**: Extract individual input types (StringInput, NumberInput, DateInput, etc.) into separate files
-  - **Fix for candidates page**: Split into `CandidateList`, `CandidateFilters`, `CandidateActions` components
-  - **Fix for rules page**: Extract `RuleList`, `RuleFilters`, `RuleActions` components
-  - **Impact**: Harder to test, maintain, and understand at a glance
-  - **Reference**: CLAUDE.md Component Design Philosophy (200-300 line limit)
-
-- **Use styled UI component instead of raw textarea** → [Issue #36](https://github.com/mchestr/plex-manager/issues/36)
-  - **File**: `app/admin/maintenance/rules/new/page.tsx:142`
-  - **Problem**: Using raw `<textarea>` instead of styled component from `components/ui/`
-  - **Fix**: Create or use `<StyledTextarea>` from `components/ui/` for consistency
-  - **Impact**: Inconsistent styling and behavior across the app
-
-- **Reduce `as any` usage in test mocks** → [Issue #37](https://github.com/mchestr/plex-manager/issues/37)
-  - **File**: `actions/__tests__/maintenance.test.ts`
-  - **Problem**: 27 instances of `as any` in test mocks bypass type checking
-  - **Fix**: Create proper mock types using `Partial<MaintenanceRule>` pattern
-  - **Example**: `const mockRule: Partial<MaintenanceRule> = { ... }; mockPrisma.create.mockResolvedValue(mockRule as MaintenanceRule)`
-  - **Impact**: Tests could pass with invalid data structures
-
 ### Performance
 
-- **Add pagination for candidate listing** → [Issue #38](https://github.com/mchestr/plex-manager/issues/38)
-  - **File**: `actions/maintenance.ts:462`
-  - **Problem**: `findMany` without `take`/`skip` could return thousands of records
-  - **Fix**: Add pagination parameters (skip, take) to `getCandidates()` function
-  - **Impact**: Performance degradation with large result sets, potential memory issues
-
-- **Investigate potential N+1 query in maintenance rule fetching** → [Issue #39](https://github.com/mchestr/plex-manager/issues/39)
-  - **File**: `actions/maintenance.ts:28-48`
-  - **Problem**: Uses nested `include` with aggregations, could be slow with many rules
-  - **Fix**: Profile query performance, consider separate queries for statistics if needed
-  - **Impact**: Slow admin dashboard load times with many rules
-
-- **Add database index for common MaintenanceCandidate queries** → [Issue #40](https://github.com/mchestr/plex-manager/issues/40)
-  - **File**: `prisma/schema.prisma` (MaintenanceCandidate model)
-  - **Problem**: No composite index on `[mediaType, plexRatingKey]` for faster lookups
-  - **Fix**: Add `@@index([mediaType, plexRatingKey])` to schema
-  - **Impact**: Slower queries when filtering candidates by media type
-
-- **Add rate limiting for maintenance scan operations** → [Issue #41](https://github.com/mchestr/plex-manager/issues/41)
-  - **File**: `actions/maintenance.ts` (runMaintenanceScan action)
-  - **Problem**: No rate limiting on resource-intensive scan operations
-  - **Fix**: Use `@/lib/security/rate-limit` to limit scans (e.g., 5 per hour per admin)
-  - **Impact**: Potential DoS if malicious admin triggers many scans
-  - **Security consideration**: Scanner fetches up to 10,000 items without pagination
+-
 
 ### Architecture
 
@@ -225,28 +136,6 @@
 
 ## 📚 Documentation
 
-- **Add JSDoc comments to complex maintenance components** → [Issue #44](https://github.com/mchestr/plex-manager/issues/44)
-  - **Files needing documentation**:
-    - `components/maintenance/condition-group-builder.tsx` - Recursive group builder
-    - `components/maintenance/enhanced-rule-builder.tsx` - Main rule builder interface
-    - `lib/maintenance/rule-evaluator.ts` - Core evaluation logic
-    - `lib/maintenance/scanner.ts` - Media scanning logic
-  - **What to document**:
-    - Component purpose and behavior
-    - Parameter descriptions
-    - Return value types and meanings
-    - Complex algorithm explanations
-  - **Example**: `/** Recursive condition group builder supporting nested AND/OR logic @param group - Current condition group @param depth - Nesting depth for UI styling */`
-  - **Impact**: Harder for developers to understand complex components
-  - **Reference**: Component Design Philosophy section in this document
-
-- **Document field registry data sources** → [Issue #45](https://github.com/mchestr/plex-manager/issues/45)
-  - **File**: `lib/maintenance/field-registry.ts`
-  - **Problem**: Fields reference Tautulli but schema shows Radarr/Sonarr support, unclear which API provides each field
-  - **Fix**: Add comments explaining which service API endpoints provide each field
-  - **Example**: Add comment for `playCount` field noting it comes from Tautulli's `get_library_media_info` endpoint
-  - **Impact**: Confusion about data sources when debugging or extending fields
-
 **NOTE:** The following API documentation sections are reference material already added to `CLAUDE.md` - they do not need to be converted to GitHub issues.
 
 - ✅ **Plex Media Server API Conventions** (already in CLAUDE.md)
@@ -341,31 +230,6 @@
   - Test IDs should be descriptive and stable (won't change with styling/content updates)
   - Example: `<button data-testid="sonarr-series-add-button">Add Series</button>`
 
-- **Add E2E tests for maintenance feature workflows** → [Issue #42](https://github.com/mchestr/plex-manager/issues/42)
-  - **Missing tests for**:
-    - Creating and editing maintenance rules
-    - Running scans and viewing results
-    - Reviewing and approving deletion candidates
-    - Bulk operations on candidates
-  - **Requirements**:
-    - Use `data-testid` attributes following project convention
-    - Add test IDs to maintenance components where missing
-    - Test critical user flows end-to-end
-    - Use authenticated session setup (see `e2e/README.md`)
-  - **Files to add test IDs**:
-    - `components/maintenance/*.tsx` - Add descriptive test IDs
-    - `app/admin/maintenance/**/*.tsx` - Add test IDs to interactive elements
-  - **Impact**: No E2E coverage for major new feature, regressions could go undetected
-  - **Reference**: CLAUDE.md Playwright Testing Best Practices
-
-- **Replace direct fetch with TanStack Query in maintenance forms** → [Issue #43](https://github.com/mchestr/plex-manager/issues/43)
-  - **File**: `app/admin/maintenance/rules/new/page.tsx:39-56`
-  - **Problem**: Direct `fetch()` calls in `useEffect` instead of TanStack Query
-  - **Fix**: Use `useQuery` for consistency with project patterns
-  - **Example**: `const { data: servers } = useQuery({ queryKey: ['radarr-servers'], queryFn: () => fetch('/api/admin/radarr').then(r => r.json()) })`
-  - **Impact**: Inconsistent data fetching patterns, missing loading/error states
-  - **Reference**: CLAUDE.md Data Fetching - Client Components use TanStack Query
-
 ---
 
 ## 🚀 DevOps & Infrastructure
@@ -496,80 +360,7 @@
 
 ### GitHub Issues Created (November 27, 2025)
 
-#### Code Review Findings - Maintenance Feature (Issues #29-45)
-
-**Critical Type Safety Issues:**
-- [Issue #29](https://github.com/mchestr/plex-manager/issues/29): Fix excessive 'as any' type casts bypassing type safety
-  - Labels: `bug`, `refactor`
-  - Files: `actions/maintenance.ts`, `lib/maintenance/scanner.ts`, `lib/maintenance/rule-evaluator.ts`
-
-- [Issue #30](https://github.com/mchestr/plex-manager/issues/30): Fix dynamic require() in production ESM code
-  - Labels: `bug`
-  - File: `lib/maintenance/rule-evaluator.ts:76`
-
-- [Issue #31](https://github.com/mchestr/plex-manager/issues/31): Fix unguarded dynamic object property access
-  - Labels: `bug`
-  - File: `lib/maintenance/rule-evaluator.ts:219`
-
-**Code Quality & Refactoring:**
-- [Issue #32](https://github.com/mchestr/plex-manager/issues/32): Complete or remove incomplete worker implementation
-  - Labels: `bug`, `refactor`
-  - File: `lib/maintenance/worker.ts`
-
-- [Issue #33](https://github.com/mchestr/plex-manager/issues/33): Add error context to scanner error messages
-  - Labels: `enhancement`, `refactor`
-  - File: `lib/maintenance/scanner.ts`
-
-- [Issue #34](https://github.com/mchestr/plex-manager/issues/34): Replace magic numbers with named constants in scanner
-  - Labels: `refactor`
-  - File: `lib/maintenance/scanner.ts`
-
-- [Issue #35](https://github.com/mchestr/plex-manager/issues/35): Split large maintenance components exceeding file size guidelines
-  - Labels: `refactor`
-  - Files: `components/maintenance/condition-value-input.tsx` (486 lines), `app/admin/maintenance/candidates/page.tsx` (381 lines), `app/admin/maintenance/rules/page.tsx` (318 lines)
-
-- [Issue #36](https://github.com/mchestr/plex-manager/issues/36): Use styled UI component instead of raw textarea
-  - Labels: `refactor`
-  - File: `app/admin/maintenance/rules/new/page.tsx:142`
-
-- [Issue #37](https://github.com/mchestr/plex-manager/issues/37): Reduce 'as any' usage in test mocks
-  - Labels: `refactor`, `testing`
-  - File: `actions/__tests__/maintenance.test.ts`
-
-**Performance & Database:**
-- [Issue #38](https://github.com/mchestr/plex-manager/issues/38): Add pagination for candidate listing
-  - Labels: `enhancement`, `performance`
-  - File: `actions/maintenance.ts:462`
-
-- [Issue #39](https://github.com/mchestr/plex-manager/issues/39): Investigate potential N+1 query in maintenance rule fetching
-  - Labels: `performance`
-  - File: `actions/maintenance.ts:28-48`
-
-- [Issue #40](https://github.com/mchestr/plex-manager/issues/40): Add database index for MaintenanceCandidate queries
-  - Labels: `database`, `performance`
-  - File: `prisma/schema.prisma`
-
-- [Issue #41](https://github.com/mchestr/plex-manager/issues/41): Add rate limiting for maintenance scan operations
-  - Labels: `enhancement`, `security`
-  - File: `actions/maintenance.ts`
-
-**Testing:**
-- [Issue #42](https://github.com/mchestr/plex-manager/issues/42): Add E2E tests for maintenance feature workflows
-  - Labels: `testing`, `enhancement`
-  - Missing: Rule creation, scan execution, candidate review workflows
-
-- [Issue #43](https://github.com/mchestr/plex-manager/issues/43): Replace direct fetch with TanStack Query in maintenance forms
-  - Labels: `refactor`
-  - File: `app/admin/maintenance/rules/new/page.tsx:39-56`
-
-**Documentation:**
-- [Issue #44](https://github.com/mchestr/plex-manager/issues/44): Add JSDoc comments to complex maintenance components
-  - Labels: `documentation`
-  - Files: `components/maintenance/`, `lib/maintenance/`
-
-- [Issue #45](https://github.com/mchestr/plex-manager/issues/45): Document field registry data sources
-  - Labels: `documentation`
-  - File: `lib/maintenance/field-registry.ts`
+**Note:** Issues #29-45 were related to the maintenance feature which has been removed in PR #204.
 
 #### Earlier Issues
 
diff --git a/actions/__tests__/maintenance.test.ts b/actions/__tests__/maintenance.test.ts
deleted file mode 100644
index ee1ae2e8..00000000
--- a/actions/__tests__/maintenance.test.ts
+++ /dev/null
@@ -1,1133 +0,0 @@
-/**
- * Tests for actions/maintenance.ts - maintenance rule and candidate operations
- */
-
-import {
-  getMaintenanceRules,
-  createMaintenanceRule,
-  updateMaintenanceRule,
-  deleteMaintenanceRule,
-  toggleMaintenanceRule,
-  getMaintenanceCandidates,
-  updateCandidateReviewStatus,
-  bulkUpdateCandidates,
-  getUserMediaMarks,
-  createUserMediaMark,
-  deleteUserMediaMark,
-  getMaintenanceStats,
-} from '@/actions/maintenance'
-import { requireAdmin } from '@/lib/admin'
-import { prisma } from '@/lib/prisma'
-import { getServerSession } from 'next-auth'
-import { revalidatePath } from 'next/cache'
-import type {
-  MaintenanceRule,
-  MaintenanceCandidate,
-  MaintenanceScan,
-  UserMediaMark,
-} from '@/lib/generated/prisma/client'
-import type { Session } from 'next-auth'
-
-jest.mock('@/lib/admin', () => ({
-  requireAdmin: jest.fn(),
-}))
-
-jest.mock('@/lib/prisma', () => ({
-  prisma: {
-    maintenanceRule: {
-      findMany: jest.fn(),
-      findUnique: jest.fn(),
-      create: jest.fn(),
-      update: jest.fn(),
-      delete: jest.fn(),
-      count: jest.fn(),
-    },
-    maintenanceCandidate: {
-      findMany: jest.fn(),
-      update: jest.fn(),
-      updateMany: jest.fn(),
-      count: jest.fn(),
-    },
-    userMediaMark: {
-      findMany: jest.fn(),
-      findFirst: jest.fn(),
-      findUnique: jest.fn(),
-      create: jest.fn(),
-      delete: jest.fn(),
-    },
-    maintenanceScan: {
-      findMany: jest.fn(),
-    },
-    maintenanceDeletionLog: {
-      count: jest.fn(),
-    },
-  },
-}))
-
-
-jest.mock('next-auth', () => ({
-  getServerSession: jest.fn(),
-}))
-
-jest.mock('next/cache', () => ({
-  revalidatePath: jest.fn(),
-}))
-
-const mockRequireAdmin = requireAdmin as jest.MockedFunction<typeof requireAdmin>
-const mockGetServerSession = getServerSession as jest.MockedFunction<typeof getServerSession>
-const mockPrisma = prisma as jest.Mocked<typeof prisma>
-const mockRevalidatePath = revalidatePath as jest.MockedFunction<typeof revalidatePath>
-
-describe('Maintenance Actions', () => {
-  const mockAdminSession: Partial<Session> = {
-    user: {
-      id: 'admin-1',
-      email: 'admin@example.com',
-      name: 'Admin User',
-      isAdmin: true,
-    },
-  }
-
-  const mockUserSession: Partial<Session> = {
-    user: {
-      id: 'user-1',
-      email: 'user@example.com',
-      name: 'Regular User',
-      isAdmin: false,
-    },
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('getMaintenanceRules', () => {
-    it('should return all maintenance rules with scan counts', async () => {
-      const mockRules: Partial<MaintenanceRule>[] = [
-        {
-          id: 'rule-1',
-          name: 'Old Movies',
-          enabled: true,
-          scans: [
-            {
-              id: 'scan-1',
-              status: 'COMPLETED',
-              itemsScanned: 100,
-              itemsFlagged: 10,
-              completedAt: new Date(),
-            },
-          ],
-          _count: { scans: 5 },
-        },
-        {
-          id: 'rule-2',
-          name: 'Unwatched Shows',
-          enabled: false,
-          scans: [],
-          _count: { scans: 0 },
-        },
-      ]
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.findMany.mockResolvedValue(mockRules as MaintenanceRule[])
-
-      const result = await getMaintenanceRules()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockRules)
-      expect(mockRequireAdmin).toHaveBeenCalled()
-      expect(mockPrisma.maintenanceRule.findMany).toHaveBeenCalledWith({
-        orderBy: { createdAt: 'desc' },
-        include: {
-          scans: {
-            orderBy: { createdAt: 'desc' },
-            take: 1,
-            select: {
-              id: true,
-              status: true,
-              itemsScanned: true,
-              itemsFlagged: true,
-              completedAt: true,
-            },
-          },
-          _count: {
-            select: {
-              scans: true,
-            },
-          },
-        },
-      })
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(getMaintenanceRules()).rejects.toThrow('Unauthorized')
-      expect(mockRequireAdmin).toHaveBeenCalled()
-    })
-
-    it('should handle database errors', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.findMany.mockRejectedValue(new Error('DB error'))
-
-      const result = await getMaintenanceRules()
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('DB error')
-    })
-
-    it('should return empty array when no rules exist (0 rules scenario)', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.findMany.mockResolvedValue([])
-
-      const result = await getMaintenanceRules()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual([])
-      expect(result.data).toHaveLength(0)
-    })
-
-    it('should handle rules with 0 scans correctly (0 scans scenario)', async () => {
-      const mockRulesNoScans: Partial<MaintenanceRule>[] = [
-        {
-          id: 'rule-1',
-          name: 'New Rule 1',
-          enabled: true,
-          scans: [],
-          _count: { scans: 0 },
-        },
-        {
-          id: 'rule-2',
-          name: 'New Rule 2',
-          enabled: true,
-          scans: [],
-          _count: { scans: 0 },
-        },
-      ]
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.findMany.mockResolvedValue(mockRulesNoScans as MaintenanceRule[])
-
-      const result = await getMaintenanceRules()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toHaveLength(2)
-      expect(result.data?.[0].scans).toEqual([])
-      expect(result.data?.[0]._count.scans).toBe(0)
-      expect(result.data?.[1].scans).toEqual([])
-      expect(result.data?.[1]._count.scans).toBe(0)
-    })
-
-    it('should handle mixed states (some rules with scans, some without)', async () => {
-      const mockMixedRules: Partial<MaintenanceRule>[] = [
-        {
-          id: 'rule-1',
-          name: 'Rule With Scans',
-          enabled: true,
-          scans: [
-            {
-              id: 'scan-1',
-              status: 'COMPLETED',
-              itemsScanned: 50,
-              itemsFlagged: 5,
-              completedAt: new Date(),
-            },
-          ],
-          _count: { scans: 10 },
-        },
-        {
-          id: 'rule-2',
-          name: 'Rule Without Scans',
-          enabled: true,
-          scans: [],
-          _count: { scans: 0 },
-        },
-        {
-          id: 'rule-3',
-          name: 'Another Rule With Scans',
-          enabled: false,
-          scans: [
-            {
-              id: 'scan-2',
-              status: 'FAILED',
-              itemsScanned: 0,
-              itemsFlagged: 0,
-              completedAt: null,
-            },
-          ],
-          _count: { scans: 1 },
-        },
-      ]
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.findMany.mockResolvedValue(mockMixedRules as MaintenanceRule[])
-
-      const result = await getMaintenanceRules()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toHaveLength(3)
-
-      // Rule with scans
-      expect(result.data?.[0].scans).toHaveLength(1)
-      expect(result.data?.[0]._count.scans).toBe(10)
-
-      // Rule without scans
-      expect(result.data?.[1].scans).toHaveLength(0)
-      expect(result.data?.[1]._count.scans).toBe(0)
-
-      // Another rule with scans (but failed)
-      expect(result.data?.[2].scans).toHaveLength(1)
-      expect(result.data?.[2].scans[0].status).toBe('FAILED')
-      expect(result.data?.[2]._count.scans).toBe(1)
-    })
-
-    it('should use a single findMany call regardless of rule count (N+1 prevention)', async () => {
-      // Create a larger dataset to verify N+1 prevention
-      const mockManyRules: Partial<MaintenanceRule>[] = Array.from({ length: 50 }, (_, i) => ({
-        id: `rule-${i}`,
-        name: `Rule ${i}`,
-        enabled: i % 2 === 0,
-        scans:
-          i % 3 === 0
-            ? [
-                {
-                  id: `scan-${i}`,
-                  status: 'COMPLETED',
-                  itemsScanned: 100 + i,
-                  itemsFlagged: i,
-                  completedAt: new Date(),
-                },
-              ]
-            : [],
-        _count: { scans: i % 3 === 0 ? 5 : 0 },
-      }))
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.findMany.mockResolvedValue(mockManyRules as MaintenanceRule[])
-
-      const result = await getMaintenanceRules()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toHaveLength(50)
-
-      // Verify that findMany was called exactly once (no N+1 queries)
-      // Prisma's include with _count should batch all queries efficiently
-      expect(mockPrisma.maintenanceRule.findMany).toHaveBeenCalledTimes(1)
-
-      // Verify the query structure uses include (which Prisma optimizes to 2 queries)
-      expect(mockPrisma.maintenanceRule.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          include: expect.objectContaining({
-            scans: expect.any(Object),
-            _count: expect.any(Object),
-          }),
-        })
-      )
-    })
-  })
-
-  describe('createMaintenanceRule', () => {
-    const validInput = {
-      name: 'Test Rule',
-      description: 'Test description',
-      enabled: true,
-      mediaType: 'MOVIE' as const,
-      criteria: {
-        type: 'group' as const,
-        id: 'group-1',
-        operator: 'AND' as const,
-        conditions: [
-          {
-            type: 'condition' as const,
-            id: 'cond-1',
-            field: 'neverWatched',
-            operator: 'equals',
-            value: true,
-          },
-        ],
-      },
-      actionType: 'FLAG_FOR_REVIEW' as const,
-      schedule: '0 0 * * *',
-    }
-
-    it('should create maintenance rule successfully', async () => {
-      const mockCreated: Partial<MaintenanceRule> = {
-        id: 'rule-1',
-        ...validInput,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.create.mockResolvedValue(mockCreated as MaintenanceRule)
-
-      const result = await createMaintenanceRule(validInput)
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockCreated)
-      expect(mockPrisma.maintenanceRule.create).toHaveBeenCalledWith({
-        data: {
-          name: validInput.name,
-          description: validInput.description,
-          enabled: validInput.enabled,
-          mediaType: validInput.mediaType,
-          criteria: validInput.criteria,
-          actionType: validInput.actionType,
-          schedule: validInput.schedule,
-        },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/admin/maintenance')
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(createMaintenanceRule(validInput)).rejects.toThrow('Unauthorized')
-      expect(mockRequireAdmin).toHaveBeenCalled()
-    })
-
-    it('should return validation error for invalid input', async () => {
-      const invalidInput = { name: '', mediaType: 'INVALID' }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-
-      const result = await createMaintenanceRule(invalidInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBeDefined()
-      expect(mockPrisma.maintenanceRule.create).not.toHaveBeenCalled()
-    })
-
-    it('should handle database errors', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.create.mockRejectedValue(new Error('DB error'))
-
-      const result = await createMaintenanceRule(validInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('DB error')
-    })
-  })
-
-  describe('updateMaintenanceRule', () => {
-    const updateInput = {
-      name: 'Updated Rule',
-      description: 'Updated description',
-      enabled: false,
-    }
-
-    it('should update maintenance rule successfully', async () => {
-      const mockUpdated: Partial<MaintenanceRule> = {
-        id: 'rule-1',
-        ...updateInput,
-        mediaType: 'MOVIE',
-        criteria: {},
-        actionType: 'FLAG_FOR_REVIEW',
-      }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.update.mockResolvedValue(mockUpdated as MaintenanceRule)
-
-      const result = await updateMaintenanceRule('rule-1', updateInput)
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockUpdated)
-      expect(mockPrisma.maintenanceRule.update).toHaveBeenCalledWith({
-        where: { id: 'rule-1' },
-        data: {
-          name: updateInput.name,
-          description: updateInput.description,
-          enabled: updateInput.enabled,
-          mediaType: undefined,
-          criteria: undefined,
-          actionType: undefined,
-          schedule: null,
-        },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/admin/maintenance')
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(updateMaintenanceRule('rule-1', updateInput)).rejects.toThrow('Unauthorized')
-    })
-
-    it('should return validation error for invalid input', async () => {
-      const invalidInput = { name: '' }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-
-      const result = await updateMaintenanceRule('rule-1', invalidInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBeDefined()
-      expect(mockPrisma.maintenanceRule.update).not.toHaveBeenCalled()
-    })
-
-    it('should handle database errors', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.update.mockRejectedValue(new Error('Rule not found'))
-
-      const result = await updateMaintenanceRule('nonexistent', updateInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Rule not found')
-    })
-  })
-
-  describe('deleteMaintenanceRule', () => {
-    it('should delete maintenance rule successfully', async () => {
-      const mockDeleted: Partial<MaintenanceRule> = { id: 'rule-1' }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.delete.mockResolvedValue(mockDeleted as MaintenanceRule)
-
-      const result = await deleteMaintenanceRule('rule-1')
-
-      expect(result.success).toBe(true)
-      expect(mockPrisma.maintenanceRule.delete).toHaveBeenCalledWith({
-        where: { id: 'rule-1' },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/admin/maintenance')
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(deleteMaintenanceRule('rule-1')).rejects.toThrow('Unauthorized')
-    })
-
-    it('should handle database errors', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.delete.mockRejectedValue(new Error('Rule not found'))
-
-      const result = await deleteMaintenanceRule('nonexistent')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Rule not found')
-    })
-  })
-
-  describe('toggleMaintenanceRule', () => {
-    it('should enable maintenance rule successfully', async () => {
-      const mockRule: Partial<MaintenanceRule> = {
-        id: 'rule-1',
-        name: 'Test Rule',
-        enabled: true,
-      }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.update.mockResolvedValue(mockRule as MaintenanceRule)
-
-      const result = await toggleMaintenanceRule('rule-1', true)
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockRule)
-      expect(mockPrisma.maintenanceRule.update).toHaveBeenCalledWith({
-        where: { id: 'rule-1' },
-        data: { enabled: true },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/admin/maintenance')
-    })
-
-    it('should disable maintenance rule successfully', async () => {
-      const mockRule: Partial<MaintenanceRule> = {
-        id: 'rule-1',
-        name: 'Test Rule',
-        enabled: false,
-      }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.update.mockResolvedValue(mockRule as MaintenanceRule)
-
-      const result = await toggleMaintenanceRule('rule-1', false)
-
-      expect(result.success).toBe(true)
-      expect(result.data?.enabled).toBe(false)
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(toggleMaintenanceRule('rule-1', true)).rejects.toThrow('Unauthorized')
-    })
-  })
-
-  describe('getMaintenanceCandidates', () => {
-    const mockCandidateData: Partial<MaintenanceCandidate>[] = [
-      {
-        id: 'candidate-1',
-        reviewStatus: 'PENDING',
-        mediaType: 'MOVIE',
-        scan: {
-          id: 'scan-1',
-          rule: { id: 'rule-1', name: 'Test Rule', actionType: 'FLAG_FOR_REVIEW' },
-        },
-      },
-    ]
-
-    beforeEach(() => {
-      mockPrisma.maintenanceCandidate.count.mockResolvedValue(1)
-      mockPrisma.maintenanceCandidate.findMany.mockResolvedValue(
-        mockCandidateData as MaintenanceCandidate[]
-      )
-    })
-
-    it('should return paginated candidates with default parameters', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-
-      const result = await getMaintenanceCandidates()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual({
-        candidates: mockCandidateData,
-        pagination: {
-          page: 1,
-          pageSize: 25,
-          totalCount: 1,
-          totalPages: 1,
-          hasNextPage: false,
-          hasPreviousPage: false,
-        },
-      })
-      expect(mockPrisma.maintenanceCandidate.count).toHaveBeenCalledWith({ where: {} })
-      expect(mockPrisma.maintenanceCandidate.findMany).toHaveBeenCalledWith({
-        where: {},
-        orderBy: { flaggedAt: 'desc' },
-        skip: 0,
-        take: 25,
-        include: {
-          scan: {
-            include: {
-              rule: {
-                select: {
-                  id: true,
-                  name: true,
-                  actionType: true,
-                },
-              },
-            },
-          },
-        },
-      })
-    })
-
-    it('should paginate correctly with custom page and pageSize', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.count.mockResolvedValue(100)
-
-      const result = await getMaintenanceCandidates({ page: 3, pageSize: 10 })
-
-      expect(result.success).toBe(true)
-      expect(result.data?.pagination).toEqual({
-        page: 3,
-        pageSize: 10,
-        totalCount: 100,
-        totalPages: 10,
-        hasNextPage: true,
-        hasPreviousPage: true,
-      })
-      expect(mockPrisma.maintenanceCandidate.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          skip: 20,
-          take: 10,
-        })
-      )
-    })
-
-    it('should filter candidates by review status with pagination', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.count.mockResolvedValue(50)
-
-      await getMaintenanceCandidates({ reviewStatus: 'APPROVED', page: 2, pageSize: 25 })
-
-      expect(mockPrisma.maintenanceCandidate.count).toHaveBeenCalledWith({
-        where: { reviewStatus: 'APPROVED' },
-      })
-      expect(mockPrisma.maintenanceCandidate.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: { reviewStatus: 'APPROVED' },
-          skip: 25,
-          take: 25,
-        })
-      )
-    })
-
-    it('should filter candidates by media type', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-
-      await getMaintenanceCandidates({ mediaType: 'TV_SERIES' })
-
-      expect(mockPrisma.maintenanceCandidate.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: { mediaType: 'TV_SERIES' },
-        })
-      )
-    })
-
-    it('should filter candidates by scan ID', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-
-      await getMaintenanceCandidates({ scanId: 'scan-1' })
-
-      expect(mockPrisma.maintenanceCandidate.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: { scanId: 'scan-1' },
-        })
-      )
-    })
-
-    it('should apply multiple filters with pagination', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-
-      await getMaintenanceCandidates({
-        reviewStatus: 'PENDING',
-        mediaType: 'MOVIE',
-        scanId: 'scan-1',
-        page: 1,
-        pageSize: 50,
-      })
-
-      expect(mockPrisma.maintenanceCandidate.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: {
-            reviewStatus: 'PENDING',
-            mediaType: 'MOVIE',
-            scanId: 'scan-1',
-          },
-          skip: 0,
-          take: 50,
-        })
-      )
-    })
-
-    it('should calculate hasNextPage and hasPreviousPage correctly', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.count.mockResolvedValue(75)
-
-      // Test first page - hasNextPage true, hasPreviousPage false
-      let result = await getMaintenanceCandidates({ page: 1, pageSize: 25 })
-      expect(result.data?.pagination.hasNextPage).toBe(true)
-      expect(result.data?.pagination.hasPreviousPage).toBe(false)
-
-      // Test middle page - both true
-      result = await getMaintenanceCandidates({ page: 2, pageSize: 25 })
-      expect(result.data?.pagination.hasNextPage).toBe(true)
-      expect(result.data?.pagination.hasPreviousPage).toBe(true)
-
-      // Test last page - hasNextPage false, hasPreviousPage true
-      result = await getMaintenanceCandidates({ page: 3, pageSize: 25 })
-      expect(result.data?.pagination.hasNextPage).toBe(false)
-      expect(result.data?.pagination.hasPreviousPage).toBe(true)
-    })
-
-    it('should handle empty results', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.count.mockResolvedValue(0)
-      mockPrisma.maintenanceCandidate.findMany.mockResolvedValue([])
-
-      const result = await getMaintenanceCandidates()
-
-      expect(result.success).toBe(true)
-      expect(result.data?.candidates).toEqual([])
-      expect(result.data?.pagination).toEqual({
-        page: 1,
-        pageSize: 25,
-        totalCount: 0,
-        totalPages: 0,
-        hasNextPage: false,
-        hasPreviousPage: false,
-      })
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(getMaintenanceCandidates()).rejects.toThrow('Unauthorized')
-    })
-  })
-
-  describe('updateCandidateReviewStatus', () => {
-    it('should update candidate review status successfully', async () => {
-      const mockCandidate: Partial<MaintenanceCandidate> = {
-        id: 'candidate-1',
-        reviewStatus: 'APPROVED',
-        reviewedAt: new Date(),
-        reviewedBy: 'admin-1',
-        reviewNote: 'Looks good',
-      }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.update.mockResolvedValue(mockCandidate as MaintenanceCandidate)
-
-      const result = await updateCandidateReviewStatus('candidate-1', 'APPROVED', 'Looks good')
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockCandidate)
-      expect(mockPrisma.maintenanceCandidate.update).toHaveBeenCalledWith({
-        where: { id: 'candidate-1' },
-        data: {
-          reviewStatus: 'APPROVED',
-          reviewedAt: expect.any(Date),
-          reviewedBy: 'admin-1',
-          reviewNote: 'Looks good',
-        },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/admin/maintenance')
-    })
-
-    it('should update without review note', async () => {
-      const mockCandidate: Partial<MaintenanceCandidate> = {
-        id: 'candidate-1',
-        reviewStatus: 'REJECTED',
-        reviewedAt: new Date(),
-        reviewedBy: 'admin-1',
-      }
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.update.mockResolvedValue(mockCandidate as MaintenanceCandidate)
-
-      const result = await updateCandidateReviewStatus('candidate-1', 'REJECTED')
-
-      expect(result.success).toBe(true)
-      expect(mockPrisma.maintenanceCandidate.update).toHaveBeenCalledWith({
-        where: { id: 'candidate-1' },
-        data: {
-          reviewStatus: 'REJECTED',
-          reviewedAt: expect.any(Date),
-          reviewedBy: 'admin-1',
-          reviewNote: undefined,
-        },
-      })
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(updateCandidateReviewStatus('candidate-1', 'APPROVED')).rejects.toThrow(
-        'Unauthorized'
-      )
-    })
-
-    it('should handle database errors', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.update.mockRejectedValue(new Error('Candidate not found'))
-
-      const result = await updateCandidateReviewStatus('nonexistent', 'APPROVED')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Candidate not found')
-    })
-  })
-
-  describe('bulkUpdateCandidates', () => {
-    it('should bulk update candidates successfully', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceCandidate.updateMany.mockResolvedValue({ count: 3 })
-
-      const result = await bulkUpdateCandidates(
-        ['candidate-1', 'candidate-2', 'candidate-3'],
-        'APPROVED'
-      )
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual({ count: 3 })
-      expect(mockPrisma.maintenanceCandidate.updateMany).toHaveBeenCalledWith({
-        where: {
-          id: { in: ['candidate-1', 'candidate-2', 'candidate-3'] },
-        },
-        data: {
-          reviewStatus: 'APPROVED',
-          reviewedAt: expect.any(Date),
-          reviewedBy: 'admin-1',
-        },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/admin/maintenance')
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(bulkUpdateCandidates(['candidate-1'], 'REJECTED')).rejects.toThrow(
-        'Unauthorized'
-      )
-    })
-  })
-
-  describe('getUserMediaMarks', () => {
-    it('should return user media marks without filters', async () => {
-      const mockMarks: Partial<UserMediaMark>[] = [
-        {
-          id: 'mark-1',
-          userId: 'user-1',
-          mediaType: 'MOVIE',
-          markType: 'FINISHED_WATCHING',
-          title: 'Test Movie',
-        },
-      ]
-
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findMany.mockResolvedValue(mockMarks as UserMediaMark[])
-
-      const result = await getUserMediaMarks()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockMarks)
-      expect(mockPrisma.userMediaMark.findMany).toHaveBeenCalledWith({
-        where: { userId: 'user-1' },
-        orderBy: { markedAt: 'desc' },
-      })
-    })
-
-    it('should filter marks by media type', async () => {
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findMany.mockResolvedValue([])
-
-      await getUserMediaMarks({ mediaType: 'TV_SERIES' })
-
-      expect(mockPrisma.userMediaMark.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: {
-            userId: 'user-1',
-            mediaType: 'TV_SERIES',
-          },
-        })
-      )
-    })
-
-    it('should filter marks by mark type', async () => {
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findMany.mockResolvedValue([])
-
-      await getUserMediaMarks({ markType: 'KEEP_FOREVER' })
-
-      expect(mockPrisma.userMediaMark.findMany).toHaveBeenCalledWith(
-        expect.objectContaining({
-          where: {
-            userId: 'user-1',
-            markType: 'KEEP_FOREVER',
-          },
-        })
-      )
-    })
-
-    it('should return error when not authenticated', async () => {
-      mockGetServerSession.mockResolvedValue(null)
-
-      const result = await getUserMediaMarks()
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Unauthorized')
-    })
-
-    it('should handle database errors', async () => {
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findMany.mockRejectedValue(new Error('DB error'))
-
-      const result = await getUserMediaMarks()
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('DB error')
-    })
-  })
-
-  describe('createUserMediaMark', () => {
-    const validInput = {
-      mediaType: 'MOVIE' as const,
-      plexRatingKey: '12345',
-      title: 'Test Movie',
-      year: 2024,
-      markType: 'FINISHED_WATCHING' as const,
-      note: 'Great movie',
-      markedVia: 'web',
-    }
-
-    it('should create user media mark successfully', async () => {
-      const mockCreated: Partial<UserMediaMark> = {
-        id: 'mark-1',
-        userId: 'user-1',
-        ...validInput,
-        markedAt: new Date(),
-      }
-
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findFirst.mockResolvedValue(null)
-      mockPrisma.userMediaMark.create.mockResolvedValue(mockCreated as UserMediaMark)
-
-      const result = await createUserMediaMark(validInput)
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual(mockCreated)
-      expect(mockPrisma.userMediaMark.create).toHaveBeenCalledWith({
-        data: {
-          userId: 'user-1',
-          mediaType: validInput.mediaType,
-          plexRatingKey: validInput.plexRatingKey,
-          radarrId: undefined,
-          sonarrId: undefined,
-          title: validInput.title,
-          year: validInput.year,
-          seasonNumber: undefined,
-          episodeNumber: undefined,
-          parentTitle: undefined,
-          markType: validInput.markType,
-          note: validInput.note,
-          markedVia: validInput.markedVia,
-          discordChannelId: undefined,
-        },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/media')
-    })
-
-    it('should return error when mark already exists', async () => {
-      const existingMark: Partial<UserMediaMark> = {
-        id: 'mark-1',
-        userId: 'user-1',
-        plexRatingKey: '12345',
-        markType: 'FINISHED_WATCHING',
-      }
-
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findFirst.mockResolvedValue(existingMark as UserMediaMark)
-
-      const result = await createUserMediaMark(validInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Mark already exists for this media')
-      expect(mockPrisma.userMediaMark.create).not.toHaveBeenCalled()
-    })
-
-    it('should return error when not authenticated', async () => {
-      mockGetServerSession.mockResolvedValue(null)
-
-      const result = await createUserMediaMark(validInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Unauthorized')
-    })
-
-    it('should return validation error for invalid input', async () => {
-      const invalidInput = { mediaType: 'INVALID', plexRatingKey: '', title: '' }
-
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-
-      const result = await createUserMediaMark(invalidInput)
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBeDefined()
-      expect(mockPrisma.userMediaMark.create).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('deleteUserMediaMark', () => {
-    it('should delete user media mark successfully', async () => {
-      const mockMark: Partial<UserMediaMark> = { id: 'mark-1', userId: 'user-1' }
-
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findUnique.mockResolvedValue(mockMark as UserMediaMark)
-      mockPrisma.userMediaMark.delete.mockResolvedValue(mockMark as UserMediaMark)
-
-      const result = await deleteUserMediaMark('mark-1')
-
-      expect(result.success).toBe(true)
-      expect(mockPrisma.userMediaMark.delete).toHaveBeenCalledWith({
-        where: { id: 'mark-1' },
-      })
-      expect(mockRevalidatePath).toHaveBeenCalledWith('/media')
-    })
-
-    it('should return error when mark not found', async () => {
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findUnique.mockResolvedValue(null)
-
-      const result = await deleteUserMediaMark('nonexistent')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Mark not found')
-      expect(mockPrisma.userMediaMark.delete).not.toHaveBeenCalled()
-    })
-
-    it('should return error when mark belongs to different user', async () => {
-      const mockMark: Partial<UserMediaMark> = { id: 'mark-1', userId: 'other-user' }
-
-      mockGetServerSession.mockResolvedValue(mockUserSession as Session)
-      mockPrisma.userMediaMark.findUnique.mockResolvedValue(mockMark as UserMediaMark)
-
-      const result = await deleteUserMediaMark('mark-1')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Unauthorized to delete this mark')
-      expect(mockPrisma.userMediaMark.delete).not.toHaveBeenCalled()
-    })
-
-    it('should return error when not authenticated', async () => {
-      mockGetServerSession.mockResolvedValue(null)
-
-      const result = await deleteUserMediaMark('mark-1')
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('Unauthorized')
-    })
-  })
-
-  describe('getMaintenanceStats', () => {
-    it('should return maintenance statistics successfully', async () => {
-      const mockRecentScans: Partial<MaintenanceScan>[] = [
-        {
-          id: 'scan-1',
-          status: 'COMPLETED',
-          completedAt: new Date(),
-          rule: { id: 'rule-1', name: 'Test Rule' },
-        },
-      ]
-
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.count
-        .mockResolvedValueOnce(10) // totalRules
-        .mockResolvedValueOnce(7) // enabledRules
-      mockPrisma.maintenanceCandidate.count
-        .mockResolvedValueOnce(50) // totalCandidates
-        .mockResolvedValueOnce(30) // pendingCandidates
-        .mockResolvedValueOnce(15) // approvedCandidates
-        .mockResolvedValueOnce(5) // rejectedCandidates
-      mockPrisma.maintenanceScan.findMany.mockResolvedValue(mockRecentScans as MaintenanceScan[])
-      mockPrisma.maintenanceDeletionLog.count.mockResolvedValue(100)
-
-      const result = await getMaintenanceStats()
-
-      expect(result.success).toBe(true)
-      expect(result.data).toEqual({
-        rules: {
-          total: 10,
-          enabled: 7,
-          disabled: 3,
-        },
-        candidates: {
-          total: 50,
-          pending: 30,
-          approved: 15,
-          rejected: 5,
-        },
-        recentScans: mockRecentScans,
-        totalDeletions: 100,
-      })
-    })
-
-    it('should require admin access', async () => {
-      mockRequireAdmin.mockRejectedValue(new Error('Unauthorized'))
-
-      await expect(getMaintenanceStats()).rejects.toThrow('Unauthorized')
-    })
-
-    it('should handle database errors', async () => {
-      mockRequireAdmin.mockResolvedValue(mockAdminSession as Session)
-      mockPrisma.maintenanceRule.count.mockRejectedValue(new Error('DB error'))
-
-      const result = await getMaintenanceStats()
-
-      expect(result.success).toBe(false)
-      expect(result.error).toBe('DB error')
-    })
-  })
-})
diff --git a/actions/maintenance.ts b/actions/maintenance.ts
deleted file mode 100644
index be35a70d..00000000
--- a/actions/maintenance.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Re-export all maintenance actions for backwards compatibility
- *
- * This file has been split into separate modules:
- * - maintenance/rules.ts: Rule CRUD operations
- * - maintenance/candidates.ts: Candidate management
- * - maintenance/operations.ts: Scan and deletion triggers
- * - maintenance/user-marks.ts: User media marks
- * - maintenance/stats.ts: Statistics and history
- */
-
-export * from "./maintenance/index"
diff --git a/actions/maintenance/candidates.ts b/actions/maintenance/candidates.ts
deleted file mode 100644
index 18cf3107..00000000
--- a/actions/maintenance/candidates.ts
+++ /dev/null
@@ -1,188 +0,0 @@
-"use server"
-
-import { requireAdmin } from "@/lib/admin"
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import {
-  CandidatePaginationSchema,
-  ReviewStatusEnum,
-  type ReviewStatus,
-  type MediaType,
-} from "@/lib/validations/maintenance"
-import { bulkIdsSchema } from "@/lib/validations/shared-schemas"
-import { z } from "zod"
-import type { PaginatedCandidatesResponse } from "@/types/maintenance"
-import { revalidatePath } from "next/cache"
-
-const logger = createLogger("MAINTENANCE-CANDIDATES")
-
-/**
- * Get maintenance candidates with optional filters and pagination (admin only)
- */
-export async function getMaintenanceCandidates(params?: {
-  page?: number
-  pageSize?: number
-  reviewStatus?: ReviewStatus
-  mediaType?: MediaType
-  scanId?: string
-}): Promise<{ success: true; data: PaginatedCandidatesResponse } | { success: false; error: string }> {
-  await requireAdmin()
-
-  try {
-    // Parse and validate pagination parameters
-    const validated = CandidatePaginationSchema.parse({
-      page: params?.page ?? 1,
-      pageSize: params?.pageSize ?? 25,
-      reviewStatus: params?.reviewStatus,
-      mediaType: params?.mediaType,
-      scanId: params?.scanId,
-    })
-
-    const { page, pageSize, reviewStatus, mediaType, scanId } = validated
-
-    const where: {
-      reviewStatus?: ReviewStatus
-      mediaType?: MediaType
-      scanId?: string
-    } = {}
-
-    if (reviewStatus) {
-      where.reviewStatus = reviewStatus
-    }
-    if (mediaType) {
-      where.mediaType = mediaType
-    }
-    if (scanId) {
-      where.scanId = scanId
-    }
-
-    // Get total count and candidates in parallel
-    const [totalCount, candidates] = await Promise.all([
-      prisma.maintenanceCandidate.count({ where }),
-      prisma.maintenanceCandidate.findMany({
-        where,
-        orderBy: { flaggedAt: "desc" },
-        skip: (page - 1) * pageSize,
-        take: pageSize,
-        include: {
-          scan: {
-            include: {
-              rule: {
-                select: {
-                  id: true,
-                  name: true,
-                  actionType: true,
-                },
-              },
-            },
-          },
-        },
-      }),
-    ])
-
-    const totalPages = Math.ceil(totalCount / pageSize)
-
-    return {
-      success: true,
-      data: {
-        candidates,
-        pagination: {
-          page,
-          pageSize,
-          totalCount,
-          totalPages,
-          hasNextPage: page < totalPages,
-          hasPreviousPage: page > 1,
-        },
-      },
-    }
-  } catch (error) {
-    logger.error("Error fetching maintenance candidates", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch maintenance candidates",
-    }
-  }
-}
-
-/**
- * Update candidate review status (admin only)
- */
-export async function updateCandidateReviewStatus(
-  candidateId: string,
-  status: ReviewStatus,
-  note?: string
-) {
-  const session = await requireAdmin()
-
-  try {
-    const candidate = await prisma.maintenanceCandidate.update({
-      where: { id: candidateId },
-      data: {
-        reviewStatus: status,
-        reviewedAt: new Date(),
-        reviewedBy: session.user.id,
-        reviewNote: note,
-      },
-    })
-
-    revalidatePath("/admin/maintenance")
-    return { success: true, data: candidate }
-  } catch (error) {
-    logger.error("Error updating candidate review status", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to update candidate review status",
-    }
-  }
-}
-
-// Schema for bulkUpdateCandidates parameters
-const bulkUpdateCandidatesSchema = z.object({
-  candidateIds: bulkIdsSchema,
-  reviewStatus: ReviewStatusEnum,
-})
-
-/**
- * Bulk update candidates review status (admin only)
- */
-export async function bulkUpdateCandidates(candidateIds: string[], reviewStatus: ReviewStatus) {
-  const session = await requireAdmin()
-
-  // Validate input parameters
-  const validated = bulkUpdateCandidatesSchema.safeParse({ candidateIds, reviewStatus })
-
-  if (!validated.success) {
-    logger.warn("Invalid bulkUpdateCandidates parameters", {
-      errors: validated.error.issues,
-    })
-    return {
-      success: false,
-      error: validated.error.issues[0]?.message || "Invalid parameters",
-    }
-  }
-
-  const { candidateIds: validIds, reviewStatus: validStatus } = validated.data
-
-  try {
-    const result = await prisma.maintenanceCandidate.updateMany({
-      where: {
-        id: { in: validIds },
-      },
-      data: {
-        reviewStatus: validStatus,
-        reviewedAt: new Date(),
-        reviewedBy: session.user.id,
-      },
-    })
-
-    revalidatePath("/admin/maintenance")
-    return { success: true, data: { count: result.count } }
-  } catch (error) {
-    logger.error("Error bulk updating candidates", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to bulk update candidates",
-    }
-  }
-}
diff --git a/actions/maintenance/index.ts b/actions/maintenance/index.ts
deleted file mode 100644
index f5332f45..00000000
--- a/actions/maintenance/index.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-/**
- * Maintenance actions module
- *
- * This module has been split into separate files for better organization:
- * - rules.ts: Rule CRUD operations
- * - candidates.ts: Candidate management
- * - operations.ts: Scan and deletion triggers
- * - user-marks.ts: User media marks
- * - stats.ts: Statistics and history
- */
-
-// Rule management
-export {
-  getMaintenanceRules,
-  createMaintenanceRule,
-  updateMaintenanceRule,
-  deleteMaintenanceRule,
-  toggleMaintenanceRule,
-} from "./rules"
-
-// Candidate management
-export {
-  getMaintenanceCandidates,
-  updateCandidateReviewStatus,
-  bulkUpdateCandidates,
-} from "./candidates"
-
-// Scan and deletion operations have been removed (BullMQ removal)
-// TODO: These operations need to be redesigned without queue-based processing
-
-// User media marks
-export {
-  getUserMediaMarks,
-  createUserMediaMark,
-  deleteUserMediaMark,
-} from "./user-marks"
-
-// Statistics and history
-export {
-  getMaintenanceStats,
-  getDeletionHistory,
-  getDeletionStats,
-} from "./stats"
diff --git a/actions/maintenance/operations.ts b/actions/maintenance/operations.ts
deleted file mode 100644
index d7e098af..00000000
--- a/actions/maintenance/operations.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-"use server"
-
-// This file previously contained queue-based operations (triggerManualScan, triggerDeletion)
-// which have been removed as part of the BullMQ removal.
-// The maintenance scanning and deletion functionality needs to be redesigned.
-// For now, maintenance operations are not available.
-
-export {}
diff --git a/actions/maintenance/rules.ts b/actions/maintenance/rules.ts
deleted file mode 100644
index 06106b63..00000000
--- a/actions/maintenance/rules.ts
+++ /dev/null
@@ -1,214 +0,0 @@
-"use server"
-
-import { requireAdmin } from "@/lib/admin"
-import { prisma } from "@/lib/prisma"
-import { Prisma } from "@/lib/generated/prisma/client"
-import { createLogger } from "@/lib/utils/logger"
-import {
-  CreateMaintenanceRuleSchema,
-  UpdateMaintenanceRuleSchema,
-} from "@/lib/validations/maintenance"
-import { revalidatePath } from "next/cache"
-
-const logger = createLogger("MAINTENANCE-RULES")
-
-/**
- * Get all maintenance rules with scan counts (admin only)
- *
- * Performance Note (Issue #39):
- * This query uses Prisma's `include` with nested relations. Performance profiling
- * shows Prisma optimizes this into just 2 queries internally (no N+1 issue):
- * - 100 rules, 1000 scans: ~6ms avg
- * - 500 rules, 25000 scans: ~77ms avg
- *
- * Well under the 1s threshold. See scripts/profile-maintenance-query.ts for profiling.
- */
-export async function getMaintenanceRules() {
-  await requireAdmin()
-
-  try {
-    const rules = await prisma.maintenanceRule.findMany({
-      orderBy: { createdAt: "desc" },
-      include: {
-        scans: {
-          orderBy: { createdAt: "desc" },
-          take: 1,
-          select: {
-            id: true,
-            status: true,
-            itemsScanned: true,
-            itemsFlagged: true,
-            completedAt: true,
-          },
-        },
-        _count: {
-          select: {
-            scans: true,
-          },
-        },
-      },
-    })
-
-    return { success: true, data: rules }
-  } catch (error) {
-    logger.error("Error fetching maintenance rules", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch maintenance rules",
-    }
-  }
-}
-
-/**
- * Get a single maintenance rule by ID (admin only)
- */
-export async function getMaintenanceRule(id: string) {
-  await requireAdmin()
-
-  try {
-    const rule = await prisma.maintenanceRule.findUnique({
-      where: { id },
-      include: {
-        scans: {
-          orderBy: { createdAt: "desc" },
-          take: 1,
-          select: {
-            id: true,
-            status: true,
-            itemsScanned: true,
-            itemsFlagged: true,
-            completedAt: true,
-          },
-        },
-        _count: {
-          select: {
-            scans: true,
-          },
-        },
-      },
-    })
-
-    if (!rule) {
-      return { success: false, error: "Rule not found" }
-    }
-
-    return { success: true, data: rule }
-  } catch (error) {
-    logger.error("Error fetching maintenance rule", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch maintenance rule",
-    }
-  }
-}
-
-/**
- * Create new maintenance rule (admin only)
- */
-export async function createMaintenanceRule(data: unknown) {
-  await requireAdmin()
-
-  try {
-    const validated = CreateMaintenanceRuleSchema.parse(data)
-
-    const rule = await prisma.maintenanceRule.create({
-      data: {
-        name: validated.name,
-        description: validated.description,
-        enabled: validated.enabled,
-        mediaType: validated.mediaType,
-        criteria: validated.criteria as unknown as Prisma.InputJsonValue,
-        actionType: validated.actionType,
-        schedule: validated.schedule,
-      },
-    })
-
-    revalidatePath("/admin/maintenance")
-    return { success: true, data: rule }
-  } catch (error) {
-    logger.error("Error creating maintenance rule", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to create maintenance rule",
-    }
-  }
-}
-
-/**
- * Update maintenance rule (admin only)
- */
-export async function updateMaintenanceRule(id: string, data: unknown) {
-  await requireAdmin()
-
-  try {
-    const validated = UpdateMaintenanceRuleSchema.parse(data)
-
-    const rule = await prisma.maintenanceRule.update({
-      where: { id },
-      data: {
-        name: validated.name,
-        description: validated.description,
-        enabled: validated.enabled,
-        mediaType: validated.mediaType,
-        criteria: validated.criteria as unknown as Prisma.InputJsonValue | undefined,
-        actionType: validated.actionType,
-        schedule: validated.schedule,
-      },
-    })
-
-    revalidatePath("/admin/maintenance")
-    return { success: true, data: rule }
-  } catch (error) {
-    logger.error("Error updating maintenance rule", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to update maintenance rule",
-    }
-  }
-}
-
-/**
- * Delete maintenance rule (admin only)
- * Cascades to delete related scans and candidates
- */
-export async function deleteMaintenanceRule(id: string) {
-  await requireAdmin()
-
-  try {
-    await prisma.maintenanceRule.delete({
-      where: { id },
-    })
-
-    revalidatePath("/admin/maintenance")
-    return { success: true }
-  } catch (error) {
-    logger.error("Error deleting maintenance rule", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to delete maintenance rule",
-    }
-  }
-}
-
-/**
- * Toggle maintenance rule enabled status (admin only)
- */
-export async function toggleMaintenanceRule(id: string, enabled: boolean) {
-  await requireAdmin()
-
-  try {
-    const rule = await prisma.maintenanceRule.update({
-      where: { id },
-      data: { enabled },
-    })
-
-    revalidatePath("/admin/maintenance")
-    return { success: true, data: rule }
-  } catch (error) {
-    logger.error("Error toggling maintenance rule", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to toggle maintenance rule",
-    }
-  }
-}
diff --git a/actions/maintenance/stats.ts b/actions/maintenance/stats.ts
deleted file mode 100644
index 04a1ec99..00000000
--- a/actions/maintenance/stats.ts
+++ /dev/null
@@ -1,247 +0,0 @@
-"use server"
-
-import { requireAdmin } from "@/lib/admin"
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import { type MediaType } from "@/lib/validations/maintenance"
-
-const logger = createLogger("MAINTENANCE-STATS")
-
-/**
- * Get maintenance overview statistics (admin only)
- */
-export async function getMaintenanceStats() {
-  await requireAdmin()
-
-  try {
-    const [
-      totalRules,
-      enabledRules,
-      totalCandidates,
-      pendingCandidates,
-      approvedCandidates,
-      rejectedCandidates,
-      recentScans,
-      totalDeletions,
-    ] = await Promise.all([
-      prisma.maintenanceRule.count(),
-      prisma.maintenanceRule.count({ where: { enabled: true } }),
-      prisma.maintenanceCandidate.count(),
-      prisma.maintenanceCandidate.count({ where: { reviewStatus: "PENDING" } }),
-      prisma.maintenanceCandidate.count({ where: { reviewStatus: "APPROVED" } }),
-      prisma.maintenanceCandidate.count({ where: { reviewStatus: "REJECTED" } }),
-      prisma.maintenanceScan.findMany({
-        where: { status: "COMPLETED" },
-        orderBy: { completedAt: "desc" },
-        take: 5,
-        include: {
-          rule: {
-            select: {
-              id: true,
-              name: true,
-            },
-          },
-        },
-      }),
-      prisma.maintenanceDeletionLog.count(),
-    ])
-
-    return {
-      success: true,
-      data: {
-        rules: {
-          total: totalRules,
-          enabled: enabledRules,
-          disabled: totalRules - enabledRules,
-        },
-        candidates: {
-          total: totalCandidates,
-          pending: pendingCandidates,
-          approved: approvedCandidates,
-          rejected: rejectedCandidates,
-        },
-        recentScans,
-        totalDeletions,
-      },
-    }
-  } catch (error) {
-    logger.error("Error fetching maintenance stats", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch maintenance stats",
-    }
-  }
-}
-
-/**
- * Get deletion history with optional filters and pagination (admin only)
- */
-export async function getDeletionHistory(filters?: {
-  mediaType?: MediaType
-  deletedBy?: string
-  filesDeleted?: boolean
-  startDate?: Date
-  endDate?: Date
-  page?: number
-  pageSize?: number
-}) {
-  await requireAdmin()
-
-  try {
-    const page = filters?.page || 1
-    const pageSize = filters?.pageSize || 50
-    const skip = (page - 1) * pageSize
-
-    const where: {
-      mediaType?: MediaType
-      deletedBy?: string
-      filesDeleted?: boolean
-      deletedAt?: {
-        gte?: Date
-        lte?: Date
-      }
-    } = {}
-
-    if (filters?.mediaType) {
-      where.mediaType = filters.mediaType
-    }
-    if (filters?.deletedBy) {
-      where.deletedBy = filters.deletedBy
-    }
-    if (filters?.filesDeleted !== undefined) {
-      where.filesDeleted = filters.filesDeleted
-    }
-    if (filters?.startDate || filters?.endDate) {
-      where.deletedAt = {}
-      if (filters.startDate) {
-        where.deletedAt.gte = filters.startDate
-      }
-      if (filters.endDate) {
-        where.deletedAt.lte = filters.endDate
-      }
-    }
-
-    const [deletions, total] = await Promise.all([
-      prisma.maintenanceDeletionLog.findMany({
-        where,
-        orderBy: { deletedAt: "desc" },
-        skip,
-        take: pageSize,
-      }),
-      prisma.maintenanceDeletionLog.count({ where }),
-    ])
-
-    return {
-      success: true,
-      data: {
-        deletions,
-        pagination: {
-          page,
-          pageSize,
-          total,
-          totalPages: Math.ceil(total / pageSize),
-        },
-      },
-    }
-  } catch (error) {
-    logger.error("Error fetching deletion history", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch deletion history",
-    }
-  }
-}
-
-/**
- * Get deletion statistics (admin only)
- */
-export async function getDeletionStats(filters?: {
-  startDate?: Date
-  endDate?: Date
-}) {
-  await requireAdmin()
-
-  try {
-    const where: {
-      deletedAt?: {
-        gte?: Date
-        lte?: Date
-      }
-    } = {}
-
-    if (filters?.startDate || filters?.endDate) {
-      where.deletedAt = {}
-      if (filters.startDate) {
-        where.deletedAt.gte = filters.startDate
-      }
-      if (filters.endDate) {
-        where.deletedAt.lte = filters.endDate
-      }
-    }
-
-    const [totalDeletions, deletions, deletionsByMediaType, deletionsByUser] = await Promise.all([
-      prisma.maintenanceDeletionLog.count({ where }),
-      prisma.maintenanceDeletionLog.findMany({
-        where,
-        select: {
-          fileSize: true,
-          filesDeleted: true,
-          deletedAt: true,
-        },
-      }),
-      prisma.maintenanceDeletionLog.groupBy({
-        by: ["mediaType"],
-        where,
-        _count: {
-          id: true,
-        },
-      }),
-      prisma.maintenanceDeletionLog.groupBy({
-        by: ["deletedBy"],
-        where,
-        _count: {
-          id: true,
-        },
-      }),
-    ])
-
-    // Calculate total space reclaimed
-    const totalSpaceReclaimed = deletions.reduce((acc, deletion) => {
-      return acc + (deletion.fileSize ? Number(deletion.fileSize) : 0)
-    }, 0)
-
-    // Count files actually deleted vs just removed from Plex
-    const filesActuallyDeleted = deletions.filter((d) => d.filesDeleted).length
-
-    // Get deletions this month
-    const now = new Date()
-    const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1)
-    const deletionsThisMonth = deletions.filter(
-      (d) => d.deletedAt >= startOfMonth
-    ).length
-
-    return {
-      success: true,
-      data: {
-        totalDeletions,
-        totalSpaceReclaimed,
-        filesActuallyDeleted,
-        deletionsThisMonth,
-        byMediaType: deletionsByMediaType.map((item) => ({
-          mediaType: item.mediaType,
-          count: item._count.id,
-        })),
-        byUser: deletionsByUser.map((item) => ({
-          userId: item.deletedBy,
-          count: item._count.id,
-        })),
-      },
-    }
-  } catch (error) {
-    logger.error("Error fetching deletion stats", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch deletion stats",
-    }
-  }
-}
diff --git a/actions/user-feedback.ts b/actions/user-feedback.ts
deleted file mode 100644
index 4208851f..00000000
--- a/actions/user-feedback.ts
+++ /dev/null
@@ -1,569 +0,0 @@
-"use server"
-
-import { requireAdmin } from "@/lib/admin"
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import { MediaType, MarkType } from "@/lib/validations/maintenance"
-import { getRadarrMovieById } from "@/lib/connections/radarr"
-import { getSonarrSeriesById } from "@/lib/connections/sonarr"
-import { getPlexServerIdentity } from "@/lib/connections/plex"
-
-const logger = createLogger("USER_FEEDBACK")
-
-export interface MediaMarkSummary {
-  plexRatingKey: string
-  mediaType: MediaType
-  title: string
-  year: number | null
-  markCounts: {
-    FINISHED_WATCHING: number
-    NOT_INTERESTED: number
-    KEEP_FOREVER: number
-    REWATCH_CANDIDATE: number
-    POOR_QUALITY: number
-    WRONG_VERSION: number
-  }
-  uniqueUserCount: number
-  deletionScore: number
-  totalFileSize: bigint | null
-  radarrId: number | null
-  sonarrId: number | null
-}
-
-export interface UserFeedbackFilters {
-  markType?: MarkType
-  mediaType?: MediaType
-  minUserCount?: number
-  sortBy?: "deletionScore" | "userCount" | "fileSize" | "date"
-  sortOrder?: "asc" | "desc"
-}
-
-export interface MediaMarkDetail {
-  id: string
-  userId: string
-  userName: string | null
-  userEmail: string | null
-  title: string
-  parentTitle: string | null
-  markType: MarkType
-  note: string | null
-  markedAt: Date
-  markedVia: string
-}
-
-export interface MediaDetails {
-  plexRatingKey: string
-  mediaType: MediaType
-  title: string
-  year: number | null
-  radarrId: number | null
-  sonarrId: number | null
-  marks: MediaMarkDetail[]
-  watchStats: {
-    totalPlays: number
-    lastWatched: Date | null
-    uniqueViewers: number
-  } | null
-  fileInfo: {
-    size: bigint | null
-    path: string | null
-    quality: string | null
-  } | null
-  deletionScore: number
-  recommendation: "delete" | "review" | "keep"
-  externalLinks: {
-    plex: string | null
-    tautulli: string | null
-    radarr: string | null
-    sonarr: string | null
-  }
-}
-
-/**
- * Calculate deletion score based on user marks
- * Higher score = more likely should be deleted
- */
-function calculateDeletionScore(markCounts: MediaMarkSummary["markCounts"], uniqueUserCount: number): number {
-  let score = 0
-
-  // Strong deletion indicators
-  score += markCounts.FINISHED_WATCHING * 3
-  score += markCounts.NOT_INTERESTED * 4
-  score += markCounts.POOR_QUALITY * 5
-  score += markCounts.WRONG_VERSION * 4
-
-  // Keep indicators (negative score)
-  score -= markCounts.KEEP_FOREVER * 10
-  score -= markCounts.REWATCH_CANDIDATE * 2
-
-  // Factor in number of users - more consensus = higher confidence
-  const userMultiplier = Math.min(uniqueUserCount / 5, 2) // Cap at 2x for 5+ users
-
-  return Math.max(0, Math.round(score * userMultiplier))
-}
-
-/**
- * Get aggregated user feedback summary
- */
-export async function getUserFeedbackSummary(filters?: UserFeedbackFilters) {
-  await requireAdmin()
-
-  try {
-    // Build where clause
-    const where: {
-      markType?: MarkType
-      mediaType?: MediaType
-    } = {}
-
-    if (filters?.markType) {
-      where.markType = filters.markType
-    }
-    if (filters?.mediaType) {
-      where.mediaType = filters.mediaType
-    }
-
-    // Get all marks grouped by media
-    const marks = await prisma.userMediaMark.groupBy({
-      by: ["plexRatingKey", "mediaType", "title", "year", "radarrId", "sonarrId"],
-      where,
-      _count: {
-        markType: true,
-      },
-    })
-
-    // For each unique media, get detailed mark counts
-    const summaries: MediaMarkSummary[] = []
-
-    for (const mark of marks) {
-      const markDetails = await prisma.userMediaMark.groupBy({
-        by: ["markType"],
-        where: {
-          plexRatingKey: mark.plexRatingKey,
-        },
-        _count: {
-          userId: true,
-        },
-      })
-
-      const uniqueUsers = await prisma.userMediaMark.findMany({
-        where: {
-          plexRatingKey: mark.plexRatingKey,
-        },
-        distinct: ["userId"],
-        select: {
-          userId: true,
-        },
-      })
-
-      const markCounts = {
-        FINISHED_WATCHING: 0,
-        NOT_INTERESTED: 0,
-        KEEP_FOREVER: 0,
-        REWATCH_CANDIDATE: 0,
-        POOR_QUALITY: 0,
-        WRONG_VERSION: 0,
-      }
-
-      markDetails.forEach((detail) => {
-        markCounts[detail.markType] = detail._count.userId
-      })
-
-      const uniqueUserCount = uniqueUsers.length
-      const deletionScore = calculateDeletionScore(markCounts, uniqueUserCount)
-
-      // Skip if below minimum user count filter
-      if (filters?.minUserCount && uniqueUserCount < filters.minUserCount) {
-        continue
-      }
-
-      summaries.push({
-        plexRatingKey: mark.plexRatingKey,
-        mediaType: mark.mediaType,
-        title: mark.title,
-        year: mark.year,
-        markCounts,
-        uniqueUserCount,
-        deletionScore,
-        totalFileSize: null, // Will be fetched from Radarr/Sonarr if needed
-        radarrId: mark.radarrId,
-        sonarrId: mark.sonarrId,
-      })
-    }
-
-    // Apply sorting
-    const sortBy = filters?.sortBy || "deletionScore"
-    const sortOrder = filters?.sortOrder || "desc"
-
-    summaries.sort((a, b) => {
-      let compareValue = 0
-
-      switch (sortBy) {
-        case "deletionScore":
-          compareValue = a.deletionScore - b.deletionScore
-          break
-        case "userCount":
-          compareValue = a.uniqueUserCount - b.uniqueUserCount
-          break
-        case "fileSize":
-          compareValue = Number(a.totalFileSize || 0) - Number(b.totalFileSize || 0)
-          break
-        case "date":
-          // Sort by title as proxy for date (would need to fetch from Plex for actual date)
-          compareValue = a.title.localeCompare(b.title)
-          break
-      }
-
-      return sortOrder === "desc" ? -compareValue : compareValue
-    })
-
-    return { success: true, data: summaries }
-  } catch (error) {
-    logger.error("Error fetching user feedback summary", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch user feedback summary",
-    }
-  }
-}
-
-/**
- * Get detailed user marks for specific media
- */
-export async function getMediaMarkDetails(ratingKey: string) {
-  await requireAdmin()
-
-  try {
-    // Get all marks for this media with user information
-    const marks = await prisma.userMediaMark.findMany({
-      where: {
-        plexRatingKey: ratingKey,
-      },
-      include: {
-        user: {
-          select: {
-            id: true,
-            name: true,
-            email: true,
-          },
-        },
-      },
-      orderBy: {
-        markedAt: "desc",
-      },
-    })
-
-    if (marks.length === 0) {
-      return { success: false, error: "No marks found for this media" }
-    }
-
-    const firstMark = marks[0]
-
-    // Calculate mark counts for deletion score
-    const markCounts = {
-      FINISHED_WATCHING: 0,
-      NOT_INTERESTED: 0,
-      KEEP_FOREVER: 0,
-      REWATCH_CANDIDATE: 0,
-      POOR_QUALITY: 0,
-      WRONG_VERSION: 0,
-    }
-
-    marks.forEach((mark) => {
-      markCounts[mark.markType]++
-    })
-
-    const uniqueUsers = new Set(marks.map((m) => m.userId))
-    const deletionScore = calculateDeletionScore(markCounts, uniqueUsers.size)
-
-    // Fetch server configurations and build external links
-    const plexServer = await prisma.plexServer.findFirst({ where: { isActive: true } })
-    const tautulliServer = await prisma.tautulli.findFirst({ where: { isActive: true } })
-    const radarrServer = await prisma.radarr.findFirst({ where: { isActive: true } })
-    const sonarrServer = await prisma.sonarr.findFirst({ where: { isActive: true } })
-
-    // Get Plex machine identifier for web URL
-    let plexUrl: string | null = null
-    if (plexServer) {
-      const identityResult = await getPlexServerIdentity({
-        url: plexServer.url,
-        token: plexServer.token,
-      })
-
-      if (identityResult.success && identityResult.machineIdentifier) {
-        plexUrl = `${plexServer.publicUrl || plexServer.url}/web/index.html#!/server/${identityResult.machineIdentifier}/details?key=%2Flibrary%2Fmetadata%2F${ratingKey}`
-      } else {
-        logger.warn("Failed to get Plex machine identifier", { error: identityResult.error })
-      }
-    }
-
-    const externalLinks = {
-      plex: plexUrl,
-      tautulli: tautulliServer ? `${tautulliServer.url}/info?rating_key=${ratingKey}` : null,
-      radarr: firstMark.radarrTitleSlug && radarrServer ? `${radarrServer.url}/movie/${firstMark.radarrTitleSlug}` : null,
-      sonarr: firstMark.sonarrTitleSlug && sonarrServer ? `${sonarrServer.url}/series/${firstMark.sonarrTitleSlug}` : null,
-    }
-
-    // Fetch watch statistics from Tautulli if available
-    let watchStats: MediaDetails["watchStats"] = null
-    try {
-      if (tautulliServer) {
-        // Use get_metadata for accurate play count and last watched
-        const metadataUrl = `${tautulliServer.url}/api/v2?apikey=${tautulliServer.apiKey}&cmd=get_metadata&rating_key=${ratingKey}`
-        const metadataResponse = await fetch(metadataUrl)
-
-        if (metadataResponse.ok) {
-          const metadata = await metadataResponse.json()
-
-          if (metadata?.response?.result === "success") {
-            const data = metadata.response.data
-            watchStats = {
-              totalPlays: data.play_count || 0,
-              lastWatched: data.last_played ? new Date(data.last_played * 1000) : null,
-              uniqueViewers: data.user_count || 0,
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger.warn("Failed to fetch Tautulli watch stats", { ratingKey, error })
-    }
-
-    // Fetch file info from Radarr/Sonarr if available
-    let fileInfo: MediaDetails["fileInfo"] = null
-    try {
-      if (firstMark.mediaType === "MOVIE" && firstMark.radarrId) {
-        const radarrServer = await prisma.radarr.findFirst({
-          where: { isActive: true },
-        })
-
-        if (radarrServer) {
-          const movieResult = await getRadarrMovieById(
-            { name: radarrServer.name, url: radarrServer.url, apiKey: radarrServer.apiKey },
-            firstMark.radarrId
-          )
-          if (movieResult.success) {
-            const movie = movieResult.data as any
-            if (movie?.movieFile) {
-              fileInfo = {
-                size: BigInt(movie.movieFile.size || 0),
-                path: movie.movieFile.path || null,
-                quality: movie.movieFile.quality?.quality?.name || null,
-              }
-            }
-          }
-        }
-      } else if (firstMark.mediaType === "TV_SERIES" && firstMark.sonarrId) {
-        const sonarrServer = await prisma.sonarr.findFirst({
-          where: { isActive: true },
-        })
-
-        if (sonarrServer) {
-          const seriesResult = await getSonarrSeriesById(
-            { name: sonarrServer.name, url: sonarrServer.url, apiKey: sonarrServer.apiKey },
-            firstMark.sonarrId
-          )
-          if (seriesResult.success) {
-            const series = seriesResult.data as any
-            if (series) {
-              const totalSize = series.statistics?.sizeOnDisk || 0
-              fileInfo = {
-                size: BigInt(totalSize),
-                path: series.path || null,
-                quality: null, // Series don't have a single quality
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      logger.warn("Failed to fetch file info", { ratingKey, error })
-    }
-
-    // Calculate recommendation
-    let recommendation: MediaDetails["recommendation"] = "review"
-    if (markCounts.KEEP_FOREVER > 0) {
-      recommendation = "keep"
-    } else if (deletionScore >= 15) {
-      recommendation = "delete"
-    } else if (deletionScore >= 8) {
-      recommendation = "review"
-    } else {
-      recommendation = "keep"
-    }
-
-    const details: MediaDetails = {
-      plexRatingKey: ratingKey,
-      mediaType: firstMark.mediaType,
-      title: firstMark.title,
-      year: firstMark.year,
-      radarrId: firstMark.radarrId,
-      sonarrId: firstMark.sonarrId,
-      marks: marks.map((mark) => ({
-        id: mark.id,
-        userId: mark.userId,
-        userName: mark.user.name,
-        userEmail: mark.user.email,
-        title: mark.title,
-        parentTitle: mark.parentTitle,
-        markType: mark.markType,
-        note: mark.note,
-        markedAt: mark.markedAt,
-        markedVia: mark.markedVia,
-      })),
-      watchStats,
-      fileInfo,
-      deletionScore,
-      recommendation,
-      externalLinks,
-    }
-
-    return { success: true, data: details }
-  } catch (error) {
-    logger.error("Error fetching media mark details", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to fetch media mark details",
-    }
-  }
-}
-
-/**
- * Add media to deletion candidates (ignoring user feedback for automated rules)
- */
-export async function addMediaToDeletionQueue(ratingKey: string, note?: string) {
-  const session = await requireAdmin()
-
-  try {
-    // Get media details
-    const marks = await prisma.userMediaMark.findMany({
-      where: {
-        plexRatingKey: ratingKey,
-      },
-      take: 1,
-    })
-
-    if (marks.length === 0) {
-      return { success: false, error: "Media not found" }
-    }
-
-    const media = marks[0]
-
-    // Create a manual maintenance scan
-    const scan = await prisma.maintenanceScan.create({
-      data: {
-        rule: {
-          connectOrCreate: {
-            where: {
-              id: "user-feedback-manual",
-            },
-            create: {
-              id: "user-feedback-manual",
-              name: "User Feedback Manual Review",
-              description: "Manually flagged items from user feedback",
-              enabled: true,
-              mediaType: media.mediaType,
-              criteria: {},
-              actionType: "FLAG_FOR_REVIEW",
-            },
-          },
-        },
-        status: "COMPLETED",
-        startedAt: new Date(),
-        completedAt: new Date(),
-        itemsScanned: 1,
-        itemsFlagged: 1,
-      },
-    })
-
-    // Create maintenance candidate
-    const candidate = await prisma.maintenanceCandidate.create({
-      data: {
-        scanId: scan.id,
-        mediaType: media.mediaType,
-        plexRatingKey: media.plexRatingKey,
-        radarrId: media.radarrId,
-        sonarrId: media.sonarrId,
-        title: media.title,
-        year: media.year,
-        matchedRules: {
-          source: "user_feedback",
-          note: note || "Added from user feedback review",
-        },
-        reviewStatus: "PENDING",
-      },
-    })
-
-    logger.info("Media added to deletion queue from user feedback", {
-      ratingKey,
-      candidateId: candidate.id,
-      userId: session.user.id,
-    })
-
-    return { success: true, data: candidate }
-  } catch (error) {
-    logger.error("Error adding media to deletion queue", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to add media to deletion queue",
-    }
-  }
-}
-
-/**
- * Ignore media forever (prevent from appearing in recommendations)
- */
-export async function ignoreMediaForever(ratingKey: string) {
-  const session = await requireAdmin()
-
-  try {
-    // Add a system mark to indicate this should be kept forever
-    // This is different from user marks - it's an admin decision
-    const mark = await prisma.userMediaMark.findFirst({
-      where: {
-        plexRatingKey: ratingKey,
-      },
-    })
-
-    if (!mark) {
-      return { success: false, error: "Media not found" }
-    }
-
-    // Create or update a "keep forever" mark from the admin
-    await prisma.userMediaMark.upsert({
-      where: {
-        userId_plexRatingKey_markType: {
-          userId: session.user.id,
-          plexRatingKey: ratingKey,
-          markType: "KEEP_FOREVER",
-        },
-      },
-      create: {
-        userId: session.user.id,
-        plexRatingKey: ratingKey,
-        mediaType: mark.mediaType,
-        title: mark.title,
-        year: mark.year,
-        markType: "KEEP_FOREVER",
-        note: "Admin decision: Keep forever (ignore user feedback)",
-        markedVia: "admin_feedback_review",
-      },
-      update: {
-        note: "Admin decision: Keep forever (ignore user feedback)",
-        markedAt: new Date(),
-      },
-    })
-
-    logger.info("Media marked to keep forever by admin", {
-      ratingKey,
-      userId: session.user.id,
-    })
-
-    return { success: true }
-  } catch (error) {
-    logger.error("Error ignoring media", error)
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Failed to ignore media",
-    }
-  }
-}
diff --git a/actions/maintenance/user-marks.ts b/actions/user-marks.ts
similarity index 97%
rename from actions/maintenance/user-marks.ts
rename to actions/user-marks.ts
index 512127f4..805a24d1 100644
--- a/actions/maintenance/user-marks.ts
+++ b/actions/user-marks.ts
@@ -6,12 +6,12 @@ import {
   CreateUserMediaMarkSchema,
   type MediaType,
   type MarkType,
-} from "@/lib/validations/maintenance"
+} from "@/lib/validations/user-media"
 import { getServerSession } from "next-auth"
 import { authOptions } from "@/lib/auth"
 import { revalidatePath } from "next/cache"
 
-const logger = createLogger("MAINTENANCE-MARKS")
+const logger = createLogger("USER-MARKS")
 
 /**
  * Get user's media marks with optional filters
diff --git a/app/admin/maintenance/candidates/page.tsx b/app/admin/maintenance/candidates/page.tsx
deleted file mode 100644
index c4195131..00000000
--- a/app/admin/maintenance/candidates/page.tsx
+++ /dev/null
@@ -1,228 +0,0 @@
-"use client"
-
-import { getMaintenanceCandidates, updateCandidateReviewStatus, bulkUpdateCandidates } from "@/actions/maintenance"
-import { useToast } from "@/components/ui/toast"
-import { LoadingSpinner } from "@/components/ui/loading-spinner"
-import { Pagination } from "@/components/ui/pagination"
-import { useState } from "react"
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"
-import type { ReviewStatus, MediaType } from "@/lib/validations/maintenance"
-import type { PaginatedCandidatesResponse } from "@/types/maintenance"
-import { CandidateList } from "@/components/admin/maintenance/candidates/CandidateList"
-import { CandidateFilters } from "@/components/admin/maintenance/candidates/CandidateFilters"
-import { CandidateActions } from "@/components/admin/maintenance/candidates/CandidateActions"
-
-const DEFAULT_PAGE_SIZE = 25
-
-export default function CandidatesPage() {
-  const toast = useToast()
-  const queryClient = useQueryClient()
-  const [selectedCandidates, setSelectedCandidates] = useState<Set<string>>(new Set())
-  const [reviewStatusFilter, setReviewStatusFilter] = useState<ReviewStatus | "ALL">("PENDING")
-  const [mediaTypeFilter, setMediaTypeFilter] = useState<MediaType | "ALL">("ALL")
-  const [page, setPage] = useState(1)
-  const [pageSize, setPageSize] = useState(DEFAULT_PAGE_SIZE)
-
-  const { data: candidatesResult, isLoading, error } = useQuery({
-    queryKey: ['maintenance-candidates', reviewStatusFilter, mediaTypeFilter, page, pageSize],
-    queryFn: async () => {
-      const params: {
-        page: number
-        pageSize: number
-        reviewStatus?: ReviewStatus
-        mediaType?: MediaType
-      } = {
-        page,
-        pageSize,
-      }
-      if (reviewStatusFilter !== "ALL") {
-        params.reviewStatus = reviewStatusFilter
-      }
-      if (mediaTypeFilter !== "ALL") {
-        params.mediaType = mediaTypeFilter
-      }
-
-      const result = await getMaintenanceCandidates(params)
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to fetch candidates')
-      }
-      return result.data as PaginatedCandidatesResponse
-    },
-  })
-
-  const updateStatusMutation = useMutation({
-    mutationFn: async ({ id, status }: { id: string; status: ReviewStatus }) => {
-      const result = await updateCandidateReviewStatus(id, status)
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to update status')
-      }
-      return result
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['maintenance-candidates'] })
-      toast.showSuccess('Status updated successfully')
-    },
-    onError: (error) => {
-      toast.showError(error instanceof Error ? error.message : 'Failed to update status')
-    },
-  })
-
-  const bulkUpdateMutation = useMutation({
-    mutationFn: async ({ ids, status }: { ids: string[]; status: ReviewStatus }) => {
-      const result = await bulkUpdateCandidates(ids, status)
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to bulk update')
-      }
-      return result
-    },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['maintenance-candidates'] })
-      toast.showSuccess(`${variables.ids.length} candidates ${variables.status.toLowerCase()}`)
-      setSelectedCandidates(new Set())
-    },
-    onError: (error) => {
-      toast.showError(error instanceof Error ? error.message : 'Failed to bulk update')
-    },
-  })
-
-  const candidates = candidatesResult?.candidates ?? []
-  const pagination = candidatesResult?.pagination
-
-  function handlePageChange(newPage: number) {
-    setPage(newPage)
-    setSelectedCandidates(new Set()) // Clear selection on page change
-  }
-
-  function handlePageSizeChange(newPageSize: number) {
-    setPageSize(newPageSize)
-    setPage(1) // Reset to first page when page size changes
-    setSelectedCandidates(new Set())
-  }
-
-  function handleFilterChange(
-    filterType: "reviewStatus" | "mediaType",
-    value: ReviewStatus | MediaType | "ALL"
-  ) {
-    if (filterType === "reviewStatus") {
-      setReviewStatusFilter(value as ReviewStatus | "ALL")
-    } else {
-      setMediaTypeFilter(value as MediaType | "ALL")
-    }
-    setPage(1) // Reset to first page when filters change
-    setSelectedCandidates(new Set())
-  }
-
-  function toggleCandidate(id: string) {
-    const newSelected = new Set(selectedCandidates)
-    if (newSelected.has(id)) {
-      newSelected.delete(id)
-    } else {
-      newSelected.add(id)
-    }
-    setSelectedCandidates(newSelected)
-  }
-
-  function toggleAll() {
-    if (selectedCandidates.size === candidates.length && candidates.length > 0) {
-      setSelectedCandidates(new Set())
-    } else {
-      setSelectedCandidates(new Set(candidates.map(c => c.id)))
-    }
-  }
-
-  function handleApprove(id: string) {
-    updateStatusMutation.mutate({ id, status: "APPROVED" })
-  }
-
-  function handleReject(id: string) {
-    updateStatusMutation.mutate({ id, status: "REJECTED" })
-  }
-
-  function handleBulkApprove() {
-    if (selectedCandidates.size === 0) return
-    bulkUpdateMutation.mutate({ ids: Array.from(selectedCandidates), status: "APPROVED" })
-  }
-
-  function handleBulkReject() {
-    if (selectedCandidates.size === 0) return
-    bulkUpdateMutation.mutate({ ids: Array.from(selectedCandidates), status: "REJECTED" })
-  }
-
-  if (isLoading) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="flex justify-center py-12">
-            <LoadingSpinner size="lg" />
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  if (error) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="bg-red-500/10 border border-red-500/20 rounded-lg p-4">
-            <p className="text-red-400">Failed to load candidates</p>
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-7xl mx-auto">
-        <div className="mb-6">
-          <h1 className="text-2xl font-bold text-white mb-2">Review Candidates</h1>
-          <p className="text-slate-400">Review media flagged for deletion by maintenance rules</p>
-        </div>
-
-        <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-4 mb-4">
-          <div className="flex flex-col sm:flex-row gap-4 items-start sm:items-center justify-between">
-            <CandidateFilters
-              reviewStatusFilter={reviewStatusFilter}
-              mediaTypeFilter={mediaTypeFilter}
-              onReviewStatusChange={(value) => handleFilterChange("reviewStatus", value)}
-              onMediaTypeChange={(value) => handleFilterChange("mediaType", value)}
-            />
-            <CandidateActions
-              selectedCount={selectedCandidates.size}
-              onBulkApprove={handleBulkApprove}
-              onBulkReject={handleBulkReject}
-              isPending={bulkUpdateMutation.isPending}
-            />
-          </div>
-        </div>
-
-        <CandidateList
-          candidates={candidates}
-          selectedCandidates={selectedCandidates}
-          onToggleCandidate={toggleCandidate}
-          onToggleAll={toggleAll}
-          onApprove={handleApprove}
-          onReject={handleReject}
-          isPending={updateStatusMutation.isPending}
-        />
-
-        {pagination && pagination.totalCount > 0 && (
-          <div className="bg-slate-800/50 rounded-lg border border-slate-700 mt-4">
-            <Pagination
-              page={pagination.page}
-              pageSize={pagination.pageSize}
-              totalCount={pagination.totalCount}
-              totalPages={pagination.totalPages}
-              hasNextPage={pagination.hasNextPage}
-              hasPreviousPage={pagination.hasPreviousPage}
-              onPageChange={handlePageChange}
-              onPageSizeChange={handlePageSizeChange}
-              className="px-4"
-            />
-          </div>
-        )}
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/history/page.tsx b/app/admin/maintenance/history/page.tsx
deleted file mode 100644
index 221bb607..00000000
--- a/app/admin/maintenance/history/page.tsx
+++ /dev/null
@@ -1,116 +0,0 @@
-import { getDeletionHistory, getDeletionStats } from "@/actions/maintenance"
-import { DeletionHistoryClient } from "@/components/admin/maintenance/deletion-history-client"
-
-export const dynamic = 'force-dynamic'
-
-export default async function DeletionHistoryPage({
-  searchParams,
-}: {
-  searchParams: Promise<{
-    page?: string
-    mediaType?: string
-    deletedBy?: string
-    filesDeleted?: string
-    startDate?: string
-    endDate?: string
-  }>
-}) {
-  const params = await searchParams
-  const page = parseInt(params.page || "1", 10)
-
-  // Parse filters
-  const filters: {
-    mediaType?: "MOVIE" | "TV_SERIES" | "EPISODE"
-    deletedBy?: string
-    filesDeleted?: boolean
-    startDate?: Date
-    endDate?: Date
-    page: number
-    pageSize: number
-  } = {
-    page,
-    pageSize: 50,
-  }
-
-  if (params.mediaType && ["MOVIE", "TV_SERIES", "EPISODE"].includes(params.mediaType)) {
-    filters.mediaType = params.mediaType as "MOVIE" | "TV_SERIES" | "EPISODE"
-  }
-
-  if (params.deletedBy) {
-    filters.deletedBy = params.deletedBy
-  }
-
-  if (params.filesDeleted) {
-    filters.filesDeleted = params.filesDeleted === "true"
-  }
-
-  if (params.startDate) {
-    filters.startDate = new Date(params.startDate)
-  }
-
-  if (params.endDate) {
-    filters.endDate = new Date(params.endDate)
-  }
-
-  const [historyResult, statsResult] = await Promise.all([
-    getDeletionHistory(filters),
-    getDeletionStats({
-      startDate: filters.startDate,
-      endDate: filters.endDate,
-    }),
-  ])
-
-  if (!historyResult.success || !historyResult.data) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="bg-red-500/10 border border-red-500/30 rounded-lg p-4">
-            <p className="text-red-400">
-              {historyResult.error || "Failed to load deletion history"}
-            </p>
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  if (!statsResult.success || !statsResult.data) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="bg-red-500/10 border border-red-500/30 rounded-lg p-4">
-            <p className="text-red-400">
-              {statsResult.error || "Failed to load deletion statistics"}
-            </p>
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-7xl mx-auto">
-        <div className="mb-6">
-          <h1 className="text-2xl sm:text-3xl font-bold text-white mb-2">Deletion History</h1>
-          <p className="text-sm text-slate-400">
-            View all media deletions and reclaimed storage space
-          </p>
-        </div>
-
-        <DeletionHistoryClient
-          deletions={historyResult.data.deletions}
-          pagination={historyResult.data.pagination}
-          stats={statsResult.data}
-          currentFilters={{
-            mediaType: params.mediaType,
-            deletedBy: params.deletedBy,
-            filesDeleted: params.filesDeleted,
-            startDate: params.startDate,
-            endDate: params.endDate,
-          }}
-        />
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/page.tsx b/app/admin/maintenance/page.tsx
deleted file mode 100644
index 50d80208..00000000
--- a/app/admin/maintenance/page.tsx
+++ /dev/null
@@ -1,270 +0,0 @@
-import { getMaintenanceStats } from "@/actions/maintenance"
-import Link from "next/link"
-
-export const dynamic = 'force-dynamic'
-
-export default async function MaintenanceDashboard() {
-  const statsResult = await getMaintenanceStats()
-
-  if (!statsResult.success || !statsResult.data) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="bg-red-500/10 border border-red-500/20 rounded-lg p-4">
-            <p className="text-red-400">Failed to load maintenance statistics</p>
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  const stats = statsResult.data
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-7xl mx-auto">
-        <div className="mb-6 space-y-4">
-          <div className="flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4">
-            <div>
-              <h1 className="text-2xl sm:text-3xl font-bold text-white mb-2">Library Maintenance</h1>
-              <p className="text-sm text-slate-400">
-                Automate library cleanup with rules and scheduled scans
-              </p>
-            </div>
-            <div className="flex gap-3">
-              <Link
-                href="/admin/maintenance/candidates"
-                className="px-4 py-2 bg-slate-700 hover:bg-slate-600 text-white rounded-lg font-medium transition-colors flex items-center gap-2"
-              >
-                <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-                </svg>
-                View Candidates
-              </Link>
-              <Link
-                href="/admin/maintenance/history"
-                className="px-4 py-2 bg-slate-700 hover:bg-slate-600 text-white rounded-lg font-medium transition-colors flex items-center gap-2"
-              >
-                <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" />
-                </svg>
-                History
-              </Link>
-              <Link
-                href="/admin/maintenance/rules/new"
-                className="px-4 py-2 bg-cyan-600 hover:bg-cyan-500 text-white rounded-lg font-medium transition-colors flex items-center gap-2"
-              >
-                <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-                </svg>
-                Create Rule
-              </Link>
-            </div>
-          </div>
-        </div>
-
-        {/* Statistics Cards */}
-        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4 mb-8">
-          {/* Rules Stats */}
-          <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-6">
-            <div className="flex items-center justify-between mb-4">
-              <div className="w-10 h-10 rounded-lg bg-cyan-600/20 flex items-center justify-center">
-                <svg className="w-5 h-5 text-cyan-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-                </svg>
-              </div>
-            </div>
-            <div className="space-y-1">
-              <div className="text-2xl font-bold text-white">{stats.rules.total}</div>
-              <div className="text-sm text-slate-400">Total Rules</div>
-              <div className="flex gap-2 text-xs">
-                <span className="text-green-400">{stats.rules.enabled} active</span>
-                <span className="text-slate-500">•</span>
-                <span className="text-slate-400">{stats.rules.disabled} disabled</span>
-              </div>
-            </div>
-          </div>
-
-          {/* Pending Candidates */}
-          <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-6">
-            <div className="flex items-center justify-between mb-4">
-              <div className="w-10 h-10 rounded-lg bg-yellow-600/20 flex items-center justify-center">
-                <svg className="w-5 h-5 text-yellow-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" />
-                </svg>
-              </div>
-            </div>
-            <div className="space-y-1">
-              <div className="text-2xl font-bold text-white">{stats.candidates.pending}</div>
-              <div className="text-sm text-slate-400">Pending Review</div>
-              <div className="text-xs text-slate-500">
-                {stats.candidates.total} total candidates
-              </div>
-            </div>
-          </div>
-
-          {/* Approved Candidates */}
-          <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-6">
-            <div className="flex items-center justify-between mb-4">
-              <div className="w-10 h-10 rounded-lg bg-green-600/20 flex items-center justify-center">
-                <svg className="w-5 h-5 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
-                </svg>
-              </div>
-            </div>
-            <div className="space-y-1">
-              <div className="text-2xl font-bold text-white">{stats.candidates.approved}</div>
-              <div className="text-sm text-slate-400">Approved</div>
-              <div className="text-xs text-slate-500">
-                Ready for deletion
-              </div>
-            </div>
-          </div>
-
-          {/* Total Deletions */}
-          <Link href="/admin/maintenance/history" className="bg-slate-800/50 rounded-lg border border-slate-700 p-6 hover:bg-slate-800/70 transition-colors block">
-            <div className="flex items-center justify-between mb-4">
-              <div className="w-10 h-10 rounded-lg bg-red-600/20 flex items-center justify-center">
-                <svg className="w-5 h-5 text-red-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
-                </svg>
-              </div>
-              <svg className="w-4 h-4 text-slate-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
-              </svg>
-            </div>
-            <div className="space-y-1">
-              <div className="text-2xl font-bold text-white">{stats.totalDeletions}</div>
-              <div className="text-sm text-slate-400">Total Deletions</div>
-              <div className="text-xs text-slate-500">
-                Click to view history
-              </div>
-            </div>
-          </Link>
-        </div>
-
-        {/* Recent Scans */}
-        <div className="bg-slate-800/50 rounded-lg border border-slate-700">
-          <div className="p-6 border-b border-slate-700 flex justify-between items-center">
-            <div>
-              <h2 className="text-xl font-bold text-white">Recent Scans</h2>
-              <p className="text-sm text-slate-400 mt-1">Latest completed maintenance scans</p>
-            </div>
-            <Link
-              href="/admin/maintenance/rules"
-              className="text-sm text-cyan-400 hover:text-cyan-300 transition-colors"
-            >
-              View All Rules
-            </Link>
-          </div>
-          <div className="overflow-x-auto">
-            {stats.recentScans.length === 0 ? (
-              <div className="p-12 text-center">
-                <svg className="w-12 h-12 text-slate-500 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-                </svg>
-                <h3 className="text-lg font-medium text-white mb-2">No scans yet</h3>
-                <p className="text-slate-400 mb-4">Create a maintenance rule to start scanning your library.</p>
-                <Link
-                  href="/admin/maintenance/rules/new"
-                  className="inline-flex items-center gap-2 px-4 py-2 bg-cyan-600 hover:bg-cyan-500 text-white rounded-lg font-medium transition-colors"
-                >
-                  <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-                  </svg>
-                  Create Rule
-                </Link>
-              </div>
-            ) : (
-              <table className="w-full text-left">
-                <thead>
-                  <tr className="bg-slate-900/50 border-b border-slate-700">
-                    <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Rule</th>
-                    <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Status</th>
-                    <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Items Scanned</th>
-                    <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Items Flagged</th>
-                    <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Completed</th>
-                  </tr>
-                </thead>
-                <tbody className="divide-y divide-slate-700">
-                  {stats.recentScans.map((scan) => (
-                    <tr key={scan.id} className="hover:bg-slate-800/50 transition-colors">
-                      <td className="px-6 py-4">
-                        <div className="text-sm font-medium text-white">{scan.rule.name}</div>
-                      </td>
-                      <td className="px-6 py-4">
-                        <span className={`inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${
-                          scan.status === 'COMPLETED' ? 'bg-green-400/10 text-green-400' :
-                          scan.status === 'RUNNING' ? 'bg-blue-400/10 text-blue-400' :
-                          scan.status === 'FAILED' ? 'bg-red-400/10 text-red-400' :
-                          'bg-slate-400/10 text-slate-400'
-                        }`}>
-                          {scan.status}
-                        </span>
-                      </td>
-                      <td className="px-6 py-4 text-sm text-slate-400">{scan.itemsScanned}</td>
-                      <td className="px-6 py-4">
-                        <div className="flex items-center gap-2">
-                          <span className="text-sm text-slate-400">{scan.itemsFlagged}</span>
-                          {scan.itemsFlagged > 0 && (
-                            <span className="inline-flex items-center px-2 py-0.5 rounded text-xs font-medium bg-yellow-400/10 text-yellow-400">
-                              Needs Review
-                            </span>
-                          )}
-                        </div>
-                      </td>
-                      <td className="px-6 py-4 text-sm text-slate-400">
-                        {scan.completedAt ? new Date(scan.completedAt).toLocaleString() : '-'}
-                      </td>
-                    </tr>
-                  ))}
-                </tbody>
-              </table>
-            )}
-          </div>
-        </div>
-
-        {/* Quick Links */}
-        <div className="grid grid-cols-1 sm:grid-cols-2 gap-4 mt-6">
-          <Link
-            href="/admin/maintenance/rules"
-            className="bg-slate-800/50 rounded-lg border border-slate-700 p-6 hover:border-cyan-500/50 transition-all group"
-          >
-            <div className="flex items-start justify-between">
-              <div className="flex-1">
-                <h3 className="text-lg font-semibold text-white mb-2 group-hover:text-cyan-400 transition-colors">
-                  Manage Rules
-                </h3>
-                <p className="text-sm text-slate-400">
-                  Create and configure automated maintenance rules for your library
-                </p>
-              </div>
-              <svg className="w-5 h-5 text-slate-500 group-hover:text-cyan-400 transition-colors" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
-              </svg>
-            </div>
-          </Link>
-
-          <Link
-            href="/admin/maintenance/candidates"
-            className="bg-slate-800/50 rounded-lg border border-slate-700 p-6 hover:border-cyan-500/50 transition-all group"
-          >
-            <div className="flex items-start justify-between">
-              <div className="flex-1">
-                <h3 className="text-lg font-semibold text-white mb-2 group-hover:text-cyan-400 transition-colors">
-                  Review Candidates
-                </h3>
-                <p className="text-sm text-slate-400">
-                  Review and approve media flagged for deletion by maintenance rules
-                </p>
-              </div>
-              <svg className="w-5 h-5 text-slate-500 group-hover:text-cyan-400 transition-colors" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5l7 7-7 7" />
-              </svg>
-            </div>
-          </Link>
-        </div>
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/rules/[ruleId]/edit/page.tsx b/app/admin/maintenance/rules/[ruleId]/edit/page.tsx
deleted file mode 100644
index 0a5e65c7..00000000
--- a/app/admin/maintenance/rules/[ruleId]/edit/page.tsx
+++ /dev/null
@@ -1,59 +0,0 @@
-import { getMaintenanceRule } from "@/actions/maintenance/rules"
-import { RuleForm, type MaintenanceRuleData } from "@/components/maintenance/RuleForm"
-import type { RuleCriteria } from "@/lib/validations/maintenance"
-import Link from "next/link"
-import { notFound } from "next/navigation"
-
-export const dynamic = 'force-dynamic'
-
-export default async function EditRulePage({
-  params,
-}: {
-  params: Promise<{ ruleId: string }>
-}) {
-  const { ruleId } = await params
-
-  const result = await getMaintenanceRule(ruleId)
-  if (!result.success || !result.data) {
-    notFound()
-  }
-
-  const rule = result.data
-
-  // Transform database rule to form data format
-  const initialData: MaintenanceRuleData = {
-    id: rule.id,
-    name: rule.name,
-    description: rule.description,
-    enabled: rule.enabled,
-    mediaType: rule.mediaType,
-    criteria: rule.criteria as unknown as RuleCriteria,
-    actionType: rule.actionType,
-    actionDelayDays: rule.actionDelayDays,
-    radarrId: rule.radarrId,
-    sonarrId: rule.sonarrId,
-    schedule: rule.schedule,
-  }
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-6xl mx-auto">
-        <div className="mb-6">
-          <Link
-            href="/admin/maintenance/rules"
-            className="inline-flex items-center gap-2 text-sm text-slate-400 hover:text-cyan-400 mb-4 transition-colors group"
-          >
-            <svg className="w-4 h-4 group-hover:-translate-x-1 transition-transform" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 19l-7-7 7-7" />
-            </svg>
-            Back to Rules
-          </Link>
-          <h1 className="text-2xl font-bold text-white mb-2">Edit Maintenance Rule</h1>
-          <p className="text-slate-400">Modify the criteria for &quot;{rule.name}&quot;</p>
-        </div>
-
-        <RuleForm mode="edit" initialData={initialData} />
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/rules/new/__tests__/page.test.tsx b/app/admin/maintenance/rules/new/__tests__/page.test.tsx
deleted file mode 100644
index ccd733fa..00000000
--- a/app/admin/maintenance/rules/new/__tests__/page.test.tsx
+++ /dev/null
@@ -1,555 +0,0 @@
-import { render, screen, waitFor } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { useRouter } from 'next/navigation'
-import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
-import NewRulePage from '../page'
-import * as maintenanceActions from '@/actions/maintenance'
-
-// Mock Next.js router
-jest.mock('next/navigation', () => ({
-  useRouter: jest.fn(),
-}))
-
-// Mock maintenance actions
-jest.mock('@/actions/maintenance', () => ({
-  createMaintenanceRule: jest.fn(),
-}))
-
-// Mock toast
-const mockShowError = jest.fn()
-const mockShowSuccess = jest.fn()
-
-jest.mock('@/components/ui/toast', () => ({
-  useToast: () => ({
-    showError: mockShowError,
-    showSuccess: mockShowSuccess,
-  }),
-}))
-
-// Mock EnhancedRuleBuilder component
-jest.mock('@/components/maintenance/enhanced-rule-builder', () => ({
-  EnhancedRuleBuilder: ({ value, onChange, mediaType }: any) => (
-    <div data-testid="enhanced-rule-builder">
-      <input
-        data-testid="rule-builder-input"
-        value={JSON.stringify(value)}
-        onChange={(e) => onChange(JSON.parse(e.target.value))}
-      />
-      <span data-testid="rule-builder-media-type">{mediaType}</span>
-    </div>
-  ),
-  createDefaultCriteria: (mediaType: string) => ({
-    operator: 'AND',
-    conditions: [
-      {
-        field: 'playCount',
-        operator: 'lessThan',
-        value: 5,
-      },
-    ],
-    mediaType,
-  }),
-}))
-
-describe('NewRulePage', () => {
-  let queryClient: QueryClient
-  const mockPush = jest.fn()
-  const mockBack = jest.fn()
-
-  beforeEach(() => {
-    queryClient = new QueryClient({
-      defaultOptions: {
-        queries: {
-          retry: false,
-        },
-      },
-    })
-
-    ;(useRouter as jest.Mock).mockReturnValue({
-      push: mockPush,
-      back: mockBack,
-    })
-
-    // Reset mocks
-    mockShowError.mockClear()
-    mockShowSuccess.mockClear()
-    mockPush.mockClear()
-    mockBack.mockClear()
-    ;(maintenanceActions.createMaintenanceRule as jest.Mock).mockClear()
-
-    // Mock successful fetch responses by default
-    global.fetch = jest.fn((url) => {
-      if (url.includes('/api/admin/radarr')) {
-        return Promise.resolve({
-          ok: true,
-          json: () => Promise.resolve({
-            servers: [
-              { id: 'radarr-1', name: 'Radarr Server 1', url: 'http://radarr1.local', apiKey: 'key1', isActive: true },
-              { id: 'radarr-2', name: 'Radarr Server 2', url: 'http://radarr2.local', apiKey: 'key2', isActive: false },
-            ],
-          }),
-        } as Response)
-      }
-      if (url.includes('/api/admin/sonarr')) {
-        return Promise.resolve({
-          ok: true,
-          json: () => Promise.resolve({
-            servers: [
-              { id: 'sonarr-1', name: 'Sonarr Server 1', url: 'http://sonarr1.local', apiKey: 'key1', isActive: true },
-            ],
-          }),
-        } as Response)
-      }
-      return Promise.reject(new Error('Unknown URL'))
-    }) as jest.Mock
-  })
-
-  afterEach(() => {
-    jest.restoreAllMocks()
-  })
-
-  const renderComponent = () => {
-    return render(
-      <QueryClientProvider client={queryClient}>
-        <NewRulePage />
-      </QueryClientProvider>
-    )
-  }
-
-  describe('Loading States', () => {
-    it('should render loading state for Radarr servers', async () => {
-      // Mock a delayed response
-      global.fetch = jest.fn((url) => {
-        if (url.includes('/api/admin/radarr')) {
-          return new Promise(() => {}) // Never resolves
-        }
-        return Promise.resolve({
-          ok: true,
-          json: () => Promise.resolve({ servers: [] }),
-        } as Response)
-      }) as jest.Mock
-
-      renderComponent()
-
-      // Wait for component to mount and show loading
-      await waitFor(() => {
-        expect(screen.getByText('Loading servers...')).toBeInTheDocument()
-      })
-    })
-
-    it('should render loading state for Sonarr servers when media type is TV_SERIES', async () => {
-      // Mock delayed Sonarr response
-      global.fetch = jest.fn((url) => {
-        if (url.includes('/api/admin/sonarr')) {
-          return new Promise(() => {}) // Never resolves
-        }
-        if (url.includes('/api/admin/radarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        return Promise.reject(new Error('Unknown URL'))
-      }) as jest.Mock
-
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Change media type to TV_SERIES
-      await waitFor(() => {
-        const mediaTypeDropdown = screen.getByLabelText('Media Type')
-        expect(mediaTypeDropdown).toBeInTheDocument()
-      })
-
-      const mediaTypeDropdown = screen.getByLabelText('Media Type')
-      await user.click(mediaTypeDropdown)
-
-      // Find and click TV Series option
-      const tvSeriesOption = screen.getByText('TV Series')
-      await user.click(tvSeriesOption)
-
-      // Should show loading for Sonarr
-      await waitFor(() => {
-        expect(screen.getByText('Loading servers...')).toBeInTheDocument()
-      })
-    })
-  })
-
-  describe('Error States', () => {
-    it('should show error toast when Radarr servers fail to load', async () => {
-      global.fetch = jest.fn((url) => {
-        if (url.includes('/api/admin/radarr')) {
-          return Promise.resolve({
-            ok: false,
-            statusText: 'Internal Server Error',
-          } as Response)
-        }
-        if (url.includes('/api/admin/sonarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        return Promise.reject(new Error('Unknown URL'))
-      }) as jest.Mock
-
-      renderComponent()
-
-      await waitFor(() => {
-        expect(mockShowError).toHaveBeenCalledWith(
-          expect.stringContaining('Failed to load Radarr servers')
-        )
-      }, { timeout: 3000 })
-    })
-
-    it('should show error toast when Sonarr servers fail to load', async () => {
-      global.fetch = jest.fn((url) => {
-        if (url.includes('/api/admin/sonarr')) {
-          return Promise.resolve({
-            ok: false,
-            statusText: 'Internal Server Error',
-          } as Response)
-        }
-        if (url.includes('/api/admin/radarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        return Promise.reject(new Error('Unknown URL'))
-      }) as jest.Mock
-
-      renderComponent()
-
-      await waitFor(() => {
-        expect(mockShowError).toHaveBeenCalledWith(
-          expect.stringContaining('Failed to load Sonarr servers')
-        )
-      }, { timeout: 3000 })
-    })
-  })
-
-  describe('Server Dropdowns', () => {
-    it('should populate Radarr dropdown with servers when data loads', async () => {
-      renderComponent()
-
-      // Wait for Radarr dropdown to appear with servers
-      await waitFor(() => {
-        const radarrDropdown = screen.getByLabelText('Radarr Server (Optional)')
-        expect(radarrDropdown).toBeInTheDocument()
-      })
-
-      // Verify dropdown is not disabled
-      const radarrDropdown = screen.getByLabelText('Radarr Server (Optional)')
-      expect(radarrDropdown).not.toBeDisabled()
-    })
-
-    it('should populate Sonarr dropdown with servers for TV_SERIES media type', async () => {
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for page to load
-      await waitFor(() => {
-        expect(screen.getByLabelText('Media Type')).toBeInTheDocument()
-      })
-
-      // Change media type to TV_SERIES
-      const mediaTypeDropdown = screen.getByLabelText('Media Type')
-      await user.click(mediaTypeDropdown)
-
-      const tvSeriesOption = screen.getByText('TV Series')
-      await user.click(tvSeriesOption)
-
-      // Wait for Sonarr dropdown to appear
-      await waitFor(() => {
-        const sonarrDropdown = screen.getByLabelText('Sonarr Server (Optional)')
-        expect(sonarrDropdown).toBeInTheDocument()
-        expect(sonarrDropdown).not.toBeDisabled()
-      })
-    })
-
-    it('should show "No servers configured" message when no Radarr servers exist', async () => {
-      // Mock empty server list
-      global.fetch = jest.fn((url) => {
-        if (url.includes('/api/admin/radarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        if (url.includes('/api/admin/sonarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        return Promise.reject(new Error('Unknown URL'))
-      }) as jest.Mock
-
-      renderComponent()
-
-      // Wait for dropdown to load
-      await waitFor(() => {
-        expect(screen.getByLabelText('Radarr Server (Optional)')).toBeInTheDocument()
-      })
-
-      // Verify disabled state and message
-      const radarrDropdown = screen.getByLabelText('Radarr Server (Optional)')
-      expect(radarrDropdown).toBeDisabled()
-
-      // Check for the help text message
-      expect(screen.getByText('Configure a Radarr server in settings to enable this option.')).toBeInTheDocument()
-    })
-
-    it('should show "No servers configured" message when no Sonarr servers exist', async () => {
-      // Mock empty server list
-      global.fetch = jest.fn((url) => {
-        if (url.includes('/api/admin/radarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        if (url.includes('/api/admin/sonarr')) {
-          return Promise.resolve({
-            ok: true,
-            json: () => Promise.resolve({ servers: [] }),
-          } as Response)
-        }
-        return Promise.reject(new Error('Unknown URL'))
-      }) as jest.Mock
-
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for page to load
-      await waitFor(() => {
-        expect(screen.getByLabelText('Media Type')).toBeInTheDocument()
-      })
-
-      // Change to TV_SERIES
-      const mediaTypeDropdown = screen.getByLabelText('Media Type')
-      await user.click(mediaTypeDropdown)
-
-      const tvSeriesOption = screen.getByText('TV Series')
-      await user.click(tvSeriesOption)
-
-      // Wait for Sonarr dropdown
-      await waitFor(() => {
-        expect(screen.getByLabelText('Sonarr Server (Optional)')).toBeInTheDocument()
-      })
-
-      const sonarrDropdown = screen.getByLabelText('Sonarr Server (Optional)')
-      expect(sonarrDropdown).toBeDisabled()
-
-      expect(screen.getByText('Configure a Sonarr server in settings to enable this option.')).toBeInTheDocument()
-    })
-  })
-
-  describe('Form Submission', () => {
-    it('should submit form successfully with server selection', async () => {
-      ;(maintenanceActions.createMaintenanceRule as jest.Mock).mockResolvedValue({
-        success: true,
-      })
-
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByLabelText(/Rule Name/)).toBeInTheDocument()
-      })
-
-      // Fill in form
-      const nameInput = screen.getByLabelText(/Rule Name/)
-      await user.type(nameInput, 'Test Rule')
-
-      // Select Radarr server
-      await waitFor(() => {
-        expect(screen.getByLabelText('Radarr Server (Optional)')).toBeInTheDocument()
-      })
-
-      // Submit form
-      const submitButton = screen.getByRole('button', { name: /Create Rule/i })
-      await user.click(submitButton)
-
-      await waitFor(() => {
-        expect(maintenanceActions.createMaintenanceRule).toHaveBeenCalled()
-        expect(mockShowSuccess).toHaveBeenCalledWith('Maintenance rule created successfully')
-        expect(mockPush).toHaveBeenCalledWith('/admin/maintenance/rules')
-      })
-    })
-
-    it('should submit form successfully without server selection', async () => {
-      ;(maintenanceActions.createMaintenanceRule as jest.Mock).mockResolvedValue({
-        success: true,
-      })
-
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByLabelText(/Rule Name/)).toBeInTheDocument()
-      })
-
-      // Fill in form with just the required name
-      const nameInput = screen.getByLabelText(/Rule Name/)
-      await user.type(nameInput, 'Test Rule Without Server')
-
-      // Submit form
-      const submitButton = screen.getByRole('button', { name: /Create Rule/i })
-      await user.click(submitButton)
-
-      await waitFor(() => {
-        expect(maintenanceActions.createMaintenanceRule).toHaveBeenCalledWith(
-          expect.objectContaining({
-            name: 'Test Rule Without Server',
-            radarrId: undefined,
-            sonarrId: undefined,
-          })
-        )
-      })
-    })
-
-    it('should show error when form submission fails', async () => {
-      ;(maintenanceActions.createMaintenanceRule as jest.Mock).mockResolvedValue({
-        success: false,
-        error: 'Database connection failed',
-      })
-
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByLabelText(/Rule Name/)).toBeInTheDocument()
-      })
-
-      // Fill in form
-      const nameInput = screen.getByLabelText(/Rule Name/)
-      await user.type(nameInput, 'Test Rule')
-
-      // Submit form
-      const submitButton = screen.getByRole('button', { name: /Create Rule/i })
-      await user.click(submitButton)
-
-      await waitFor(() => {
-        expect(mockShowError).toHaveBeenCalledWith('Database connection failed')
-      })
-    })
-
-    it('should validate required name field', async () => {
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByRole('button', { name: /Create Rule/i })).toBeInTheDocument()
-      })
-
-      // The name input should have the required attribute
-      const nameInput = screen.getByLabelText(/Rule Name/)
-      expect(nameInput).toHaveAttribute('required')
-
-      // Type some spaces (which will be trimmed)
-      await user.type(nameInput, '   ')
-
-      // Try to submit with whitespace-only name
-      const submitButton = screen.getByRole('button', { name: /Create Rule/i })
-      await user.click(submitButton)
-
-      await waitFor(() => {
-        expect(mockShowError).toHaveBeenCalledWith('Rule name is required')
-      })
-
-      expect(maintenanceActions.createMaintenanceRule).not.toHaveBeenCalled()
-    })
-
-    it('should handle cancel button click', async () => {
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByRole('button', { name: /Cancel/i })).toBeInTheDocument()
-      })
-
-      const cancelButton = screen.getByRole('button', { name: /Cancel/i })
-      await user.click(cancelButton)
-
-      expect(mockBack).toHaveBeenCalled()
-    })
-  })
-
-  describe('Media Type Changes', () => {
-    it('should show Radarr dropdown for MOVIE media type', async () => {
-      renderComponent()
-
-      await waitFor(() => {
-        expect(screen.getByLabelText('Radarr Server (Optional)')).toBeInTheDocument()
-      })
-
-      // Sonarr dropdown should not be present
-      expect(screen.queryByLabelText('Sonarr Server (Optional)')).not.toBeInTheDocument()
-    })
-
-    it('should show Sonarr dropdown for TV_SERIES media type', async () => {
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByLabelText('Media Type')).toBeInTheDocument()
-      })
-
-      // Change to TV_SERIES
-      const mediaTypeDropdown = screen.getByLabelText('Media Type')
-      await user.click(mediaTypeDropdown)
-
-      const tvSeriesOption = screen.getByText('TV Series')
-      await user.click(tvSeriesOption)
-
-      // Should show Sonarr, not Radarr
-      await waitFor(() => {
-        expect(screen.getByLabelText('Sonarr Server (Optional)')).toBeInTheDocument()
-      })
-
-      expect(screen.queryByLabelText('Radarr Server (Optional)')).not.toBeInTheDocument()
-    })
-
-    it('should show Sonarr dropdown for EPISODE media type', async () => {
-      renderComponent()
-
-      const user = userEvent.setup()
-
-      // Wait for form to load
-      await waitFor(() => {
-        expect(screen.getByLabelText('Media Type')).toBeInTheDocument()
-      })
-
-      // Change to EPISODE
-      const mediaTypeDropdown = screen.getByLabelText('Media Type')
-      await user.click(mediaTypeDropdown)
-
-      const episodeOption = screen.getByText('Episode')
-      await user.click(episodeOption)
-
-      // Should show Sonarr, not Radarr
-      await waitFor(() => {
-        expect(screen.getByLabelText('Sonarr Server (Optional)')).toBeInTheDocument()
-      })
-
-      expect(screen.queryByLabelText('Radarr Server (Optional)')).not.toBeInTheDocument()
-    })
-  })
-})
diff --git a/app/admin/maintenance/rules/new/page.tsx b/app/admin/maintenance/rules/new/page.tsx
deleted file mode 100644
index 7b1ee2ed..00000000
--- a/app/admin/maintenance/rules/new/page.tsx
+++ /dev/null
@@ -1,28 +0,0 @@
-"use client"
-
-import { RuleForm } from "@/components/maintenance/RuleForm"
-import Link from "next/link"
-
-export default function NewRulePage() {
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-6xl mx-auto">
-        <div className="mb-6">
-          <Link
-            href="/admin/maintenance/rules"
-            className="inline-flex items-center gap-2 text-sm text-slate-400 hover:text-cyan-400 mb-4 transition-colors group"
-          >
-            <svg className="w-4 h-4 group-hover:-translate-x-1 transition-transform" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 19l-7-7 7-7" />
-            </svg>
-            Back to Rules
-          </Link>
-          <h1 className="text-2xl font-bold text-white mb-2">Create Maintenance Rule</h1>
-          <p className="text-slate-400">Define powerful criteria for automated library maintenance</p>
-        </div>
-
-        <RuleForm mode="create" />
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/rules/page.tsx b/app/admin/maintenance/rules/page.tsx
deleted file mode 100644
index d21c037d..00000000
--- a/app/admin/maintenance/rules/page.tsx
+++ /dev/null
@@ -1,153 +0,0 @@
-"use client"
-
-import { getMaintenanceRules, deleteMaintenanceRule, toggleMaintenanceRule } from "@/actions/maintenance"
-import { useToast } from "@/components/ui/toast"
-import { ConfirmModal } from "@/components/admin/shared/confirm-modal"
-import { LoadingSpinner } from "@/components/ui/loading-spinner"
-import { useState } from "react"
-import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query"
-import { RuleList } from "@/components/admin/maintenance/rules/RuleList"
-import { RuleActions } from "@/components/admin/maintenance/rules/RuleActions"
-
-type MaintenanceRule = {
-  id: string
-  name: string
-  description: string | null
-  enabled: boolean
-  mediaType: string
-  actionType: string
-  schedule: string | null
-  createdAt: Date
-  scans: Array<{
-    id: string
-    status: string
-    itemsScanned: number
-    itemsFlagged: number
-    completedAt: Date | null
-  }>
-  _count: {
-    scans: number
-  }
-}
-
-export default function RulesPage() {
-  const toast = useToast()
-  const queryClient = useQueryClient()
-  const [ruleIdToDelete, setRuleIdToDelete] = useState<string | null>(null)
-
-  const { data: rulesResult, isLoading, error } = useQuery({
-    queryKey: ['maintenance-rules'],
-    queryFn: async () => {
-      const result = await getMaintenanceRules()
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to fetch rules')
-      }
-      return result.data as MaintenanceRule[]
-    },
-  })
-
-  const deleteMutation = useMutation({
-    mutationFn: async (id: string) => {
-      const result = await deleteMaintenanceRule(id)
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to delete rule')
-      }
-      return result
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['maintenance-rules'] })
-      toast.showSuccess('Rule deleted successfully')
-      setRuleIdToDelete(null)
-    },
-    onError: (error) => {
-      toast.showError(error instanceof Error ? error.message : 'Failed to delete rule')
-    },
-  })
-
-  const toggleMutation = useMutation({
-    mutationFn: async ({ id, enabled }: { id: string; enabled: boolean }) => {
-      const result = await toggleMaintenanceRule(id, enabled)
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to toggle rule')
-      }
-      return result
-    },
-    onSuccess: (_, variables) => {
-      queryClient.invalidateQueries({ queryKey: ['maintenance-rules'] })
-      toast.showSuccess(variables.enabled ? 'Rule enabled' : 'Rule disabled')
-    },
-    onError: (error) => {
-      toast.showError(error instanceof Error ? error.message : 'Failed to toggle rule')
-    },
-  })
-
-  function handleDeleteClick(id: string) {
-    setRuleIdToDelete(id)
-  }
-
-  function handleDeleteConfirm() {
-    if (ruleIdToDelete) {
-      deleteMutation.mutate(ruleIdToDelete)
-    }
-  }
-
-  function handleToggle(id: string, currentEnabled: boolean) {
-    toggleMutation.mutate({ id, enabled: !currentEnabled })
-  }
-
-  if (isLoading) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="flex justify-center py-12">
-            <LoadingSpinner size="lg" />
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  if (error) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="bg-red-500/10 border border-red-500/20 rounded-lg p-4">
-            <p className="text-red-400">Failed to load maintenance rules</p>
-          </div>
-        </div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-7xl mx-auto">
-        <div className="flex justify-between items-center mb-8">
-          <div>
-            <h1 className="text-2xl font-bold text-white mb-2">Maintenance Rules</h1>
-            <p className="text-slate-400">Configure automated library maintenance rules</p>
-          </div>
-          <RuleActions />
-        </div>
-
-        <RuleList
-          rules={rulesResult || []}
-          onToggle={handleToggle}
-          onDeleteClick={handleDeleteClick}
-          isTogglePending={toggleMutation.isPending}
-        />
-
-        <ConfirmModal
-          isOpen={ruleIdToDelete !== null}
-          onClose={() => setRuleIdToDelete(null)}
-          onConfirm={handleDeleteConfirm}
-          title="Delete Maintenance Rule"
-          message="Are you sure you want to delete this rule? This will also delete all associated scans and candidates. This action cannot be undone."
-          confirmText="Delete"
-          cancelText="Cancel"
-          confirmButtonClass="bg-red-600 hover:bg-red-700"
-        />
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/user-feedback/[ratingKey]/page.tsx b/app/admin/maintenance/user-feedback/[ratingKey]/page.tsx
deleted file mode 100644
index 12277ff8..00000000
--- a/app/admin/maintenance/user-feedback/[ratingKey]/page.tsx
+++ /dev/null
@@ -1,141 +0,0 @@
-import { getMediaMarkDetails } from "@/actions/user-feedback"
-import { MediaMarkDetailsView } from "@/components/admin/maintenance/media-mark-details"
-import { ErrorState } from "@/components/ui/error-state"
-import { PlexIcon, TautulliIcon, RadarrIcon, SonarrIcon } from "@/components/ui/service-icons"
-import Link from "next/link"
-
-export const dynamic = "force-dynamic"
-
-interface PageProps {
-  params: Promise<{
-    ratingKey: string
-  }>
-}
-
-export default async function MediaMarkDetailPage({ params }: PageProps) {
-  const { ratingKey } = await params
-  const result = await getMediaMarkDetails(ratingKey)
-
-  if (!result.success) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <div className="mb-6">
-            <Link
-              href="/admin/maintenance/user-feedback"
-              className="text-sm text-slate-400 hover:text-white transition-colors inline-flex items-center gap-1"
-            >
-              <svg
-                className="w-4 h-4"
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-              >
-                <path
-                  strokeLinecap="round"
-                  strokeLinejoin="round"
-                  strokeWidth={2}
-                  d="M15 19l-7-7 7-7"
-                />
-              </svg>
-              Back to User Feedback
-            </Link>
-          </div>
-          <ErrorState title="Failed to load media details" message={result.error} />
-        </div>
-      </div>
-    )
-  }
-
-  const details = result.data
-
-  if (!details) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <ErrorState title="Media details not found" message="No details available for this media" />
-        </div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-7xl mx-auto">
-        <div className="mb-6">
-          <Link
-            href="/admin/maintenance/user-feedback"
-            className="text-sm text-slate-400 hover:text-white transition-colors inline-flex items-center gap-1 mb-4"
-          >
-            <svg
-              className="w-4 h-4"
-              fill="none"
-              stroke="currentColor"
-              viewBox="0 0 24 24"
-            >
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M15 19l-7-7 7-7"
-              />
-            </svg>
-            Back to User Feedback
-          </Link>
-          <div className="flex items-center gap-3 flex-wrap">
-            <h1 className="text-2xl sm:text-3xl font-bold text-white">{details.title}</h1>
-            <div className="flex items-center gap-2">
-              {details.externalLinks.plex && (
-                <a
-                  href={details.externalLinks.plex}
-                  target="_blank"
-                  rel="noopener noreferrer"
-                  className="text-slate-500 hover:text-amber-500 transition-colors"
-                  title="View in Plex"
-                >
-                  <PlexIcon />
-                </a>
-              )}
-              {details.externalLinks.tautulli && (
-                <a
-                  href={details.externalLinks.tautulli}
-                  target="_blank"
-                  rel="noopener noreferrer"
-                  className="text-slate-500 hover:text-blue-500 transition-colors"
-                  title="View in Tautulli"
-                >
-                  <TautulliIcon />
-                </a>
-              )}
-              {details.externalLinks.radarr && (
-                <a
-                  href={details.externalLinks.radarr}
-                  target="_blank"
-                  rel="noopener noreferrer"
-                  className="text-slate-500 hover:text-purple-500 transition-colors"
-                  title="View in Radarr"
-                >
-                  <RadarrIcon />
-                </a>
-              )}
-              {details.externalLinks.sonarr && (
-                <a
-                  href={details.externalLinks.sonarr}
-                  target="_blank"
-                  rel="noopener noreferrer"
-                  className="text-slate-500 hover:text-emerald-500 transition-colors"
-                  title="View in Sonarr"
-                >
-                  <SonarrIcon />
-                </a>
-              )}
-            </div>
-          </div>
-          {details.year && <p className="text-sm text-slate-400">{details.year}</p>}
-        </div>
-
-        <MediaMarkDetailsView details={details} />
-      </div>
-    </div>
-  )
-}
diff --git a/app/admin/maintenance/user-feedback/page.tsx b/app/admin/maintenance/user-feedback/page.tsx
deleted file mode 100644
index aa9b8c18..00000000
--- a/app/admin/maintenance/user-feedback/page.tsx
+++ /dev/null
@@ -1,62 +0,0 @@
-import { getUserFeedbackSummary } from "@/actions/user-feedback"
-import { UserFeedbackTable } from "@/components/admin/maintenance/user-feedback-table"
-import { ErrorState } from "@/components/ui/error-state"
-
-export const dynamic = "force-dynamic"
-
-export default async function UserFeedbackPage() {
-  const result = await getUserFeedbackSummary()
-
-  if (!result.success) {
-    return (
-      <div className="p-4 sm:p-6">
-        <div className="max-w-7xl mx-auto">
-          <h1 className="text-2xl sm:text-3xl font-bold text-white mb-6">User Feedback</h1>
-          <ErrorState title="Failed to load user feedback" message={result.error} />
-        </div>
-      </div>
-    )
-  }
-
-  const summaries = result.data || []
-
-  return (
-    <div className="p-4 sm:p-6">
-      <div className="max-w-7xl mx-auto">
-        <div className="mb-6">
-          <h1 className="text-2xl sm:text-3xl font-bold text-white mb-2">User Feedback</h1>
-          <p className="text-sm text-slate-400">
-            Review aggregated user marks to identify media for deletion or retention.
-          </p>
-        </div>
-
-        <div className="mb-6 grid grid-cols-1 sm:grid-cols-4 gap-4">
-          <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-            <div className="text-sm text-slate-400 mb-1">Total Items</div>
-            <div className="text-2xl font-bold text-white">{summaries.length}</div>
-          </div>
-          <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-            <div className="text-sm text-slate-400 mb-1">High Priority</div>
-            <div className="text-2xl font-bold text-red-400">
-              {summaries.filter((s) => s.deletionScore >= 15).length}
-            </div>
-          </div>
-          <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-            <div className="text-sm text-slate-400 mb-1">Review Needed</div>
-            <div className="text-2xl font-bold text-amber-400">
-              {summaries.filter((s) => s.deletionScore >= 8 && s.deletionScore < 15).length}
-            </div>
-          </div>
-          <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-            <div className="text-sm text-slate-400 mb-1">Keep</div>
-            <div className="text-2xl font-bold text-green-400">
-              {summaries.filter((s) => s.deletionScore < 8 || s.markCounts.KEEP_FOREVER > 0).length}
-            </div>
-          </div>
-        </div>
-
-        <UserFeedbackTable initialData={summaries} />
-      </div>
-    </div>
-  )
-}
diff --git a/app/api/admin/maintenance/media/route.ts b/app/api/admin/maintenance/media/route.ts
deleted file mode 100644
index bd3eb2e3..00000000
--- a/app/api/admin/maintenance/media/route.ts
+++ /dev/null
@@ -1,343 +0,0 @@
-/**
- * API route for fetching media from Radarr/Sonarr for rule testing.
- * Transforms raw API data into MediaItem format for client-side evaluation.
- */
-
-import { prisma } from "@/lib/prisma"
-import { requireAdminAPI } from "@/lib/security/api-helpers"
-import { createSafeError, ErrorCode, getStatusCode, logError } from "@/lib/security/error-handler"
-import { adminRateLimiter } from "@/lib/security/rate-limit"
-import { getRadarrMovies } from "@/lib/connections/radarr"
-import { getSonarrSeries } from "@/lib/connections/sonarr"
-import { NextRequest, NextResponse } from "next/server"
-import type { RadarrParsed } from "@/lib/validations/radarr"
-import type { SonarrParsed } from "@/lib/validations/sonarr"
-
-import {
-  type RadarrMovie,
-  type SonarrSeries,
-  OVERSEERR_STATUS_LABELS,
-  fetchTautulliMovieData,
-  fetchTautulliSeriesData,
-  fetchPlexMovieData,
-  fetchPlexSeriesData,
-  fetchPlexPlaylistMap,
-  fetchOverseerrMovieData,
-  findTautulliMatch,
-  findPlexMatch,
-} from "@/lib/maintenance/services"
-
-export const dynamic = "force-dynamic"
-
-export async function GET(request: NextRequest) {
-  try {
-    const rateLimitResponse = await adminRateLimiter(request)
-    if (rateLimitResponse) {
-      return rateLimitResponse
-    }
-
-    const authResult = await requireAdminAPI(request)
-    if (authResult.response) {
-      return authResult.response
-    }
-
-    const { searchParams } = new URL(request.url)
-    const mediaType = searchParams.get("mediaType") || "MOVIE"
-    const search = searchParams.get("search") || ""
-    const limit = parseInt(searchParams.get("limit") || "50", 10)
-
-    if (mediaType === "MOVIE") {
-      return await fetchMovies(search, limit)
-    } else if (mediaType === "TV_SERIES") {
-      return await fetchSeries(search, limit)
-    } else {
-      return NextResponse.json(
-        createSafeError(ErrorCode.VALIDATION_ERROR, "Invalid media type"),
-        { status: getStatusCode(ErrorCode.VALIDATION_ERROR) }
-      )
-    }
-  } catch (error) {
-    logError("MAINTENANCE_MEDIA_API", error)
-    return NextResponse.json(
-      createSafeError(ErrorCode.INTERNAL_ERROR, "Failed to fetch media"),
-      { status: getStatusCode(ErrorCode.INTERNAL_ERROR) }
-    )
-  }
-}
-
-async function fetchMovies(search: string, limit: number) {
-  const radarr = await prisma.radarr.findFirst({
-    where: { isActive: true },
-  })
-
-  if (!radarr) {
-    return NextResponse.json({ items: [], error: "No active Radarr server configured" })
-  }
-
-  const radarrConfig: RadarrParsed = {
-    url: radarr.url,
-    apiKey: radarr.apiKey,
-    name: radarr.name,
-  }
-
-  const result = await getRadarrMovies(radarrConfig)
-  if (!result.success) {
-    return NextResponse.json({ items: [], error: result.error })
-  }
-  if (!result.data) {
-    return NextResponse.json({ items: [], error: "No data returned from Radarr" })
-  }
-
-  const movies = result.data as RadarrMovie[]
-
-  // Fetch additional service data in parallel
-  const [tautulliData, plexData, overseerrData, playlistMap] = await Promise.all([
-    fetchTautulliMovieData(),
-    fetchPlexMovieData(),
-    fetchOverseerrMovieData(movies.filter((m) => m.tmdbId).map((m) => m.tmdbId!)),
-    fetchPlexPlaylistMap(),
-  ])
-
-  // Filter by search term if provided
-  let filtered = movies
-  if (search) {
-    const searchLower = search.toLowerCase()
-    filtered = movies.filter((movie) => movie.title.toLowerCase().includes(searchLower))
-  }
-
-  // Transform to MediaItem format and limit results
-  const items = filtered.slice(0, limit).map((movie) => {
-    const tautulliItem = findTautulliMatch(movie, tautulliData)
-    const plexItem = findPlexMatch(movie, plexData)
-    const overseerrItem = movie.tmdbId ? overseerrData.get(`movie_${movie.tmdbId}`) : undefined
-
-    return transformMovieToMediaItem(movie, tautulliItem, plexItem, overseerrItem, playlistMap)
-  })
-
-  return NextResponse.json({ items })
-}
-
-async function fetchSeries(search: string, limit: number) {
-  const sonarr = await prisma.sonarr.findFirst({
-    where: { isActive: true },
-  })
-
-  if (!sonarr) {
-    return NextResponse.json({ items: [], error: "No active Sonarr server configured" })
-  }
-
-  const sonarrConfig: SonarrParsed = {
-    url: sonarr.url,
-    apiKey: sonarr.apiKey,
-    name: sonarr.name,
-  }
-
-  const result = await getSonarrSeries(sonarrConfig)
-  if (!result.success) {
-    return NextResponse.json({ items: [], error: result.error })
-  }
-  if (!result.data) {
-    return NextResponse.json({ items: [], error: "No data returned from Sonarr" })
-  }
-
-  const series = result.data as SonarrSeries[]
-
-  // Fetch additional service data in parallel
-  const [tautulliData, plexData, playlistMap] = await Promise.all([
-    fetchTautulliSeriesData(),
-    fetchPlexSeriesData(),
-    fetchPlexPlaylistMap(),
-  ])
-
-  // Filter by search term if provided
-  let filtered = series
-  if (search) {
-    const searchLower = search.toLowerCase()
-    filtered = series.filter((s) => s.title.toLowerCase().includes(searchLower))
-  }
-
-  // Transform to MediaItem format and limit results
-  const items = filtered.slice(0, limit).map((s) => {
-    const tautulliItem = findTautulliMatch(s, tautulliData)
-    const plexItem = findPlexMatch(s, plexData)
-
-    return transformSeriesToMediaItem(s, tautulliItem, plexItem, playlistMap)
-  })
-
-  return NextResponse.json({ items })
-}
-
-function transformMovieToMediaItem(
-  movie: RadarrMovie,
-  tautulliItem: any,
-  plexItem: any,
-  overseerrItem: any,
-  playlistMap: Map<string, string[]>
-) {
-  return {
-    id: String(movie.id),
-    title: movie.title,
-    year: movie.year,
-    mediaType: "MOVIE" as const,
-    genres: movie.genres || [],
-
-    plex: plexItem
-      ? {
-          ratingKey: plexItem.ratingKey,
-          viewCount: plexItem.viewCount ?? 0,
-          lastViewedAt: plexItem.lastViewedAt ? new Date(plexItem.lastViewedAt * 1000) : null,
-          addedAt: plexItem.addedAt ? new Date(plexItem.addedAt * 1000) : null,
-          thumb: plexItem.thumb ?? null,
-          audienceRating: plexItem.audienceRating ?? null,
-          contentRating: plexItem.contentRating ?? null,
-          studio: plexItem.studio ?? null,
-          duration: plexItem.duration ?? null,
-          guid: plexItem.guid ?? null,
-          playlists: playlistMap.get(plexItem.ratingKey) || [],
-        }
-      : null,
-
-    tautulli: tautulliItem
-      ? {
-          plexRatingKey: tautulliItem.rating_key,
-          playCount: tautulliItem.play_count ?? 0,
-          lastWatchedAt: tautulliItem.last_played ? new Date(tautulliItem.last_played * 1000) : null,
-          addedAt: tautulliItem.added_at ? new Date(tautulliItem.added_at * 1000) : null,
-          fileSize: tautulliItem.file_size ?? null,
-          filePath: tautulliItem.file ?? null,
-          duration: tautulliItem.duration ? Math.round(tautulliItem.duration / 60000) : null,
-          videoCodec: tautulliItem.video_codec ?? null,
-          audioCodec: tautulliItem.audio_codec ?? null,
-          resolution: tautulliItem.video_resolution ?? null,
-          bitrate: tautulliItem.bitrate ?? null,
-          container: tautulliItem.container ?? null,
-        }
-      : null,
-
-    radarr: {
-      hasFile: movie.hasFile,
-      monitored: movie.monitored,
-      qualityProfileId: movie.qualityProfileId,
-      minimumAvailability: movie.minimumAvailability,
-      status: movie.status,
-      tmdbRating: movie.ratings?.tmdb?.value ?? null,
-      digitalRelease: movie.digitalRelease ? new Date(movie.digitalRelease) : null,
-      inCinemas: movie.inCinemas ? new Date(movie.inCinemas) : null,
-      runtime: movie.runtime ?? null,
-      tags: movie.tags || [],
-      sizeOnDisk: movie.sizeOnDisk ?? 0,
-      addedAt: movie.added ? new Date(movie.added) : null,
-      tmdbId: movie.tmdbId ?? null,
-      imdbId: movie.imdbId ?? null,
-    },
-
-    overseerr: overseerrItem
-      ? {
-          mediaStatus: overseerrItem.status,
-          status: OVERSEERR_STATUS_LABELS[overseerrItem.status] || "unknown",
-          hasRequest: overseerrItem.hasRequest,
-          requestedBy: overseerrItem.requestedBy ?? null,
-          requestedAt: overseerrItem.requestedAt ?? null,
-          isRequested: overseerrItem.hasRequest,
-          requestCount: overseerrItem.requestCount,
-          tmdbId: movie.tmdbId ?? null,
-        }
-      : null,
-
-    playCount: tautulliItem?.play_count ?? plexItem?.viewCount ?? 0,
-    lastWatchedAt: tautulliItem?.last_played
-      ? new Date(tautulliItem.last_played * 1000)
-      : plexItem?.lastViewedAt
-        ? new Date(plexItem.lastViewedAt * 1000)
-        : null,
-    addedAt: tautulliItem?.added_at
-      ? new Date(tautulliItem.added_at * 1000)
-      : plexItem?.addedAt
-        ? new Date(plexItem.addedAt * 1000)
-        : movie.added
-          ? new Date(movie.added)
-          : null,
-  }
-}
-
-function transformSeriesToMediaItem(
-  series: SonarrSeries,
-  tautulliItem: any,
-  plexItem: any,
-  playlistMap: Map<string, string[]>
-) {
-  return {
-    id: String(series.id),
-    title: series.title,
-    year: series.year,
-    mediaType: "TV_SERIES" as const,
-    genres: series.genres || [],
-
-    plex: plexItem
-      ? {
-          ratingKey: plexItem.ratingKey,
-          viewCount: plexItem.viewCount ?? 0,
-          lastViewedAt: plexItem.lastViewedAt ? new Date(plexItem.lastViewedAt * 1000) : null,
-          addedAt: plexItem.addedAt ? new Date(plexItem.addedAt * 1000) : null,
-          thumb: plexItem.thumb ?? null,
-          audienceRating: plexItem.audienceRating ?? null,
-          contentRating: plexItem.contentRating ?? null,
-          studio: plexItem.studio ?? null,
-          duration: plexItem.duration ?? null,
-          guid: plexItem.guid ?? null,
-          playlists: playlistMap.get(plexItem.ratingKey) || [],
-        }
-      : null,
-
-    tautulli: tautulliItem
-      ? {
-          plexRatingKey: tautulliItem.rating_key,
-          playCount: tautulliItem.play_count ?? 0,
-          lastWatchedAt: tautulliItem.last_played ? new Date(tautulliItem.last_played * 1000) : null,
-          addedAt: tautulliItem.added_at ? new Date(tautulliItem.added_at * 1000) : null,
-          fileSize: tautulliItem.file_size ?? null,
-          filePath: tautulliItem.file ?? null,
-          duration: tautulliItem.duration ? Math.round(tautulliItem.duration / 60000) : null,
-          videoCodec: tautulliItem.video_codec ?? null,
-          audioCodec: tautulliItem.audio_codec ?? null,
-          resolution: tautulliItem.video_resolution ?? null,
-          bitrate: tautulliItem.bitrate ?? null,
-          container: tautulliItem.container ?? null,
-        }
-      : null,
-
-    sonarr: {
-      monitored: series.monitored,
-      status: series.status,
-      seriesType: series.seriesType,
-      network: series.network ?? null,
-      seasonCount: series.statistics?.seasonCount ?? 0,
-      totalEpisodeCount: series.statistics?.totalEpisodeCount ?? 0,
-      episodeFileCount: series.statistics?.episodeFileCount ?? 0,
-      percentOfEpisodes: series.statistics?.percentOfEpisodes ?? null,
-      firstAired: series.firstAired ? new Date(series.firstAired) : null,
-      ended: series.ended,
-      tags: series.tags || [],
-      sizeOnDisk: series.statistics?.sizeOnDisk ?? 0,
-      certification: series.certification ?? null,
-      qualityProfileId: series.qualityProfileId,
-      addedAt: series.added ? new Date(series.added) : null,
-      tvdbId: series.tvdbId ?? null,
-      imdbId: series.imdbId ?? null,
-    },
-
-    playCount: tautulliItem?.play_count ?? plexItem?.viewCount ?? 0,
-    lastWatchedAt: tautulliItem?.last_played
-      ? new Date(tautulliItem.last_played * 1000)
-      : plexItem?.lastViewedAt
-        ? new Date(plexItem.lastViewedAt * 1000)
-        : null,
-    addedAt: tautulliItem?.added_at
-      ? new Date(tautulliItem.added_at * 1000)
-      : plexItem?.addedAt
-        ? new Date(plexItem.addedAt * 1000)
-        : series.added
-          ? new Date(series.added)
-          : null,
-  }
-}
diff --git a/app/api/admin/radarr/route.ts b/app/api/admin/radarr/route.ts
index 47309a5a..ed10849d 100644
--- a/app/api/admin/radarr/route.ts
+++ b/app/api/admin/radarr/route.ts
@@ -9,7 +9,7 @@ import { NextRequest, NextResponse } from "next/server"
  *
  * Uses API route instead of Server Action because this endpoint is consumed
  * by client-side components that need to fetch server lists dynamically
- * (e.g., for dropdowns/selectors in maintenance rule creation).
+ * (e.g., for dropdowns/selectors in admin interfaces).
  * API routes are preferred for GET operations that need to be called from
  * client components with proper HTTP caching and conditional requests.
  */
diff --git a/app/api/admin/sonarr/route.ts b/app/api/admin/sonarr/route.ts
index 68f8e2a2..0f787d01 100644
--- a/app/api/admin/sonarr/route.ts
+++ b/app/api/admin/sonarr/route.ts
@@ -9,7 +9,7 @@ import { NextRequest, NextResponse } from "next/server"
  *
  * Uses API route instead of Server Action because this endpoint is consumed
  * by client-side components that need to fetch server lists dynamically
- * (e.g., for dropdowns/selectors in maintenance rule creation).
+ * (e.g., for dropdowns/selectors in admin interfaces).
  * API routes are preferred for GET operations that need to be called from
  * client components with proper HTTP caching and conditional requests.
  */
diff --git a/components/__tests__/admin-shared.test.tsx b/components/__tests__/admin-shared.test.tsx
index 0e1a653e..b66f5946 100644
--- a/components/__tests__/admin-shared.test.tsx
+++ b/components/__tests__/admin-shared.test.tsx
@@ -317,8 +317,8 @@ describe('AdminNav', () => {
       render(<AdminNav />)
 
       // Mobile view shows only first word of labels for primary items
-      // Maintenance Overview becomes "Overview" in the bottom bar
-      const mobileLabels = screen.getAllByText('Overview')
+      // Share Analytics becomes "Share" in the bottom bar
+      const mobileLabels = screen.getAllByText('Share')
       expect(mobileLabels.length).toBeGreaterThan(0)
     })
 
@@ -405,7 +405,7 @@ describe('AdminNav', () => {
       const { container } = render(<AdminNav />)
 
       const sectionHeaders = container.querySelectorAll('.text-xs.font-semibold.text-slate-500')
-      expect(sectionHeaders.length).toBe(3) // Library Maintenance, Analytics, and Prompts & Testing
+      expect(sectionHeaders.length).toBe(2) // Analytics, and Prompts & Testing
     })
   })
 
@@ -559,12 +559,10 @@ describe('AdminNav', () => {
       const moreButton = screen.getByTestId('admin-nav-more-mobile')
       await user.click(moreButton)
 
-      // Check for secondary items in the menu
-      expect(screen.getByTestId('admin-nav-share-analytics-mobile')).toBeInTheDocument()
-      expect(screen.getByTestId('admin-nav-maintenance-rules-mobile')).toBeInTheDocument()
-      expect(screen.getByTestId('admin-nav-maintenance-candidates-mobile')).toBeInTheDocument()
+      // Check for secondary items in the menu (analytics + config nav items)
       expect(screen.getByTestId('admin-nav-llm-usage-mobile')).toBeInTheDocument()
       expect(screen.getByTestId('admin-nav-cost-analysis-mobile')).toBeInTheDocument()
+      expect(screen.getByTestId('admin-nav-discord-mobile')).toBeInTheDocument()
       expect(screen.getByTestId('admin-nav-prompts-mobile')).toBeInTheDocument()
       expect(screen.getByTestId('admin-nav-playground-mobile')).toBeInTheDocument()
     })
@@ -599,8 +597,8 @@ describe('AdminNav', () => {
       const moreButton = screen.getByTestId('admin-nav-more-mobile')
       await user.click(moreButton)
 
-      const shareAnalytics = screen.getByTestId('admin-nav-share-analytics-mobile')
-      expect(shareAnalytics).toHaveAttribute('role', 'menuitem')
+      const llmUsage = screen.getByTestId('admin-nav-llm-usage-mobile')
+      expect(llmUsage).toHaveAttribute('role', 'menuitem')
 
       const home = screen.getByTestId('admin-nav-home-mobile')
       expect(home).toHaveAttribute('role', 'menuitem')
@@ -675,7 +673,7 @@ describe('AdminNav', () => {
       // Primary items should be visible in bottom bar (search within mobile nav)
       expect(mobileNav?.querySelector('[data-testid="admin-nav-users-mobile"]')).toBeInTheDocument()
       expect(mobileNav?.querySelector('[data-testid="admin-nav-invites-mobile"]')).toBeInTheDocument()
-      expect(mobileNav?.querySelector('[data-testid="admin-nav-maintenance-overview-mobile"]')).toBeInTheDocument()
+      expect(mobileNav?.querySelector('[data-testid="admin-nav-share-analytics-mobile"]')).toBeInTheDocument()
       expect(mobileNav?.querySelector('[data-testid="admin-nav-settings-mobile"]')).toBeInTheDocument()
     })
 
@@ -760,7 +758,7 @@ describe('AdminNav', () => {
       await user.click(moreButton)
 
       // First menu item should be focused (wait for async focus)
-      const firstMenuItem = screen.getByTestId('admin-nav-share-analytics-mobile')
+      const firstMenuItem = screen.getByTestId('admin-nav-llm-usage-mobile')
       await waitFor(() => {
         expect(firstMenuItem).toHaveFocus()
       })
@@ -774,14 +772,14 @@ describe('AdminNav', () => {
       await user.click(moreButton)
 
       // Wait for first item to be focused
-      const firstMenuItem = screen.getByTestId('admin-nav-share-analytics-mobile')
+      const firstMenuItem = screen.getByTestId('admin-nav-llm-usage-mobile')
       await waitFor(() => {
         expect(firstMenuItem).toHaveFocus()
       })
 
       // Press ArrowDown to go to second item
       await user.keyboard('{ArrowDown}')
-      const secondMenuItem = screen.getByTestId('admin-nav-maintenance-rules-mobile')
+      const secondMenuItem = screen.getByTestId('admin-nav-cost-analysis-mobile')
       expect(secondMenuItem).toHaveFocus()
 
       // Press ArrowUp to go back to first item
@@ -797,13 +795,13 @@ describe('AdminNav', () => {
       await user.click(moreButton)
 
       // Wait for first item to be focused
-      const firstMenuItem = screen.getByTestId('admin-nav-share-analytics-mobile')
+      const firstMenuItem = screen.getByTestId('admin-nav-llm-usage-mobile')
       await waitFor(() => {
         expect(firstMenuItem).toHaveFocus()
       })
 
-      // Navigate to last item (Sign Out) - there are 12 items total (10 menu items + Home + Sign Out)
-      for (let i = 0; i < 11; i++) {
+      // Navigate to last item (Sign Out) - there are 7 items total (5 menu items + Home + Sign Out)
+      for (let i = 0; i < 6; i++) {
         await user.keyboard('{ArrowDown}')
       }
 
@@ -822,7 +820,7 @@ describe('AdminNav', () => {
       const moreButton = screen.getByTestId('admin-nav-more-mobile')
       await user.click(moreButton)
 
-      const firstMenuItem = screen.getByTestId('admin-nav-share-analytics-mobile')
+      const firstMenuItem = screen.getByTestId('admin-nav-llm-usage-mobile')
       expect(firstMenuItem).toHaveClass('focus-visible:ring-2')
       expect(firstMenuItem).toHaveClass('focus-visible:ring-cyan-500')
     })
diff --git a/components/admin/maintenance/candidates/CandidateActions.tsx b/components/admin/maintenance/candidates/CandidateActions.tsx
deleted file mode 100644
index 6304f83b..00000000
--- a/components/admin/maintenance/candidates/CandidateActions.tsx
+++ /dev/null
@@ -1,43 +0,0 @@
-"use client"
-
-import { Button } from "@/components/ui/button"
-import { Check, X } from "lucide-react"
-
-interface CandidateActionsProps {
-  selectedCount: number
-  onBulkApprove: () => void
-  onBulkReject: () => void
-  isPending: boolean
-}
-
-export function CandidateActions({
-  selectedCount,
-  onBulkApprove,
-  onBulkReject,
-  isPending,
-}: CandidateActionsProps) {
-  return (
-    <div className={`flex gap-2 ${selectedCount === 0 ? 'hidden' : ''}`}>
-      <Button
-        onClick={onBulkApprove}
-        disabled={isPending}
-        variant="success"
-        size="md"
-        data-testid="bulk-approve-button"
-      >
-        <Check className="w-4 h-4" />
-        Approve ({selectedCount})
-      </Button>
-      <Button
-        onClick={onBulkReject}
-        disabled={isPending}
-        variant="danger"
-        size="md"
-        data-testid="bulk-reject-button"
-      >
-        <X className="w-4 h-4" />
-        Reject ({selectedCount})
-      </Button>
-    </div>
-  )
-}
diff --git a/components/admin/maintenance/candidates/CandidateFilters.tsx b/components/admin/maintenance/candidates/CandidateFilters.tsx
deleted file mode 100644
index db8692d8..00000000
--- a/components/admin/maintenance/candidates/CandidateFilters.tsx
+++ /dev/null
@@ -1,54 +0,0 @@
-"use client"
-
-import type { ReviewStatus, MediaType } from "@/lib/validations/maintenance"
-import { StyledDropdown } from "@/components/ui/styled-dropdown"
-
-interface CandidateFiltersProps {
-  reviewStatusFilter: ReviewStatus | "ALL"
-  mediaTypeFilter: MediaType | "ALL"
-  onReviewStatusChange: (status: ReviewStatus | "ALL") => void
-  onMediaTypeChange: (type: MediaType | "ALL") => void
-}
-
-export function CandidateFilters({
-  reviewStatusFilter,
-  mediaTypeFilter,
-  onReviewStatusChange,
-  onMediaTypeChange,
-}: CandidateFiltersProps) {
-  return (
-    <div className="flex gap-3 flex-wrap" data-testid="candidate-filters-container">
-      <div>
-        <label className="text-xs text-slate-400 mb-1 block">Review Status</label>
-        <StyledDropdown
-          value={reviewStatusFilter}
-          onChange={(value) => onReviewStatusChange(value as ReviewStatus | "ALL")}
-          options={[
-            { value: "ALL", label: "All Status" },
-            { value: "PENDING", label: "Pending" },
-            { value: "APPROVED", label: "Approved" },
-            { value: "REJECTED", label: "Rejected" },
-          ]}
-          size="md"
-          data-testid="review-status-filter"
-        />
-      </div>
-
-      <div>
-        <label className="text-xs text-slate-400 mb-1 block">Media Type</label>
-        <StyledDropdown
-          value={mediaTypeFilter}
-          onChange={(value) => onMediaTypeChange(value as MediaType | "ALL")}
-          options={[
-            { value: "ALL", label: "All Types" },
-            { value: "MOVIE", label: "Movie" },
-            { value: "TV_SERIES", label: "TV Series" },
-            { value: "EPISODE", label: "Episode" },
-          ]}
-          size="md"
-          data-testid="media-type-filter"
-        />
-      </div>
-    </div>
-  )
-}
diff --git a/components/admin/maintenance/candidates/CandidateList.tsx b/components/admin/maintenance/candidates/CandidateList.tsx
deleted file mode 100644
index b1fb834c..00000000
--- a/components/admin/maintenance/candidates/CandidateList.tsx
+++ /dev/null
@@ -1,165 +0,0 @@
-"use client"
-
-import type { MaintenanceCandidate } from "@/types/maintenance"
-import { StyledCheckbox } from "@/components/ui/styled-checkbox"
-import { formatFileSize, formatDate, getMediaTypeLabel } from "@/lib/utils/formatters"
-import { CheckCircle, Film, Check, X } from "lucide-react"
-import { Button } from "@/components/ui/button"
-
-interface CandidateListProps {
-  candidates: MaintenanceCandidate[]
-  selectedCandidates: Set<string>
-  onToggleCandidate: (id: string) => void
-  onToggleAll: () => void
-  onApprove: (id: string) => void
-  onReject: (id: string) => void
-  isPending: boolean
-}
-
-export function CandidateList({
-  candidates,
-  selectedCandidates,
-  onToggleCandidate,
-  onToggleAll,
-  onApprove,
-  onReject,
-  isPending,
-}: CandidateListProps) {
-  if (candidates.length === 0) {
-    return (
-      <div className="text-center py-12 bg-slate-800/50 rounded-lg border border-slate-700" data-testid="candidates-empty-state">
-        <CheckCircle className="w-12 h-12 text-slate-500 mx-auto mb-4" />
-        <h3 className="text-lg font-medium text-white mb-2">No candidates found</h3>
-        <p className="text-slate-400">No media matching the current filters.</p>
-      </div>
-    )
-  }
-
-  return (
-    <div className="bg-slate-800/50 rounded-lg border border-slate-700 overflow-hidden">
-      <div className="overflow-x-auto">
-        <table className="w-full text-left">
-          <thead>
-            <tr className="bg-slate-900/50 border-b border-slate-700">
-              <th className="px-6 py-4">
-                <StyledCheckbox
-                  checked={selectedCandidates.size === candidates.length && candidates.length > 0}
-                  onChange={onToggleAll}
-                  data-testid="select-all-candidates"
-                />
-              </th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Media</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Type</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">File Size</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Play Count</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Last Watched</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Matched Rule</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Status</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Actions</th>
-            </tr>
-          </thead>
-          <tbody className="divide-y divide-slate-700">
-            {candidates.map((candidate) => (
-              <tr key={candidate.id} className="hover:bg-slate-800/50 transition-colors" data-testid={`candidate-row-${candidate.id}`}>
-                <td className="px-6 py-4">
-                  <StyledCheckbox
-                    checked={selectedCandidates.has(candidate.id)}
-                    onChange={() => onToggleCandidate(candidate.id)}
-                    data-testid={`select-candidate-${candidate.id}`}
-                  />
-                </td>
-                <td className="px-6 py-4">
-                  <div className="flex items-center gap-3">
-                    {candidate.poster ? (
-                      <img
-                        src={candidate.poster}
-                        alt={candidate.title}
-                        className="w-10 h-14 object-cover rounded"
-                      />
-                    ) : (
-                      <div className="w-10 h-14 bg-slate-700 rounded flex items-center justify-center">
-                        <Film className="w-5 h-5 text-slate-500" />
-                      </div>
-                    )}
-                    <div>
-                      <div className="text-sm font-medium text-white">{candidate.title}</div>
-                      {candidate.year && (
-                        <div className="text-xs text-slate-400">{candidate.year}</div>
-                      )}
-                    </div>
-                  </div>
-                </td>
-                <td className="px-6 py-4">
-                  <span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-400/10 text-blue-400">
-                    {getMediaTypeLabel(candidate.mediaType)}
-                  </span>
-                </td>
-                <td className="px-6 py-4 text-sm text-slate-400">
-                  {formatFileSize(candidate.fileSize)}
-                </td>
-                <td className="px-6 py-4 text-sm text-slate-400">
-                  {candidate.playCount}
-                </td>
-                <td className="px-6 py-4 text-sm text-slate-400">
-                  {formatDate(candidate.lastWatchedAt)}
-                </td>
-                <td className="px-6 py-4">
-                  <div className="text-sm text-white">{candidate.scan.rule.name}</div>
-                  <div className={`text-xs mt-1 ${
-                    candidate.scan.rule.actionType === 'AUTO_DELETE'
-                      ? 'text-red-400'
-                      : 'text-yellow-400'
-                  }`}>
-                    {candidate.scan.rule.actionType === 'AUTO_DELETE' ? 'Auto Delete' : 'Flag for Review'}
-                  </div>
-                </td>
-                <td className="px-6 py-4">
-                  <span className={`inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${
-                    candidate.reviewStatus === 'APPROVED' ? 'bg-green-400/10 text-green-400' :
-                    candidate.reviewStatus === 'REJECTED' ? 'bg-red-400/10 text-red-400' :
-                    candidate.reviewStatus === 'DELETED' ? 'bg-slate-400/10 text-slate-400' :
-                    'bg-yellow-400/10 text-yellow-400'
-                  }`}>
-                    {candidate.reviewStatus}
-                  </span>
-                </td>
-                <td className="px-6 py-4">
-                  <div className="flex items-center gap-2">
-                    {candidate.reviewStatus === 'PENDING' && (
-                      <>
-                        <Button
-                          onClick={() => onApprove(candidate.id)}
-                          disabled={isPending}
-                          variant="ghost"
-                          size="sm"
-                          className="text-green-400 hover:text-green-300"
-                          title="Approve"
-                          aria-label="Approve"
-                          data-testid={`approve-candidate-${candidate.id}`}
-                        >
-                          <Check className="w-5 h-5" />
-                        </Button>
-                        <Button
-                          onClick={() => onReject(candidate.id)}
-                          disabled={isPending}
-                          variant="ghost"
-                          size="sm"
-                          className="text-red-400 hover:text-red-300"
-                          title="Reject"
-                          aria-label="Reject"
-                          data-testid={`reject-candidate-${candidate.id}`}
-                        >
-                          <X className="w-5 h-5" />
-                        </Button>
-                      </>
-                    )}
-                  </div>
-                </td>
-              </tr>
-            ))}
-          </tbody>
-        </table>
-      </div>
-    </div>
-  )
-}
diff --git a/components/admin/maintenance/candidates/__tests__/CandidateActions.test.tsx b/components/admin/maintenance/candidates/__tests__/CandidateActions.test.tsx
deleted file mode 100644
index 3ed963b7..00000000
--- a/components/admin/maintenance/candidates/__tests__/CandidateActions.test.tsx
+++ /dev/null
@@ -1,184 +0,0 @@
-import { CandidateActions } from '../CandidateActions'
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-
-// Mock lucide-react icons
-jest.mock('lucide-react', () => ({
-  Check: () => <div data-testid="check-icon" />,
-  X: () => <div data-testid="x-icon" />,
-}))
-
-// Mock Button component
-jest.mock('@/components/ui/button', () => ({
-  Button: ({ children, onClick, disabled, variant, 'data-testid': dataTestId }: {
-    children: React.ReactNode
-    onClick: () => void
-    disabled?: boolean
-    variant?: string
-    'data-testid'?: string
-  }) => (
-    <button
-      onClick={onClick}
-      disabled={disabled}
-      data-variant={variant}
-      data-testid={dataTestId}
-    >
-      {children}
-    </button>
-  ),
-}))
-
-describe('CandidateActions', () => {
-  const defaultProps = {
-    selectedCount: 5,
-    onBulkApprove: jest.fn(),
-    onBulkReject: jest.fn(),
-    isPending: false,
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('Rendering', () => {
-    it('should render both approve and reject buttons when candidates are selected', () => {
-      render(<CandidateActions {...defaultProps} />)
-
-      expect(screen.getByTestId('bulk-approve-button')).toBeInTheDocument()
-      expect(screen.getByTestId('bulk-reject-button')).toBeInTheDocument()
-    })
-
-    it('should display selected count in button text', () => {
-      render(<CandidateActions {...defaultProps} selectedCount={3} />)
-
-      expect(screen.getByText(/Approve \(3\)/)).toBeInTheDocument()
-      expect(screen.getByText(/Reject \(3\)/)).toBeInTheDocument()
-    })
-
-    it('should hide buttons when selectedCount is 0', () => {
-      const { container } = render(<CandidateActions {...defaultProps} selectedCount={0} />)
-
-      // Buttons exist in DOM but container is hidden
-      const containerDiv = container.firstChild as HTMLElement
-      expect(containerDiv).toBeInTheDocument()
-      expect(containerDiv).toHaveClass('hidden')
-      expect(screen.getByTestId('bulk-approve-button')).toBeInTheDocument()
-      expect(screen.getByTestId('bulk-reject-button')).toBeInTheDocument()
-    })
-
-    it('should render icons in buttons', () => {
-      render(<CandidateActions {...defaultProps} />)
-
-      expect(screen.getByTestId('check-icon')).toBeInTheDocument()
-      expect(screen.getByTestId('x-icon')).toBeInTheDocument()
-    })
-  })
-
-  describe('Button Variants', () => {
-    it('should use success variant for approve button', () => {
-      render(<CandidateActions {...defaultProps} />)
-
-      const approveButton = screen.getByTestId('bulk-approve-button')
-      expect(approveButton).toHaveAttribute('data-variant', 'success')
-    })
-
-    it('should use danger variant for reject button', () => {
-      render(<CandidateActions {...defaultProps} />)
-
-      const rejectButton = screen.getByTestId('bulk-reject-button')
-      expect(rejectButton).toHaveAttribute('data-variant', 'danger')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onBulkApprove when approve button is clicked', async () => {
-      const user = userEvent.setup()
-      const onBulkApprove = jest.fn()
-
-      render(<CandidateActions {...defaultProps} onBulkApprove={onBulkApprove} />)
-
-      const approveButton = screen.getByTestId('bulk-approve-button')
-      await user.click(approveButton)
-
-      expect(onBulkApprove).toHaveBeenCalledTimes(1)
-    })
-
-    it('should call onBulkReject when reject button is clicked', async () => {
-      const user = userEvent.setup()
-      const onBulkReject = jest.fn()
-
-      render(<CandidateActions {...defaultProps} onBulkReject={onBulkReject} />)
-
-      const rejectButton = screen.getByTestId('bulk-reject-button')
-      await user.click(rejectButton)
-
-      expect(onBulkReject).toHaveBeenCalledTimes(1)
-    })
-  })
-
-  describe('Disabled State', () => {
-    it('should disable buttons when isPending is true', () => {
-      render(<CandidateActions {...defaultProps} isPending={true} />)
-
-      expect(screen.getByTestId('bulk-approve-button')).toBeDisabled()
-      expect(screen.getByTestId('bulk-reject-button')).toBeDisabled()
-    })
-
-    it('should enable buttons when isPending is false', () => {
-      render(<CandidateActions {...defaultProps} isPending={false} />)
-
-      expect(screen.getByTestId('bulk-approve-button')).not.toBeDisabled()
-      expect(screen.getByTestId('bulk-reject-button')).not.toBeDisabled()
-    })
-
-    it('should not call handlers when buttons are disabled and clicked', async () => {
-      const user = userEvent.setup()
-      const onBulkApprove = jest.fn()
-      const onBulkReject = jest.fn()
-
-      render(
-        <CandidateActions
-          {...defaultProps}
-          isPending={true}
-          onBulkApprove={onBulkApprove}
-          onBulkReject={onBulkReject}
-        />
-      )
-
-      const approveButton = screen.getByTestId('bulk-approve-button')
-      const rejectButton = screen.getByTestId('bulk-reject-button')
-
-      // Disabled buttons should not trigger handlers
-      await user.click(approveButton)
-      await user.click(rejectButton)
-
-      expect(onBulkApprove).not.toHaveBeenCalled()
-      expect(onBulkReject).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Different Selected Counts', () => {
-    it('should display count of 1 correctly', () => {
-      render(<CandidateActions {...defaultProps} selectedCount={1} />)
-
-      expect(screen.getByText(/Approve \(1\)/)).toBeInTheDocument()
-      expect(screen.getByText(/Reject \(1\)/)).toBeInTheDocument()
-    })
-
-    it('should display large counts correctly', () => {
-      render(<CandidateActions {...defaultProps} selectedCount={100} />)
-
-      expect(screen.getByText(/Approve \(100\)/)).toBeInTheDocument()
-      expect(screen.getByText(/Reject \(100\)/)).toBeInTheDocument()
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have data-testid attributes for testing', () => {
-      render(<CandidateActions {...defaultProps} />)
-
-      expect(screen.getByTestId('bulk-approve-button')).toBeInTheDocument()
-      expect(screen.getByTestId('bulk-reject-button')).toBeInTheDocument()
-    })
-  })
-})
diff --git a/components/admin/maintenance/candidates/__tests__/CandidateFilters.test.tsx b/components/admin/maintenance/candidates/__tests__/CandidateFilters.test.tsx
deleted file mode 100644
index 6c4413f5..00000000
--- a/components/admin/maintenance/candidates/__tests__/CandidateFilters.test.tsx
+++ /dev/null
@@ -1,180 +0,0 @@
-import { CandidateFilters } from '../CandidateFilters'
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-
-// Mock StyledDropdown component
-jest.mock('@/components/ui/styled-dropdown', () => ({
-  StyledDropdown: ({ value, onChange, options, 'data-testid': dataTestId }: {
-    value: string
-    onChange: (value: string) => void
-    options: Array<{ value: string; label: string }>
-    'data-testid'?: string
-  }) => (
-    <select
-      value={value}
-      onChange={(e) => onChange(e.target.value)}
-      data-testid={dataTestId}
-    >
-      {options.map((opt) => (
-        <option key={opt.value} value={opt.value}>
-          {opt.label}
-        </option>
-      ))}
-    </select>
-  ),
-}))
-
-describe('CandidateFilters', () => {
-  const defaultProps = {
-    reviewStatusFilter: 'PENDING' as const,
-    mediaTypeFilter: 'ALL' as const,
-    onReviewStatusChange: jest.fn(),
-    onMediaTypeChange: jest.fn(),
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('Rendering', () => {
-    it('should render both filter dropdowns', () => {
-      render(<CandidateFilters {...defaultProps} />)
-
-      expect(screen.getByTestId('review-status-filter')).toBeInTheDocument()
-      expect(screen.getByTestId('media-type-filter')).toBeInTheDocument()
-    })
-
-    it('should render filter labels', () => {
-      render(<CandidateFilters {...defaultProps} />)
-
-      expect(screen.getByText('Review Status')).toBeInTheDocument()
-      expect(screen.getByText('Media Type')).toBeInTheDocument()
-    })
-
-    it('should have correct container test id', () => {
-      render(<CandidateFilters {...defaultProps} />)
-
-      expect(screen.getByTestId('candidate-filters-container')).toBeInTheDocument()
-    })
-  })
-
-  describe('Review Status Filter', () => {
-    it('should display current review status value', () => {
-      render(<CandidateFilters {...defaultProps} reviewStatusFilter="APPROVED" />)
-
-      const select = screen.getByTestId('review-status-filter')
-      expect(select).toHaveValue('APPROVED')
-    })
-
-    it('should have all review status options', () => {
-      render(<CandidateFilters {...defaultProps} />)
-
-      const select = screen.getByTestId('review-status-filter')
-
-      expect(screen.getByText('All Status')).toBeInTheDocument()
-      expect(screen.getByText('Pending')).toBeInTheDocument()
-      expect(screen.getByText('Approved')).toBeInTheDocument()
-      expect(screen.getByText('Rejected')).toBeInTheDocument()
-    })
-
-    it('should call onReviewStatusChange when value changes', async () => {
-      const user = userEvent.setup()
-      const onReviewStatusChange = jest.fn()
-
-      render(<CandidateFilters {...defaultProps} onReviewStatusChange={onReviewStatusChange} />)
-
-      const select = screen.getByTestId('review-status-filter')
-      await user.selectOptions(select, 'APPROVED')
-
-      expect(onReviewStatusChange).toHaveBeenCalledWith('APPROVED')
-    })
-
-    it('should support "ALL" option', async () => {
-      const user = userEvent.setup()
-      const onReviewStatusChange = jest.fn()
-
-      render(<CandidateFilters {...defaultProps} onReviewStatusChange={onReviewStatusChange} />)
-
-      const select = screen.getByTestId('review-status-filter')
-      await user.selectOptions(select, 'ALL')
-
-      expect(onReviewStatusChange).toHaveBeenCalledWith('ALL')
-    })
-  })
-
-  describe('Media Type Filter', () => {
-    it('should display current media type value', () => {
-      render(<CandidateFilters {...defaultProps} mediaTypeFilter="MOVIE" />)
-
-      const select = screen.getByTestId('media-type-filter')
-      expect(select).toHaveValue('MOVIE')
-    })
-
-    it('should have all media type options', () => {
-      render(<CandidateFilters {...defaultProps} />)
-
-      expect(screen.getByText('All Types')).toBeInTheDocument()
-      expect(screen.getByText('Movie')).toBeInTheDocument()
-      expect(screen.getByText('TV Series')).toBeInTheDocument()
-      expect(screen.getByText('Episode')).toBeInTheDocument()
-    })
-
-    it('should call onMediaTypeChange when value changes', async () => {
-      const user = userEvent.setup()
-      const onMediaTypeChange = jest.fn()
-
-      render(<CandidateFilters {...defaultProps} onMediaTypeChange={onMediaTypeChange} />)
-
-      const select = screen.getByTestId('media-type-filter')
-      await user.selectOptions(select, 'MOVIE')
-
-      expect(onMediaTypeChange).toHaveBeenCalledWith('MOVIE')
-    })
-
-    it('should support "ALL" option', async () => {
-      const user = userEvent.setup()
-      const onMediaTypeChange = jest.fn()
-
-      render(<CandidateFilters {...defaultProps} onMediaTypeChange={onMediaTypeChange} />)
-
-      const select = screen.getByTestId('media-type-filter')
-      await user.selectOptions(select, 'ALL')
-
-      expect(onMediaTypeChange).toHaveBeenCalledWith('ALL')
-    })
-
-    it('should support TV_SERIES option', async () => {
-      const user = userEvent.setup()
-      const onMediaTypeChange = jest.fn()
-
-      render(<CandidateFilters {...defaultProps} onMediaTypeChange={onMediaTypeChange} />)
-
-      const select = screen.getByTestId('media-type-filter')
-      await user.selectOptions(select, 'TV_SERIES')
-
-      expect(onMediaTypeChange).toHaveBeenCalledWith('TV_SERIES')
-    })
-
-    it('should support EPISODE option', async () => {
-      const user = userEvent.setup()
-      const onMediaTypeChange = jest.fn()
-
-      render(<CandidateFilters {...defaultProps} onMediaTypeChange={onMediaTypeChange} />)
-
-      const select = screen.getByTestId('media-type-filter')
-      await user.selectOptions(select, 'EPISODE')
-
-      expect(onMediaTypeChange).toHaveBeenCalledWith('EPISODE')
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have proper label associations', () => {
-      render(<CandidateFilters {...defaultProps} />)
-
-      // Labels should be visible and properly associated
-      expect(screen.getByText('Review Status')).toBeInTheDocument()
-      expect(screen.getByText('Media Type')).toBeInTheDocument()
-    })
-  })
-})
diff --git a/components/admin/maintenance/candidates/__tests__/CandidateList.test.tsx b/components/admin/maintenance/candidates/__tests__/CandidateList.test.tsx
deleted file mode 100644
index 046faaf3..00000000
--- a/components/admin/maintenance/candidates/__tests__/CandidateList.test.tsx
+++ /dev/null
@@ -1,331 +0,0 @@
-import { CandidateList } from '../CandidateList'
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import type { MaintenanceCandidate } from '@/types/maintenance'
-
-// Mock lucide-react icons
-jest.mock('lucide-react', () => ({
-  CheckCircle: () => <div data-testid="check-circle-icon" />,
-  Film: () => <div data-testid="film-icon" />,
-  Check: () => <div data-testid="check-icon" />,
-  X: () => <div data-testid="x-icon" />,
-}))
-
-// Mock StyledCheckbox to return a proper input element for testing
-jest.mock('@/components/ui/styled-checkbox', () => ({
-  StyledCheckbox: ({ checked, onChange, 'data-testid': dataTestId }: {
-    checked?: boolean
-    onChange?: () => void
-    'data-testid'?: string
-  }) => (
-    <input
-      type="checkbox"
-      checked={checked}
-      onChange={onChange}
-      data-testid={dataTestId}
-    />
-  ),
-}))
-
-describe('CandidateList', () => {
-  const mockCandidate: MaintenanceCandidate = {
-    id: 'candidate-1',
-    mediaType: 'MOVIE',
-    plexRatingKey: '12345',
-    title: 'Test Movie',
-    year: 2023,
-    poster: '/poster.jpg',
-    fileSize: BigInt(5368709120), // 5 GB
-    playCount: 3,
-    lastWatchedAt: new Date('2024-01-15T12:00:00Z'),
-    addedAt: new Date('2023-06-01T00:00:00Z'),
-    reviewStatus: 'PENDING',
-    flaggedAt: new Date('2024-11-01T00:00:00Z'),
-    scan: {
-      id: 'scan-1',
-      rule: {
-        id: 'rule-1',
-        name: 'Old Unwatched Movies',
-        actionType: 'FLAG_FOR_REVIEW',
-      },
-    },
-  }
-
-  const defaultProps = {
-    candidates: [mockCandidate],
-    selectedCandidates: new Set<string>(),
-    onToggleCandidate: jest.fn(),
-    onToggleAll: jest.fn(),
-    onApprove: jest.fn(),
-    onReject: jest.fn(),
-    isPending: false,
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('Empty State', () => {
-    it('should display empty state when no candidates', () => {
-      render(<CandidateList {...defaultProps} candidates={[]} />)
-
-      expect(screen.getByTestId('candidates-empty-state')).toBeInTheDocument()
-      expect(screen.getByText('No candidates found')).toBeInTheDocument()
-      expect(screen.getByText('No media matching the current filters.')).toBeInTheDocument()
-    })
-  })
-
-  describe('Candidate Display', () => {
-    it('should render candidate with all details', () => {
-      render(<CandidateList {...defaultProps} />)
-
-      expect(screen.getByText('Test Movie')).toBeInTheDocument()
-      expect(screen.getByText('2023')).toBeInTheDocument()
-      expect(screen.getByText('Movie')).toBeInTheDocument()
-      expect(screen.getByText('5 GB')).toBeInTheDocument()
-      expect(screen.getByText('3')).toBeInTheDocument()
-      expect(screen.getByText('Old Unwatched Movies')).toBeInTheDocument()
-    })
-
-    it('should display poster image when available', () => {
-      render(<CandidateList {...defaultProps} />)
-
-      const poster = screen.getByAltText('Test Movie')
-      expect(poster).toBeInTheDocument()
-      expect(poster).toHaveAttribute('src', '/poster.jpg')
-    })
-
-    it('should display placeholder icon when no poster', () => {
-      const candidateWithoutPoster = { ...mockCandidate, poster: null }
-      render(<CandidateList {...defaultProps} candidates={[candidateWithoutPoster]} />)
-
-      expect(screen.queryByAltText('Test Movie')).not.toBeInTheDocument()
-      expect(screen.getByTestId('film-icon')).toBeInTheDocument()
-    })
-
-    it('should format file size correctly', () => {
-      render(<CandidateList {...defaultProps} />)
-      expect(screen.getByText('5 GB')).toBeInTheDocument()
-    })
-
-    it('should format dates correctly', () => {
-      render(<CandidateList {...defaultProps} />)
-
-      // formatDate returns localized format - could be M/D/YYYY or D/M/YYYY depending on locale
-      // The mock date is 2024-01-15, check that the formatted date is rendered
-      const formattedDate = new Date('2024-01-15T12:00:00Z').toLocaleDateString()
-      expect(screen.getByText(formattedDate)).toBeInTheDocument()
-    })
-
-    it('should display "Never" for null lastWatchedAt', () => {
-      const candidateNeverWatched = { ...mockCandidate, lastWatchedAt: null }
-      render(<CandidateList {...defaultProps} candidates={[candidateNeverWatched]} />)
-
-      expect(screen.getByText('Never')).toBeInTheDocument()
-    })
-
-    it('should display "Unknown" for null file size', () => {
-      const candidateNoFileSize = { ...mockCandidate, fileSize: null }
-      render(<CandidateList {...defaultProps} candidates={[candidateNoFileSize]} />)
-
-      expect(screen.getByText('Unknown')).toBeInTheDocument()
-    })
-
-    it('should not display year when null', () => {
-      const candidateNoYear = { ...mockCandidate, year: null }
-      render(<CandidateList {...defaultProps} candidates={[candidateNoYear]} />)
-
-      expect(screen.getByText('Test Movie')).toBeInTheDocument()
-      expect(screen.queryByText('2023')).not.toBeInTheDocument()
-    })
-
-    it('should display different media types correctly', () => {
-      const tvSeriesCandidate = { ...mockCandidate, mediaType: 'TV_SERIES' }
-      render(<CandidateList {...defaultProps} candidates={[tvSeriesCandidate]} />)
-
-      expect(screen.getByText('TV Series')).toBeInTheDocument()
-    })
-  })
-
-  describe('Selection', () => {
-    it('should call onToggleCandidate when individual checkbox is clicked', async () => {
-      const user = userEvent.setup()
-      const onToggleCandidate = jest.fn()
-
-      render(<CandidateList {...defaultProps} onToggleCandidate={onToggleCandidate} />)
-
-      const checkbox = screen.getByTestId('select-candidate-candidate-1')
-      await user.click(checkbox)
-
-      expect(onToggleCandidate).toHaveBeenCalledWith('candidate-1')
-    })
-
-    it('should call onToggleAll when select all checkbox is clicked', async () => {
-      const user = userEvent.setup()
-      const onToggleAll = jest.fn()
-
-      render(<CandidateList {...defaultProps} onToggleAll={onToggleAll} />)
-
-      const selectAllCheckbox = screen.getByTestId('select-all-candidates')
-      await user.click(selectAllCheckbox)
-
-      expect(onToggleAll).toHaveBeenCalled()
-    })
-
-    it('should show checkbox as checked when candidate is selected', () => {
-      const selectedCandidates = new Set(['candidate-1'])
-
-      render(<CandidateList {...defaultProps} selectedCandidates={selectedCandidates} />)
-
-      const checkbox = screen.getByTestId('select-candidate-candidate-1')
-      expect(checkbox).toBeChecked()
-    })
-
-    it('should show select all checkbox as checked when all candidates are selected', () => {
-      const selectedCandidates = new Set(['candidate-1'])
-
-      render(<CandidateList {...defaultProps} selectedCandidates={selectedCandidates} />)
-
-      const selectAllCheckbox = screen.getByTestId('select-all-candidates')
-      expect(selectAllCheckbox).toBeChecked()
-    })
-  })
-
-  describe('Actions', () => {
-    it('should show approve and reject buttons for pending candidates', () => {
-      render(<CandidateList {...defaultProps} />)
-
-      expect(screen.getByTestId('approve-candidate-candidate-1')).toBeInTheDocument()
-      expect(screen.getByTestId('reject-candidate-candidate-1')).toBeInTheDocument()
-    })
-
-    it('should not show action buttons for approved candidates', () => {
-      const approvedCandidate = { ...mockCandidate, reviewStatus: 'APPROVED' as const }
-      render(<CandidateList {...defaultProps} candidates={[approvedCandidate]} />)
-
-      expect(screen.queryByTestId('approve-candidate-candidate-1')).not.toBeInTheDocument()
-      expect(screen.queryByTestId('reject-candidate-candidate-1')).not.toBeInTheDocument()
-    })
-
-    it('should call onApprove when approve button is clicked', async () => {
-      const user = userEvent.setup()
-      const onApprove = jest.fn()
-
-      render(<CandidateList {...defaultProps} onApprove={onApprove} />)
-
-      const approveButton = screen.getByTestId('approve-candidate-candidate-1')
-      await user.click(approveButton)
-
-      expect(onApprove).toHaveBeenCalledWith('candidate-1')
-    })
-
-    it('should call onReject when reject button is clicked', async () => {
-      const user = userEvent.setup()
-      const onReject = jest.fn()
-
-      render(<CandidateList {...defaultProps} onReject={onReject} />)
-
-      const rejectButton = screen.getByTestId('reject-candidate-candidate-1')
-      await user.click(rejectButton)
-
-      expect(onReject).toHaveBeenCalledWith('candidate-1')
-    })
-
-    it('should disable action buttons when isPending is true', () => {
-      render(<CandidateList {...defaultProps} isPending={true} />)
-
-      expect(screen.getByTestId('approve-candidate-candidate-1')).toBeDisabled()
-      expect(screen.getByTestId('reject-candidate-candidate-1')).toBeDisabled()
-    })
-  })
-
-  describe('Review Status', () => {
-    it('should display correct badge color for approved status', () => {
-      const approvedCandidate = { ...mockCandidate, reviewStatus: 'APPROVED' as const }
-      render(<CandidateList {...defaultProps} candidates={[approvedCandidate]} />)
-
-      const badge = screen.getByText('APPROVED')
-      expect(badge).toHaveClass('bg-green-400/10', 'text-green-400')
-    })
-
-    it('should display correct badge color for rejected status', () => {
-      const rejectedCandidate = { ...mockCandidate, reviewStatus: 'REJECTED' as const }
-      render(<CandidateList {...defaultProps} candidates={[rejectedCandidate]} />)
-
-      const badge = screen.getByText('REJECTED')
-      expect(badge).toHaveClass('bg-red-400/10', 'text-red-400')
-    })
-
-    it('should display correct badge color for pending status', () => {
-      render(<CandidateList {...defaultProps} />)
-
-      const badge = screen.getByText('PENDING')
-      expect(badge).toHaveClass('bg-yellow-400/10', 'text-yellow-400')
-    })
-
-    it('should display correct badge color for deleted status', () => {
-      const deletedCandidate = { ...mockCandidate, reviewStatus: 'DELETED' as const }
-      render(<CandidateList {...defaultProps} candidates={[deletedCandidate]} />)
-
-      const badge = screen.getByText('DELETED')
-      expect(badge).toHaveClass('bg-slate-400/10', 'text-slate-400')
-    })
-  })
-
-  describe('Multiple Candidates', () => {
-    it('should render multiple candidates', () => {
-      const candidates = [
-        mockCandidate,
-        { ...mockCandidate, id: 'candidate-2', title: 'Test Movie 2' },
-        { ...mockCandidate, id: 'candidate-3', title: 'Test Movie 3' },
-      ]
-
-      render(<CandidateList {...defaultProps} candidates={candidates} />)
-
-      expect(screen.getByText('Test Movie')).toBeInTheDocument()
-      expect(screen.getByText('Test Movie 2')).toBeInTheDocument()
-      expect(screen.getByText('Test Movie 3')).toBeInTheDocument()
-    })
-
-    it('should show select all unchecked when not all candidates are selected', () => {
-      const candidates = [
-        mockCandidate,
-        { ...mockCandidate, id: 'candidate-2', title: 'Test Movie 2' },
-      ]
-      const selectedCandidates = new Set(['candidate-1']) // Only 1 of 2 selected
-
-      render(<CandidateList {...defaultProps} candidates={candidates} selectedCandidates={selectedCandidates} />)
-
-      const selectAllCheckbox = screen.getByTestId('select-all-candidates')
-      expect(selectAllCheckbox).not.toBeChecked()
-    })
-  })
-
-  describe('Action Type Display', () => {
-    it('should display "Flag for Review" in yellow for FLAG_FOR_REVIEW action type', () => {
-      render(<CandidateList {...defaultProps} />)
-
-      const actionLabel = screen.getByText('Flag for Review')
-      expect(actionLabel).toBeInTheDocument()
-      expect(actionLabel).toHaveClass('text-yellow-400')
-    })
-
-    it('should display "Auto Delete" in red for AUTO_DELETE action type', () => {
-      const autoDeleteCandidate = {
-        ...mockCandidate,
-        scan: {
-          ...mockCandidate.scan,
-          rule: {
-            ...mockCandidate.scan.rule,
-            actionType: 'AUTO_DELETE',
-          },
-        },
-      }
-      render(<CandidateList {...defaultProps} candidates={[autoDeleteCandidate]} />)
-
-      const actionLabel = screen.getByText('Auto Delete')
-      expect(actionLabel).toBeInTheDocument()
-      expect(actionLabel).toHaveClass('text-red-400')
-    })
-  })
-})
diff --git a/components/admin/maintenance/deletion-history-client.tsx b/components/admin/maintenance/deletion-history-client.tsx
deleted file mode 100644
index c2075101..00000000
--- a/components/admin/maintenance/deletion-history-client.tsx
+++ /dev/null
@@ -1,435 +0,0 @@
-"use client"
-
-import { useState } from "react"
-import Link from "next/link"
-import { useRouter } from "next/navigation"
-import { formatBytes } from "@/lib/utils/time-formatting"
-
-type DeletionLog = {
-  id: string
-  candidateId: string | null
-  mediaType: "MOVIE" | "TV_SERIES" | "EPISODE"
-  title: string
-  year: number | null
-  fileSize: bigint | null
-  deletedBy: string
-  deletedAt: Date
-  deletedFrom: string
-  filesDeleted: boolean
-  ruleNames: unknown
-}
-
-type Stats = {
-  totalDeletions: number
-  totalSpaceReclaimed: number
-  filesActuallyDeleted: number
-  deletionsThisMonth: number
-  byMediaType: Array<{ mediaType: string; count: number }>
-  byUser: Array<{ userId: string; count: number }>
-}
-
-type Pagination = {
-  page: number
-  pageSize: number
-  total: number
-  totalPages: number
-}
-
-type Props = {
-  deletions: DeletionLog[]
-  pagination: Pagination
-  stats: Stats
-  currentFilters: {
-    mediaType?: string
-    deletedBy?: string
-    filesDeleted?: string
-    startDate?: string
-    endDate?: string
-  }
-}
-
-export function DeletionHistoryClient({ deletions, pagination, stats, currentFilters }: Props) {
-  const router = useRouter()
-  const [filters, setFilters] = useState(currentFilters)
-  const [isExporting, setIsExporting] = useState(false)
-
-  const handleFilterChange = (key: string, value: string) => {
-    const newFilters = { ...filters, [key]: value || undefined }
-    setFilters(newFilters)
-
-    // Build query string
-    const params = new URLSearchParams()
-    Object.entries(newFilters).forEach(([k, v]) => {
-      if (v) params.set(k, v)
-    })
-
-    router.push(`/admin/maintenance/history?${params.toString()}`)
-  }
-
-  const handleExportCSV = () => {
-    setIsExporting(true)
-
-    try {
-      // Build CSV content
-      const headers = [
-        "Title",
-        "Year",
-        "Media Type",
-        "Deleted At",
-        "Deleted By",
-        "File Size",
-        "Files Deleted",
-        "Deleted From",
-        "Rules",
-      ]
-
-      const rows = deletions.map((deletion) => {
-        const ruleNames = Array.isArray(deletion.ruleNames)
-          ? deletion.ruleNames.join("; ")
-          : ""
-
-        return [
-          deletion.title,
-          deletion.year?.toString() || "",
-          deletion.mediaType,
-          new Date(deletion.deletedAt).toLocaleString(),
-          deletion.deletedBy,
-          deletion.fileSize ? formatBytes(Number(deletion.fileSize)) : "",
-          deletion.filesDeleted ? "Yes" : "No",
-          deletion.deletedFrom,
-          ruleNames,
-        ]
-      })
-
-      const csvContent = [
-        headers.join(","),
-        ...rows.map((row) =>
-          row.map((cell) => `"${String(cell).replace(/"/g, '""')}"`).join(",")
-        ),
-      ].join("\n")
-
-      // Download CSV
-      const blob = new Blob([csvContent], { type: "text/csv;charset=utf-8;" })
-      const link = document.createElement("a")
-      const url = URL.createObjectURL(blob)
-      link.setAttribute("href", url)
-      link.setAttribute("download", `deletion-history-${new Date().toISOString()}.csv`)
-      link.style.visibility = "hidden"
-      document.body.appendChild(link)
-      link.click()
-      document.body.removeChild(link)
-    } finally {
-      setIsExporting(false)
-    }
-  }
-
-  const clearFilters = () => {
-    setFilters({})
-    router.push("/admin/maintenance/history")
-  }
-
-  const hasActiveFilters =
-    filters.mediaType || filters.deletedBy || filters.filesDeleted || filters.startDate || filters.endDate
-
-  return (
-    <div className="space-y-6">
-      {/* Stats Summary */}
-      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4">
-        <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-          <div className="text-sm text-slate-400 mb-1">Total Deletions</div>
-          <div className="text-2xl font-bold text-white">{stats.totalDeletions.toLocaleString()}</div>
-          <div className="text-xs text-slate-500 mt-1">All time</div>
-        </div>
-        <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-          <div className="text-sm text-slate-400 mb-1">Space Reclaimed</div>
-          <div className="text-2xl font-bold text-green-400">
-            {formatBytes(stats.totalSpaceReclaimed)}
-          </div>
-          <div className="text-xs text-slate-500 mt-1">Total storage freed</div>
-        </div>
-        <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-          <div className="text-sm text-slate-400 mb-1">Files Deleted</div>
-          <div className="text-2xl font-bold text-red-400">
-            {stats.filesActuallyDeleted.toLocaleString()}
-          </div>
-          <div className="text-xs text-slate-500 mt-1">
-            {stats.totalDeletions - stats.filesActuallyDeleted} Plex-only
-          </div>
-        </div>
-        <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-          <div className="text-sm text-slate-400 mb-1">This Month</div>
-          <div className="text-2xl font-bold text-cyan-400">
-            {stats.deletionsThisMonth.toLocaleString()}
-          </div>
-          <div className="text-xs text-slate-500 mt-1">
-            {stats.totalDeletions > 0
-              ? `${Math.round((stats.deletionsThisMonth / stats.totalDeletions) * 100)}% of total`
-              : "0% of total"}
-          </div>
-        </div>
-      </div>
-
-      {/* Filters */}
-      <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-        <div className="flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4 mb-4">
-          <h2 className="text-lg font-semibold text-white">Filters</h2>
-          <div className="flex gap-2">
-            {hasActiveFilters && (
-              <button
-                onClick={clearFilters}
-                className="px-3 py-1.5 bg-slate-700 hover:bg-slate-600 text-white text-sm font-medium rounded transition-colors"
-              >
-                Clear Filters
-              </button>
-            )}
-            <button
-              onClick={handleExportCSV}
-              disabled={isExporting || deletions.length === 0}
-              className="px-3 py-1.5 bg-green-600 hover:bg-green-700 disabled:bg-slate-700 disabled:text-slate-500 text-white text-sm font-medium rounded transition-colors"
-            >
-              {isExporting ? "Exporting..." : "Export CSV"}
-            </button>
-          </div>
-        </div>
-
-        <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-3 gap-4">
-          <div>
-            <label htmlFor="mediaType" className="block text-sm text-slate-400 mb-1">
-              Media Type
-            </label>
-            <select
-              id="mediaType"
-              value={filters.mediaType || ""}
-              onChange={(e) => handleFilterChange("mediaType", e.target.value)}
-              className="w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded text-white text-sm focus:outline-none focus:ring-2 focus:ring-cyan-500"
-            >
-              <option value="">All Types</option>
-              <option value="MOVIE">Movies</option>
-              <option value="TV_SERIES">TV Series</option>
-              <option value="EPISODE">Episodes</option>
-            </select>
-          </div>
-
-          <div>
-            <label htmlFor="filesDeleted" className="block text-sm text-slate-400 mb-1">
-              Files Deleted
-            </label>
-            <select
-              id="filesDeleted"
-              value={filters.filesDeleted || ""}
-              onChange={(e) => handleFilterChange("filesDeleted", e.target.value)}
-              className="w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded text-white text-sm focus:outline-none focus:ring-2 focus:ring-cyan-500"
-            >
-              <option value="">All</option>
-              <option value="true">Yes (files deleted)</option>
-              <option value="false">No (Plex only)</option>
-            </select>
-          </div>
-
-          <div>
-            <label htmlFor="startDate" className="block text-sm text-slate-400 mb-1">
-              Start Date
-            </label>
-            <input
-              type="date"
-              id="startDate"
-              value={filters.startDate || ""}
-              onChange={(e) => handleFilterChange("startDate", e.target.value)}
-              className="w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded text-white text-sm focus:outline-none focus:ring-2 focus:ring-cyan-500"
-            />
-          </div>
-
-          <div>
-            <label htmlFor="endDate" className="block text-sm text-slate-400 mb-1">
-              End Date
-            </label>
-            <input
-              type="date"
-              id="endDate"
-              value={filters.endDate || ""}
-              onChange={(e) => handleFilterChange("endDate", e.target.value)}
-              className="w-full px-3 py-2 bg-slate-700 border border-slate-600 rounded text-white text-sm focus:outline-none focus:ring-2 focus:ring-cyan-500"
-            />
-          </div>
-        </div>
-      </div>
-
-      {/* Deletion History Table */}
-      <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg overflow-hidden">
-        <div className="overflow-x-auto">
-          <table className="w-full">
-            <thead className="bg-slate-700/30 border-b border-slate-700">
-              <tr>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider">
-                  Title
-                </th>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider hidden md:table-cell">
-                  Year
-                </th>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider hidden lg:table-cell">
-                  Type
-                </th>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider">
-                  Deleted At
-                </th>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider hidden xl:table-cell">
-                  File Size
-                </th>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider">
-                  Files Deleted
-                </th>
-                <th className="px-3 sm:px-6 py-3 text-left text-xs font-medium text-slate-400 uppercase tracking-wider hidden lg:table-cell">
-                  Rules
-                </th>
-              </tr>
-            </thead>
-            <tbody className="divide-y divide-slate-700">
-              {deletions.length === 0 ? (
-                <tr>
-                  <td colSpan={7} className="px-6 py-8 text-center text-slate-400">
-                    No deletions found.
-                  </td>
-                </tr>
-              ) : (
-                deletions.map((deletion) => {
-                  const ruleNames = Array.isArray(deletion.ruleNames)
-                    ? deletion.ruleNames
-                    : []
-
-                  return (
-                    <tr key={deletion.id} className="hover:bg-slate-700/20 transition-colors">
-                      <td className="px-3 sm:px-6 py-4">
-                        <div className="text-sm font-medium text-white">{deletion.title}</div>
-                        <div className="text-xs text-slate-400 md:hidden">
-                          {deletion.year} - {deletion.mediaType}
-                        </div>
-                      </td>
-                      <td className="px-3 sm:px-6 py-4 whitespace-nowrap hidden md:table-cell">
-                        <div className="text-sm text-slate-300">
-                          {deletion.year || <span className="text-slate-500">—</span>}
-                        </div>
-                      </td>
-                      <td className="px-3 sm:px-6 py-4 whitespace-nowrap hidden lg:table-cell">
-                        <span
-                          className={`px-2 py-1 text-xs font-medium rounded ${
-                            deletion.mediaType === "MOVIE"
-                              ? "bg-blue-500/20 text-blue-400"
-                              : deletion.mediaType === "TV_SERIES"
-                                ? "bg-purple-500/20 text-purple-400"
-                                : "bg-yellow-500/20 text-yellow-400"
-                          }`}
-                        >
-                          {deletion.mediaType === "MOVIE"
-                            ? "Movie"
-                            : deletion.mediaType === "TV_SERIES"
-                              ? "TV Series"
-                              : "Episode"}
-                        </span>
-                      </td>
-                      <td className="px-3 sm:px-6 py-4 whitespace-nowrap">
-                        <div className="text-sm text-slate-300">
-                          <div className="md:hidden">
-                            {new Date(deletion.deletedAt).toLocaleDateString("en-US", {
-                              month: "short",
-                              day: "numeric",
-                            })}
-                          </div>
-                          <div className="hidden md:block">
-                            {new Date(deletion.deletedAt).toLocaleString("en-US", {
-                              year: "numeric",
-                              month: "short",
-                              day: "numeric",
-                              hour: "2-digit",
-                              minute: "2-digit",
-                            })}
-                          </div>
-                        </div>
-                      </td>
-                      <td className="px-3 sm:px-6 py-4 whitespace-nowrap hidden xl:table-cell">
-                        <div className="text-sm text-slate-300">
-                          {deletion.fileSize ? (
-                            formatBytes(Number(deletion.fileSize))
-                          ) : (
-                            <span className="text-slate-500">—</span>
-                          )}
-                        </div>
-                      </td>
-                      <td className="px-3 sm:px-6 py-4 whitespace-nowrap">
-                        <span
-                          className={`px-2 py-1 text-xs font-medium rounded ${
-                            deletion.filesDeleted
-                              ? "bg-red-500/20 text-red-400"
-                              : "bg-slate-600/50 text-slate-400"
-                          }`}
-                        >
-                          {deletion.filesDeleted ? "Yes" : "No"}
-                        </span>
-                      </td>
-                      <td className="px-3 sm:px-6 py-4 hidden lg:table-cell">
-                        <div className="text-xs text-slate-400">
-                          {ruleNames.length > 0 ? (
-                            <div className="flex flex-wrap gap-1">
-                              {ruleNames.map((rule: string, idx: number) => (
-                                <span
-                                  key={idx}
-                                  className="px-2 py-0.5 bg-slate-700 rounded text-slate-300"
-                                >
-                                  {rule}
-                                </span>
-                              ))}
-                            </div>
-                          ) : (
-                            <span className="text-slate-500">Manual</span>
-                          )}
-                        </div>
-                      </td>
-                    </tr>
-                  )
-                })
-              )}
-            </tbody>
-          </table>
-        </div>
-
-        {/* Pagination */}
-        {pagination.totalPages > 1 && (
-          <div className="px-4 sm:px-6 py-4 border-t border-slate-700 flex flex-col sm:flex-row sm:items-center sm:justify-between gap-3">
-            <div className="text-xs sm:text-sm text-slate-400">
-              Showing {(pagination.page - 1) * pagination.pageSize + 1} to{" "}
-              {Math.min(pagination.page * pagination.pageSize, pagination.total)} of{" "}
-              {pagination.total} results
-            </div>
-            <div className="flex gap-2">
-              {pagination.page > 1 && (
-                <Link
-                  href={`/admin/maintenance/history?page=${pagination.page - 1}${
-                    Object.entries(currentFilters)
-                      .filter(([_, v]) => v)
-                      .map(([k, v]) => `&${k}=${v}`)
-                      .join("")
-                  }`}
-                  className="px-3 sm:px-4 py-2 bg-slate-700 hover:bg-slate-600 text-white text-xs sm:text-sm font-medium rounded transition-colors"
-                >
-                  Previous
-                </Link>
-              )}
-              {pagination.page < pagination.totalPages && (
-                <Link
-                  href={`/admin/maintenance/history?page=${pagination.page + 1}${
-                    Object.entries(currentFilters)
-                      .filter(([_, v]) => v)
-                      .map(([k, v]) => `&${k}=${v}`)
-                      .join("")
-                  }`}
-                  className="px-3 sm:px-4 py-2 bg-slate-700 hover:bg-slate-600 text-white text-xs sm:text-sm font-medium rounded transition-colors"
-                >
-                  Next
-                </Link>
-              )}
-            </div>
-          </div>
-        )}
-      </div>
-    </div>
-  )
-}
diff --git a/components/admin/maintenance/media-mark-details.tsx b/components/admin/maintenance/media-mark-details.tsx
deleted file mode 100644
index 542e9e28..00000000
--- a/components/admin/maintenance/media-mark-details.tsx
+++ /dev/null
@@ -1,291 +0,0 @@
-"use client"
-
-import { useState } from "react"
-import { useRouter } from "next/navigation"
-import { MediaDetails } from "@/actions/user-feedback"
-import { addMediaToDeletionQueue, ignoreMediaForever } from "@/actions/user-feedback"
-import { useToast } from "@/components/ui/toast"
-import { LoadingSpinner } from "@/components/ui/loading-spinner"
-import { MarkType } from "@/lib/validations/maintenance"
-import { formatFileSize } from "@/lib/utils/formatters"
-
-interface MediaMarkDetailsViewProps {
-  details: MediaDetails
-}
-
-export function MediaMarkDetailsView({ details }: MediaMarkDetailsViewProps) {
-  const router = useRouter()
-  const { showToast } = useToast()
-  const [loading, setLoading] = useState(false)
-
-  const handleAddToQueue = async () => {
-    setLoading(true)
-    try {
-      const result = await addMediaToDeletionQueue(details.plexRatingKey)
-
-      if (result.success) {
-        showToast(`${details.title} added to deletion queue`, "success")
-        router.push("/admin/maintenance/user-feedback")
-      } else {
-        showToast(result.error || "Failed to add to queue", "error")
-      }
-    } catch (error) {
-      showToast("An error occurred", "error")
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  const handleIgnore = async () => {
-    setLoading(true)
-    try {
-      const result = await ignoreMediaForever(details.plexRatingKey)
-
-      if (result.success) {
-        showToast(`${details.title} will be kept forever`, "success")
-        router.push("/admin/maintenance/user-feedback")
-      } else {
-        showToast(result.error || "Failed to ignore media", "error")
-      }
-    } catch (error) {
-      showToast("An error occurred", "error")
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  const getMarkTypeLabel = (markType: MarkType) => {
-    const labels: Record<MarkType, string> = {
-      FINISHED_WATCHING: "Finished Watching",
-      NOT_INTERESTED: "Not Interested",
-      KEEP_FOREVER: "Keep Forever",
-      REWATCH_CANDIDATE: "Rewatch Candidate",
-      POOR_QUALITY: "Poor Quality",
-      WRONG_VERSION: "Wrong Version",
-    }
-    return labels[markType]
-  }
-
-  const getMarkTypeBadgeColor = (markType: MarkType) => {
-    const colors: Record<MarkType, string> = {
-      FINISHED_WATCHING: "bg-blue-500/20 text-blue-400",
-      NOT_INTERESTED: "bg-red-500/20 text-red-400",
-      KEEP_FOREVER: "bg-green-500/20 text-green-400",
-      REWATCH_CANDIDATE: "bg-cyan-500/20 text-cyan-400",
-      POOR_QUALITY: "bg-orange-500/20 text-orange-400",
-      WRONG_VERSION: "bg-purple-500/20 text-purple-400",
-    }
-    return colors[markType]
-  }
-
-  const getRecommendationDetails = () => {
-    switch (details.recommendation) {
-      case "delete":
-        return {
-          label: "Delete",
-          color: "bg-red-500/20 text-red-400 border-red-500/50",
-          icon: (
-            <svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"
-              />
-            </svg>
-          ),
-          message:
-            "Strong consensus for deletion. Multiple users have indicated this media should be removed.",
-        }
-      case "review":
-        return {
-          label: "Review",
-          color: "bg-amber-500/20 text-amber-400 border-amber-500/50",
-          icon: (
-            <svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z"
-              />
-            </svg>
-          ),
-          message: "Mixed feedback. Review user marks and watch statistics before making a decision.",
-        }
-      case "keep":
-        return {
-          label: "Keep",
-          color: "bg-green-500/20 text-green-400 border-green-500/50",
-          icon: (
-            <svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path
-                strokeLinecap="round"
-                strokeLinejoin="round"
-                strokeWidth={2}
-                d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"
-              />
-            </svg>
-          ),
-          message: "Should be kept. Low deletion score or users have marked it to keep forever.",
-        }
-    }
-  }
-
-  const recommendation = getRecommendationDetails()
-
-  return (
-    <div className="space-y-6">
-      {/* Recommendation Section */}
-      <div
-        className={`bg-slate-800/50 backdrop-blur-sm border ${recommendation.color} rounded-lg p-6`}
-      >
-        <div className="flex items-start gap-4">
-          <div className={recommendation.color}>{recommendation.icon}</div>
-          <div className="flex-1">
-            <h2 className="text-xl font-bold mb-2">Recommendation: {recommendation.label}</h2>
-            <p className="text-sm text-slate-300 mb-4">{recommendation.message}</p>
-            <div className="flex items-center gap-2">
-              <span className="text-sm text-slate-400">Deletion Score:</span>
-              <span className="text-2xl font-bold text-white">{details.deletionScore}</span>
-            </div>
-          </div>
-          <div className="flex flex-col gap-2">
-            <button
-              onClick={handleAddToQueue}
-              disabled={loading}
-              className="px-4 py-2 bg-red-500 hover:bg-red-600 text-white font-medium rounded-lg transition-colors disabled:opacity-50 flex items-center gap-2"
-            >
-              {loading ? <LoadingSpinner size="sm" /> : "Add to Deletion Queue"}
-            </button>
-            <button
-              onClick={handleIgnore}
-              disabled={loading}
-              className="px-4 py-2 bg-slate-700 hover:bg-slate-600 text-white font-medium rounded-lg transition-colors disabled:opacity-50 flex items-center gap-2"
-            >
-              {loading ? <LoadingSpinner size="sm" /> : "Keep Forever"}
-            </button>
-          </div>
-        </div>
-      </div>
-
-      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-        {/* Watch Statistics */}
-        {details.watchStats && (
-          <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-6">
-            <h3 className="text-lg font-bold text-white mb-4">Watch Statistics</h3>
-            <div className="space-y-3">
-              <div className="flex justify-between items-center">
-                <span className="text-sm text-slate-400">Total Plays</span>
-                <span className="text-lg font-semibold text-white">
-                  {details.watchStats.totalPlays}
-                </span>
-              </div>
-              <div className="flex justify-between items-center">
-                <span className="text-sm text-slate-400">Unique Viewers</span>
-                <span className="text-lg font-semibold text-white">
-                  {details.watchStats.uniqueViewers}
-                </span>
-              </div>
-              <div className="flex justify-between items-center">
-                <span className="text-sm text-slate-400">Last Watched</span>
-                <span className="text-sm text-white">
-                  {details.watchStats.lastWatched
-                    ? new Date(details.watchStats.lastWatched).toLocaleDateString()
-                    : "Never"}
-                </span>
-              </div>
-            </div>
-          </div>
-        )}
-
-        {/* File Information */}
-        {details.fileInfo && (
-          <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-6">
-            <h3 className="text-lg font-bold text-white mb-4">File Information</h3>
-            <div className="space-y-3">
-              <div className="flex justify-between items-center">
-                <span className="text-sm text-slate-400">File Size</span>
-                <span className="text-lg font-semibold text-white">
-                  {formatFileSize(details.fileInfo.size)}
-                </span>
-              </div>
-              {details.fileInfo.quality && (
-                <div className="flex justify-between items-center">
-                  <span className="text-sm text-slate-400">Quality</span>
-                  <span className="text-sm text-white">{details.fileInfo.quality}</span>
-                </div>
-              )}
-              {details.fileInfo.path && (
-                <div>
-                  <span className="text-sm text-slate-400 block mb-1">Path</span>
-                  <span className="text-xs text-slate-300 font-mono break-all">
-                    {details.fileInfo.path}
-                  </span>
-                </div>
-              )}
-            </div>
-          </div>
-        )}
-      </div>
-
-      {/* User Marks */}
-      <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg overflow-hidden">
-        <div className="p-6 border-b border-slate-700">
-          <h3 className="text-lg font-bold text-white">User Marks ({details.marks.length})</h3>
-        </div>
-        <div className="overflow-x-auto">
-          <table className="w-full text-left border-collapse">
-            <thead>
-              <tr className="bg-slate-900/50 text-xs uppercase text-slate-400 font-medium border-b border-slate-700">
-                <th className="px-4 py-3">User</th>
-                <th className="px-4 py-3">Media Title</th>
-                <th className="px-4 py-3">Mark Type</th>
-                <th className="px-4 py-3">Note</th>
-                <th className="px-4 py-3">Marked Date</th>
-                <th className="px-4 py-3">Via</th>
-              </tr>
-            </thead>
-            <tbody className="divide-y divide-slate-700/50">
-              {details.marks.map((mark) => (
-                <tr key={mark.id} className="hover:bg-slate-800/30 transition-colors">
-                  <td className="px-4 py-3">
-                    <div className="font-medium text-white">
-                      {mark.userName || "Unknown User"}
-                    </div>
-                    {mark.userEmail && (
-                      <div className="text-xs text-slate-400">{mark.userEmail}</div>
-                    )}
-                  </td>
-                  <td className="px-4 py-3">
-                    <div className="font-medium text-white">
-                      {mark.parentTitle ? `${mark.parentTitle} - ` : ""}{mark.title}
-                    </div>
-                  </td>
-                  <td className="px-4 py-3">
-                    <span className={`px-2 py-1 text-xs rounded ${getMarkTypeBadgeColor(mark.markType)}`}>
-                      {getMarkTypeLabel(mark.markType)}
-                    </span>
-                  </td>
-                  <td className="px-4 py-3">
-                    <span className="text-sm text-slate-300">
-                      {mark.note || <span className="text-slate-500 italic">No note</span>}
-                    </span>
-                  </td>
-                  <td className="px-4 py-3">
-                    <span className="text-sm text-slate-300">
-                      {new Date(mark.markedAt).toLocaleDateString()}
-                    </span>
-                  </td>
-                  <td className="px-4 py-3">
-                    <span className="text-xs text-slate-400">{mark.markedVia}</span>
-                  </td>
-                </tr>
-              ))}
-            </tbody>
-          </table>
-        </div>
-      </div>
-    </div>
-  )
-}
diff --git a/components/admin/maintenance/rules/RuleActions.tsx b/components/admin/maintenance/rules/RuleActions.tsx
deleted file mode 100644
index dd3c38b4..00000000
--- a/components/admin/maintenance/rules/RuleActions.tsx
+++ /dev/null
@@ -1,18 +0,0 @@
-"use client"
-
-import Link from "next/link"
-
-export function RuleActions() {
-  return (
-    <Link
-      href="/admin/maintenance/rules/new"
-      className="px-4 py-2 bg-cyan-600 hover:bg-cyan-500 text-white rounded-lg font-medium transition-colors flex items-center gap-2"
-      data-testid="maintenance-rule-create"
-    >
-      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-      </svg>
-      Create Rule
-    </Link>
-  )
-}
diff --git a/components/admin/maintenance/rules/RuleList.tsx b/components/admin/maintenance/rules/RuleList.tsx
deleted file mode 100644
index 91c6a938..00000000
--- a/components/admin/maintenance/rules/RuleList.tsx
+++ /dev/null
@@ -1,175 +0,0 @@
-"use client"
-
-import Link from "next/link"
-import { getMediaTypeLabel } from "@/lib/utils/formatters"
-
-type MaintenanceRule = {
-  id: string
-  name: string
-  description: string | null
-  enabled: boolean
-  mediaType: string
-  actionType: string
-  schedule: string | null
-  createdAt: Date
-  scans: Array<{
-    id: string
-    status: string
-    itemsScanned: number
-    itemsFlagged: number
-    completedAt: Date | null
-  }>
-  _count: {
-    scans: number
-  }
-}
-
-interface RuleListProps {
-  rules: MaintenanceRule[]
-  onToggle: (id: string, currentEnabled: boolean) => void
-  onDeleteClick: (id: string) => void
-  isTogglePending: boolean
-}
-
-export function RuleList({
-  rules,
-  onToggle,
-  onDeleteClick,
-  isTogglePending,
-}: RuleListProps) {
-  function getActionTypeLabel(actionType: string) {
-    switch (actionType) {
-      case 'FLAG_FOR_REVIEW':
-        return 'Flag for Review'
-      case 'AUTO_DELETE':
-        return 'Auto Delete'
-      default:
-        return actionType
-    }
-  }
-
-  if (rules.length === 0) {
-    return (
-      <div className="text-center py-12 bg-slate-800/50 rounded-lg border border-slate-700">
-        <svg className="w-12 h-12 text-slate-500 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-        </svg>
-        <h3 className="text-lg font-medium text-white mb-2">No rules yet</h3>
-        <p className="text-slate-400 mb-4">Create a maintenance rule to start automating library cleanup.</p>
-        <Link
-          href="/admin/maintenance/rules/new"
-          className="inline-flex items-center gap-2 px-4 py-2 bg-cyan-600 hover:bg-cyan-500 text-white rounded-lg font-medium transition-colors"
-        >
-          <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-          </svg>
-          Create First Rule
-        </Link>
-      </div>
-    )
-  }
-
-  return (
-    <div className="bg-slate-800/50 rounded-lg border border-slate-700 overflow-hidden">
-      <div className="overflow-x-auto">
-        <table className="w-full text-left">
-          <thead>
-            <tr className="bg-slate-900/50 border-b border-slate-700">
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Rule Name</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Media Type</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Action</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Status</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Scans</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Last Run</th>
-              <th className="px-6 py-4 text-xs font-semibold text-slate-400 uppercase tracking-wider">Actions</th>
-            </tr>
-          </thead>
-          <tbody className="divide-y divide-slate-700">
-            {rules.map((rule) => {
-              const lastScan = rule.scans[0]
-
-              return (
-                <tr key={rule.id} className="hover:bg-slate-800/50 transition-colors" data-testid={`rule-row-${rule.id}`}>
-                  <td className="px-6 py-4">
-                    <div>
-                      <div className="text-sm font-medium text-white">{rule.name}</div>
-                      {rule.description && (
-                        <div className="text-xs text-slate-400 mt-1">{rule.description}</div>
-                      )}
-                    </div>
-                  </td>
-                  <td className="px-6 py-4">
-                    <span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-blue-400/10 text-blue-400">
-                      {getMediaTypeLabel(rule.mediaType)}
-                    </span>
-                  </td>
-                  <td className="px-6 py-4">
-                    <span className={`inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium ${
-                      rule.actionType === 'AUTO_DELETE'
-                        ? 'bg-red-400/10 text-red-400'
-                        : 'bg-yellow-400/10 text-yellow-400'
-                    }`}>
-                      {getActionTypeLabel(rule.actionType)}
-                    </span>
-                  </td>
-                  <td className="px-6 py-4">
-                    <button
-                      onClick={() => onToggle(rule.id, rule.enabled)}
-                      disabled={isTogglePending}
-                      className={`inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium transition-colors ${
-                        rule.enabled
-                          ? 'bg-green-400/10 text-green-400 hover:bg-green-400/20'
-                          : 'bg-slate-400/10 text-slate-400 hover:bg-slate-400/20'
-                      }`}
-                      data-testid={`toggle-rule-${rule.id}`}
-                    >
-                      {rule.enabled ? 'Enabled' : 'Disabled'}
-                    </button>
-                  </td>
-                  <td className="px-6 py-4 text-sm text-slate-400">
-                    {rule._count.scans} total
-                    {lastScan && lastScan.itemsFlagged > 0 && (
-                      <span className="ml-2 text-yellow-400">
-                        ({lastScan.itemsFlagged} flagged)
-                      </span>
-                    )}
-                  </td>
-                  <td className="px-6 py-4 text-sm text-slate-400">
-                    {lastScan?.completedAt
-                      ? new Date(lastScan.completedAt).toLocaleDateString()
-                      : 'Never'
-                    }
-                  </td>
-                  <td className="px-6 py-4">
-                    <div className="flex items-center gap-2">
-                      <Link
-                        href={`/admin/maintenance/rules/${rule.id}/edit`}
-                        className="text-slate-400 hover:text-white transition-colors"
-                        title="Edit"
-                        data-testid={`edit-rule-${rule.id}`}
-                      >
-                        <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z" />
-                        </svg>
-                      </Link>
-                      <button
-                        onClick={() => onDeleteClick(rule.id)}
-                        className="text-slate-400 hover:text-red-400 transition-colors"
-                        title="Delete"
-                        data-testid={`delete-rule-${rule.id}`}
-                      >
-                        <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16" />
-                        </svg>
-                      </button>
-                    </div>
-                  </td>
-                </tr>
-              )
-            })}
-          </tbody>
-        </table>
-      </div>
-    </div>
-  )
-}
diff --git a/components/admin/maintenance/rules/__tests__/RuleActions.test.tsx b/components/admin/maintenance/rules/__tests__/RuleActions.test.tsx
deleted file mode 100644
index 30e1e3e9..00000000
--- a/components/admin/maintenance/rules/__tests__/RuleActions.test.tsx
+++ /dev/null
@@ -1,97 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import { RuleActions } from '../RuleActions'
-
-// Mock next/link
-jest.mock('next/link', () => {
-  return ({ children, href, className }: { children: React.ReactNode; href: string; className?: string }) => (
-    <a href={href} className={className}>
-      {children}
-    </a>
-  )
-})
-
-describe('RuleActions', () => {
-  describe('Basic Rendering', () => {
-    it('should render create rule link', () => {
-      render(<RuleActions />)
-
-      const link = screen.getByRole('link', { name: /Create Rule/i })
-      expect(link).toBeInTheDocument()
-    })
-
-    it('should link to new rule page', () => {
-      render(<RuleActions />)
-
-      const link = screen.getByRole('link')
-      expect(link).toHaveAttribute('href', '/admin/maintenance/rules/new')
-    })
-
-    it('should display "Create Rule" text', () => {
-      render(<RuleActions />)
-
-      expect(screen.getByText('Create Rule')).toBeInTheDocument()
-    })
-  })
-
-  describe('Styling', () => {
-    it('should have proper button styling classes', () => {
-      render(<RuleActions />)
-
-      const link = screen.getByRole('link')
-      expect(link).toHaveClass('px-4', 'py-2')
-      expect(link).toHaveClass('bg-cyan-600')
-      expect(link).toHaveClass('hover:bg-cyan-500')
-      expect(link).toHaveClass('text-white')
-      expect(link).toHaveClass('rounded-lg')
-      expect(link).toHaveClass('font-medium')
-    })
-
-    it('should have flex layout with gap for icon', () => {
-      render(<RuleActions />)
-
-      const link = screen.getByRole('link')
-      expect(link).toHaveClass('flex', 'items-center', 'gap-2')
-    })
-
-    it('should have transition effect', () => {
-      render(<RuleActions />)
-
-      const link = screen.getByRole('link')
-      expect(link).toHaveClass('transition-colors')
-    })
-  })
-
-  describe('Icon', () => {
-    it('should render plus icon', () => {
-      const { container } = render(<RuleActions />)
-
-      const svg = container.querySelector('svg')
-      expect(svg).toBeInTheDocument()
-    })
-
-    it('should have proper icon size', () => {
-      const { container } = render(<RuleActions />)
-
-      const svg = container.querySelector('svg')
-      expect(svg).toHaveClass('w-5', 'h-5')
-    })
-
-    it('should have plus icon path', () => {
-      const { container } = render(<RuleActions />)
-
-      const path = container.querySelector('path')
-      expect(path).toBeInTheDocument()
-      expect(path).toHaveAttribute('d', 'M12 4v16m8-8H4')
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should be keyboard accessible as a link', () => {
-      render(<RuleActions />)
-
-      const link = screen.getByRole('link')
-      expect(link).toBeInTheDocument()
-      // Links are inherently keyboard accessible
-    })
-  })
-})
diff --git a/components/admin/maintenance/rules/__tests__/RuleList.test.tsx b/components/admin/maintenance/rules/__tests__/RuleList.test.tsx
deleted file mode 100644
index 08e31aa3..00000000
--- a/components/admin/maintenance/rules/__tests__/RuleList.test.tsx
+++ /dev/null
@@ -1,324 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { RuleList } from '../RuleList'
-
-// Mock next/link
-jest.mock('next/link', () => {
-  return ({ children, href, ...props }: { children: React.ReactNode; href: string }) => (
-    <a href={href} {...props}>
-      {children}
-    </a>
-  )
-})
-
-// Mock formatters
-jest.mock('@/lib/utils/formatters', () => ({
-  getMediaTypeLabel: (type: string) => {
-    switch (type) {
-      case 'MOVIE':
-        return 'Movie'
-      case 'TV_SERIES':
-        return 'TV Series'
-      case 'EPISODE':
-        return 'Episode'
-      default:
-        return type
-    }
-  },
-}))
-
-type MaintenanceRule = {
-  id: string
-  name: string
-  description: string | null
-  enabled: boolean
-  mediaType: string
-  actionType: string
-  schedule: string | null
-  createdAt: Date
-  scans: Array<{
-    id: string
-    status: string
-    itemsScanned: number
-    itemsFlagged: number
-    completedAt: Date | null
-  }>
-  _count: {
-    scans: number
-  }
-}
-
-describe('RuleList', () => {
-  const mockRule: MaintenanceRule = {
-    id: 'rule-1',
-    name: 'Old Unwatched Movies',
-    description: 'Clean up movies not watched in 6 months',
-    enabled: true,
-    mediaType: 'MOVIE',
-    actionType: 'FLAG_FOR_REVIEW',
-    schedule: '0 0 * * 0',
-    createdAt: new Date('2024-01-01'),
-    scans: [
-      {
-        id: 'scan-1',
-        status: 'COMPLETED',
-        itemsScanned: 100,
-        itemsFlagged: 15,
-        completedAt: new Date('2024-11-15'),
-      },
-    ],
-    _count: {
-      scans: 5,
-    },
-  }
-
-  const defaultProps = {
-    rules: [mockRule],
-    onToggle: jest.fn(),
-    onDeleteClick: jest.fn(),
-    isTogglePending: false,
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('Empty State', () => {
-    it('should display empty state when no rules', () => {
-      render(<RuleList {...defaultProps} rules={[]} />)
-
-      expect(screen.getByText('No rules yet')).toBeInTheDocument()
-      expect(
-        screen.getByText('Create a maintenance rule to start automating library cleanup.')
-      ).toBeInTheDocument()
-    })
-
-    it('should display create first rule link in empty state', () => {
-      render(<RuleList {...defaultProps} rules={[]} />)
-
-      const createLink = screen.getByRole('link', { name: /Create First Rule/i })
-      expect(createLink).toBeInTheDocument()
-      expect(createLink).toHaveAttribute('href', '/admin/maintenance/rules/new')
-    })
-  })
-
-  describe('Rule Display', () => {
-    it('should render rule with all details', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('Old Unwatched Movies')).toBeInTheDocument()
-      expect(screen.getByText('Clean up movies not watched in 6 months')).toBeInTheDocument()
-      expect(screen.getByText('Movie')).toBeInTheDocument()
-      expect(screen.getByText('Flag for Review')).toBeInTheDocument()
-    })
-
-    it('should display rule without description', () => {
-      const ruleWithoutDescription = { ...mockRule, description: null }
-      render(<RuleList {...defaultProps} rules={[ruleWithoutDescription]} />)
-
-      expect(screen.getByText('Old Unwatched Movies')).toBeInTheDocument()
-      expect(screen.queryByText('Clean up movies not watched in 6 months')).not.toBeInTheDocument()
-    })
-
-    it('should display enabled status correctly', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('Enabled')).toBeInTheDocument()
-    })
-
-    it('should display disabled status correctly', () => {
-      const disabledRule = { ...mockRule, enabled: false }
-      render(<RuleList {...defaultProps} rules={[disabledRule]} />)
-
-      expect(screen.getByText('Disabled')).toBeInTheDocument()
-    })
-
-    it('should display scan count', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('5 total')).toBeInTheDocument()
-    })
-
-    it('should display flagged count from last scan', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('(15 flagged)')).toBeInTheDocument()
-    })
-
-    it('should not display flagged count when zero', () => {
-      const ruleWithNoFlagged = {
-        ...mockRule,
-        scans: [{ ...mockRule.scans[0], itemsFlagged: 0 }],
-      }
-      render(<RuleList {...defaultProps} rules={[ruleWithNoFlagged]} />)
-
-      expect(screen.queryByText(/flagged/)).not.toBeInTheDocument()
-    })
-
-    it('should display last run date', () => {
-      render(<RuleList {...defaultProps} />)
-
-      // Date formatted as localized date string
-      const expectedDate = new Date('2024-11-15').toLocaleDateString()
-      expect(screen.getByText(expectedDate)).toBeInTheDocument()
-    })
-
-    it('should display "Never" when no scans completed', () => {
-      const ruleWithNoScans = { ...mockRule, scans: [] }
-      render(<RuleList {...defaultProps} rules={[ruleWithNoScans]} />)
-
-      expect(screen.getByText('Never')).toBeInTheDocument()
-    })
-  })
-
-  describe('Action Types', () => {
-    it('should display Flag for Review action type', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('Flag for Review')).toBeInTheDocument()
-    })
-
-    it('should display Auto Delete action type', () => {
-      const autoDeleteRule = { ...mockRule, actionType: 'AUTO_DELETE' }
-      render(<RuleList {...defaultProps} rules={[autoDeleteRule]} />)
-
-      expect(screen.getByText('Auto Delete')).toBeInTheDocument()
-    })
-
-    it('should style Auto Delete action type in red', () => {
-      const autoDeleteRule = { ...mockRule, actionType: 'AUTO_DELETE' }
-      render(<RuleList {...defaultProps} rules={[autoDeleteRule]} />)
-
-      const badge = screen.getByText('Auto Delete')
-      expect(badge).toHaveClass('bg-red-400/10', 'text-red-400')
-    })
-
-    it('should style Flag for Review in yellow', () => {
-      render(<RuleList {...defaultProps} />)
-
-      const badge = screen.getByText('Flag for Review')
-      expect(badge).toHaveClass('bg-yellow-400/10', 'text-yellow-400')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onToggle when status button is clicked', async () => {
-      const user = userEvent.setup()
-      const onToggle = jest.fn()
-
-      render(<RuleList {...defaultProps} onToggle={onToggle} />)
-
-      await user.click(screen.getByTestId('toggle-rule-rule-1'))
-
-      expect(onToggle).toHaveBeenCalledWith('rule-1', true)
-    })
-
-    it('should call onDeleteClick when delete button is clicked', async () => {
-      const user = userEvent.setup()
-      const onDeleteClick = jest.fn()
-
-      render(<RuleList {...defaultProps} onDeleteClick={onDeleteClick} />)
-
-      await user.click(screen.getByTestId('delete-rule-rule-1'))
-
-      expect(onDeleteClick).toHaveBeenCalledWith('rule-1')
-    })
-
-    it('should link to edit page', () => {
-      render(<RuleList {...defaultProps} />)
-
-      const editLink = screen.getByTestId('edit-rule-rule-1')
-      expect(editLink).toHaveAttribute('href', '/admin/maintenance/rules/rule-1/edit')
-    })
-  })
-
-  describe('Disabled States', () => {
-    it('should disable toggle button when isTogglePending is true', () => {
-      render(<RuleList {...defaultProps} isTogglePending={true} />)
-
-      expect(screen.getByTestId('toggle-rule-rule-1')).toBeDisabled()
-    })
-  })
-
-  describe('Multiple Rules', () => {
-    it('should render multiple rules', () => {
-      const rules = [
-        mockRule,
-        { ...mockRule, id: 'rule-2', name: 'TV Series Cleanup', mediaType: 'TV_SERIES' },
-        { ...mockRule, id: 'rule-3', name: 'Episode Cleanup', mediaType: 'EPISODE' },
-      ]
-
-      render(<RuleList {...defaultProps} rules={rules} />)
-
-      expect(screen.getByText('Old Unwatched Movies')).toBeInTheDocument()
-      expect(screen.getByText('TV Series Cleanup')).toBeInTheDocument()
-      expect(screen.getByText('Episode Cleanup')).toBeInTheDocument()
-    })
-
-    it('should have correct test IDs for multiple rules', () => {
-      const rules = [
-        mockRule,
-        { ...mockRule, id: 'rule-2', name: 'Second Rule' },
-      ]
-
-      render(<RuleList {...defaultProps} rules={rules} />)
-
-      expect(screen.getByTestId('rule-row-rule-1')).toBeInTheDocument()
-      expect(screen.getByTestId('rule-row-rule-2')).toBeInTheDocument()
-    })
-  })
-
-  describe('Media Types', () => {
-    it('should display Movie media type', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('Movie')).toBeInTheDocument()
-    })
-
-    it('should display TV Series media type', () => {
-      const tvRule = { ...mockRule, mediaType: 'TV_SERIES' }
-      render(<RuleList {...defaultProps} rules={[tvRule]} />)
-
-      expect(screen.getByText('TV Series')).toBeInTheDocument()
-    })
-
-    it('should display Episode media type', () => {
-      const episodeRule = { ...mockRule, mediaType: 'EPISODE' }
-      render(<RuleList {...defaultProps} rules={[episodeRule]} />)
-
-      expect(screen.getByText('Episode')).toBeInTheDocument()
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have data-testid attributes for testing', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByTestId('rule-row-rule-1')).toBeInTheDocument()
-      expect(screen.getByTestId('toggle-rule-rule-1')).toBeInTheDocument()
-      expect(screen.getByTestId('edit-rule-rule-1')).toBeInTheDocument()
-      expect(screen.getByTestId('delete-rule-rule-1')).toBeInTheDocument()
-    })
-
-    it('should have title attributes on action buttons', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByTestId('edit-rule-rule-1')).toHaveAttribute('title', 'Edit')
-      expect(screen.getByTestId('delete-rule-rule-1')).toHaveAttribute('title', 'Delete')
-    })
-  })
-
-  describe('Table Headers', () => {
-    it('should display all table headers', () => {
-      render(<RuleList {...defaultProps} />)
-
-      expect(screen.getByText('Rule Name')).toBeInTheDocument()
-      expect(screen.getByText('Media Type')).toBeInTheDocument()
-      expect(screen.getByText('Action')).toBeInTheDocument()
-      expect(screen.getByText('Status')).toBeInTheDocument()
-      expect(screen.getByText('Scans')).toBeInTheDocument()
-      expect(screen.getByText('Last Run')).toBeInTheDocument()
-      expect(screen.getByText('Actions')).toBeInTheDocument()
-    })
-  })
-})
diff --git a/components/admin/maintenance/user-feedback-table.tsx b/components/admin/maintenance/user-feedback-table.tsx
deleted file mode 100644
index 263f9ad1..00000000
--- a/components/admin/maintenance/user-feedback-table.tsx
+++ /dev/null
@@ -1,341 +0,0 @@
-"use client"
-
-import { useState, useMemo } from "react"
-import { useRouter } from "next/navigation"
-import { MediaMarkSummary } from "@/actions/user-feedback"
-import { MediaType, MarkType } from "@/lib/validations/maintenance"
-import { addMediaToDeletionQueue, ignoreMediaForever } from "@/actions/user-feedback"
-import { useToast } from "@/components/ui/toast"
-import { LoadingSpinner } from "@/components/ui/loading-spinner"
-
-interface UserFeedbackTableProps {
-  initialData: MediaMarkSummary[]
-}
-
-type SortField = "title" | "deletionScore" | "userCount" | "fileSize"
-type SortOrder = "asc" | "desc"
-
-export function UserFeedbackTable({ initialData }: UserFeedbackTableProps) {
-  const router = useRouter()
-  const { showToast } = useToast()
-  const [data, setData] = useState(initialData)
-  const [loading, setLoading] = useState<string | null>(null)
-
-  // Filters
-  const [mediaTypeFilter, setMediaTypeFilter] = useState<MediaType | "all">("all")
-  const [markTypeFilter, setMarkTypeFilter] = useState<MarkType | "all">("all")
-  const [minUserCount, setMinUserCount] = useState(1)
-
-  // Sorting
-  const [sortField, setSortField] = useState<SortField>("deletionScore")
-  const [sortOrder, setSortOrder] = useState<SortOrder>("desc")
-
-  const filteredAndSortedData = useMemo(() => {
-    let filtered = data.filter((item) => {
-      if (mediaTypeFilter !== "all" && item.mediaType !== mediaTypeFilter) {
-        return false
-      }
-
-      if (markTypeFilter !== "all") {
-        if (item.markCounts[markTypeFilter] === 0) {
-          return false
-        }
-      }
-
-      if (item.uniqueUserCount < minUserCount) {
-        return false
-      }
-
-      return true
-    })
-
-    filtered.sort((a, b) => {
-      let compareValue = 0
-
-      switch (sortField) {
-        case "title":
-          compareValue = a.title.localeCompare(b.title)
-          break
-        case "deletionScore":
-          compareValue = a.deletionScore - b.deletionScore
-          break
-        case "userCount":
-          compareValue = a.uniqueUserCount - b.uniqueUserCount
-          break
-        case "fileSize":
-          compareValue = Number(a.totalFileSize || 0) - Number(b.totalFileSize || 0)
-          break
-      }
-
-      return sortOrder === "desc" ? -compareValue : compareValue
-    })
-
-    return filtered
-  }, [data, mediaTypeFilter, markTypeFilter, minUserCount, sortField, sortOrder])
-
-  const handleSort = (field: SortField) => {
-    if (sortField === field) {
-      setSortOrder(sortOrder === "asc" ? "desc" : "asc")
-    } else {
-      setSortField(field)
-      setSortOrder("desc")
-    }
-  }
-
-  const handleAddToQueue = async (item: MediaMarkSummary) => {
-    setLoading(item.plexRatingKey)
-    try {
-      const result = await addMediaToDeletionQueue(item.plexRatingKey)
-
-      if (result.success) {
-        showToast(`${item.title} added to deletion queue`, "success")
-        // Remove from list
-        setData((prev) => prev.filter((d) => d.plexRatingKey !== item.plexRatingKey))
-      } else {
-        showToast(result.error || "Failed to add to queue", "error")
-      }
-    } catch (error) {
-      showToast("An error occurred", "error")
-    } finally {
-      setLoading(null)
-    }
-  }
-
-  const handleIgnore = async (item: MediaMarkSummary) => {
-    setLoading(item.plexRatingKey)
-    try {
-      const result = await ignoreMediaForever(item.plexRatingKey)
-
-      if (result.success) {
-        showToast(`${item.title} will be kept forever`, "success")
-        // Remove from list
-        setData((prev) => prev.filter((d) => d.plexRatingKey !== item.plexRatingKey))
-      } else {
-        showToast(result.error || "Failed to ignore media", "error")
-      }
-    } catch (error) {
-      showToast("An error occurred", "error")
-    } finally {
-      setLoading(null)
-    }
-  }
-
-  const getRecommendationBadge = (item: MediaMarkSummary) => {
-    if (item.markCounts.KEEP_FOREVER > 0) {
-      return <span className="px-2 py-1 text-xs rounded-full bg-green-500/20 text-green-400">Keep</span>
-    }
-    if (item.deletionScore >= 15) {
-      return <span className="px-2 py-1 text-xs rounded-full bg-red-500/20 text-red-400">Delete</span>
-    }
-    if (item.deletionScore >= 8) {
-      return <span className="px-2 py-1 text-xs rounded-full bg-amber-500/20 text-amber-400">Review</span>
-    }
-    return <span className="px-2 py-1 text-xs rounded-full bg-green-500/20 text-green-400">Keep</span>
-  }
-
-  const SortIcon = ({ field }: { field: SortField }) => {
-    if (sortField !== field) {
-      return (
-        <svg className="w-4 h-4 opacity-50" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 16V4m0 0L3 8m4-4l4 4m6 0v12m0 0l4-4m-4 4l-4-4" />
-        </svg>
-      )
-    }
-    return sortOrder === "asc" ? (
-      <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 15l7-7 7 7" />
-      </svg>
-    ) : (
-      <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
-      </svg>
-    )
-  }
-
-  return (
-    <div className="space-y-4">
-      {/* Filters */}
-      <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg p-4">
-        <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
-          <div>
-            <label className="block text-sm font-medium text-slate-300 mb-2">Media Type</label>
-            <select
-              value={mediaTypeFilter}
-              onChange={(e) => setMediaTypeFilter(e.target.value as MediaType | "all")}
-              className="w-full bg-slate-900 border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-amber-500"
-            >
-              <option value="all">All Types</option>
-              <option value="MOVIE">Movies</option>
-              <option value="TV_SERIES">TV Series</option>
-            </select>
-          </div>
-
-          <div>
-            <label className="block text-sm font-medium text-slate-300 mb-2">Mark Type</label>
-            <select
-              value={markTypeFilter}
-              onChange={(e) => setMarkTypeFilter(e.target.value as MarkType | "all")}
-              className="w-full bg-slate-900 border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-amber-500"
-            >
-              <option value="all">All Marks</option>
-              <option value="FINISHED_WATCHING">Finished Watching</option>
-              <option value="NOT_INTERESTED">Not Interested</option>
-              <option value="KEEP_FOREVER">Keep Forever</option>
-              <option value="REWATCH_CANDIDATE">Rewatch Candidate</option>
-              <option value="POOR_QUALITY">Poor Quality</option>
-              <option value="WRONG_VERSION">Wrong Version</option>
-            </select>
-          </div>
-
-          <div>
-            <label className="block text-sm font-medium text-slate-300 mb-2">Min User Count</label>
-            <input
-              type="number"
-              min="1"
-              value={minUserCount}
-              onChange={(e) => setMinUserCount(parseInt(e.target.value) || 1)}
-              className="w-full bg-slate-900 border border-slate-700 rounded-lg px-3 py-2 text-white text-sm focus:outline-none focus:ring-2 focus:ring-amber-500"
-            />
-          </div>
-        </div>
-      </div>
-
-      {/* Table */}
-      <div className="bg-slate-800/50 backdrop-blur-sm border border-slate-700 rounded-lg overflow-hidden">
-        <div className="overflow-x-auto">
-          <table className="w-full text-left border-collapse">
-            <thead>
-              <tr className="bg-slate-900/50 text-xs uppercase text-slate-400 font-medium border-b border-slate-700">
-                <th
-                  className="px-4 py-3 cursor-pointer hover:bg-slate-800/50 transition-colors"
-                  onClick={() => handleSort("title")}
-                >
-                  <div className="flex items-center gap-2">
-                    Title
-                    <SortIcon field="title" />
-                  </div>
-                </th>
-                <th className="px-4 py-3">Type</th>
-                <th className="px-4 py-3">User Marks</th>
-                <th
-                  className="px-4 py-3 cursor-pointer hover:bg-slate-800/50 transition-colors"
-                  onClick={() => handleSort("userCount")}
-                >
-                  <div className="flex items-center gap-2">
-                    Users
-                    <SortIcon field="userCount" />
-                  </div>
-                </th>
-                <th
-                  className="px-4 py-3 cursor-pointer hover:bg-slate-800/50 transition-colors"
-                  onClick={() => handleSort("deletionScore")}
-                >
-                  <div className="flex items-center gap-2">
-                    Score
-                    <SortIcon field="deletionScore" />
-                  </div>
-                </th>
-                <th className="px-4 py-3">Recommendation</th>
-                <th className="px-4 py-3">Actions</th>
-              </tr>
-            </thead>
-            <tbody className="divide-y divide-slate-700/50">
-              {filteredAndSortedData.length === 0 ? (
-                <tr>
-                  <td colSpan={7} className="px-4 py-8 text-center text-slate-400 text-sm">
-                    No feedback found matching filters
-                  </td>
-                </tr>
-              ) : (
-                filteredAndSortedData.map((item) => (
-                  <tr
-                    key={item.plexRatingKey}
-                    className="hover:bg-slate-800/30 transition-colors cursor-pointer"
-                    onClick={() => router.push(`/admin/maintenance/user-feedback/${item.plexRatingKey}`)}
-                  >
-                    <td className="px-4 py-3">
-                      <div className="font-medium text-white">{item.title}</div>
-                      {item.year && <div className="text-xs text-slate-400">{item.year}</div>}
-                    </td>
-                    <td className="px-4 py-3">
-                      <span className="text-sm text-slate-300">
-                        {item.mediaType === "MOVIE" ? "Movie" : "TV Series"}
-                      </span>
-                    </td>
-                    <td className="px-4 py-3">
-                      <div className="flex flex-wrap gap-1 text-xs">
-                        {item.markCounts.FINISHED_WATCHING > 0 && (
-                          <span className="px-2 py-1 bg-blue-500/20 text-blue-400 rounded">
-                            Finished: {item.markCounts.FINISHED_WATCHING}
-                          </span>
-                        )}
-                        {item.markCounts.NOT_INTERESTED > 0 && (
-                          <span className="px-2 py-1 bg-red-500/20 text-red-400 rounded">
-                            Not Interested: {item.markCounts.NOT_INTERESTED}
-                          </span>
-                        )}
-                        {item.markCounts.KEEP_FOREVER > 0 && (
-                          <span className="px-2 py-1 bg-green-500/20 text-green-400 rounded">
-                            Keep: {item.markCounts.KEEP_FOREVER}
-                          </span>
-                        )}
-                        {item.markCounts.POOR_QUALITY > 0 && (
-                          <span className="px-2 py-1 bg-orange-500/20 text-orange-400 rounded">
-                            Poor Quality: {item.markCounts.POOR_QUALITY}
-                          </span>
-                        )}
-                        {item.markCounts.WRONG_VERSION > 0 && (
-                          <span className="px-2 py-1 bg-purple-500/20 text-purple-400 rounded">
-                            Wrong Version: {item.markCounts.WRONG_VERSION}
-                          </span>
-                        )}
-                        {item.markCounts.REWATCH_CANDIDATE > 0 && (
-                          <span className="px-2 py-1 bg-cyan-500/20 text-cyan-400 rounded">
-                            Rewatch: {item.markCounts.REWATCH_CANDIDATE}
-                          </span>
-                        )}
-                      </div>
-                    </td>
-                    <td className="px-4 py-3">
-                      <span className="text-sm text-white font-medium">{item.uniqueUserCount}</span>
-                    </td>
-                    <td className="px-4 py-3">
-                      <span className="text-sm text-white font-medium">{item.deletionScore}</span>
-                    </td>
-                    <td className="px-4 py-3">{getRecommendationBadge(item)}</td>
-                    <td className="px-4 py-3" onClick={(e) => e.stopPropagation()}>
-                      <div className="flex items-center gap-2">
-                        <button
-                          onClick={() => handleAddToQueue(item)}
-                          disabled={loading === item.plexRatingKey}
-                          className="px-3 py-1 text-xs font-medium bg-red-500/20 text-red-400 rounded hover:bg-red-500/30 transition-colors disabled:opacity-50"
-                        >
-                          {loading === item.plexRatingKey ? (
-                            <LoadingSpinner size="sm" />
-                          ) : (
-                            "Add to Queue"
-                          )}
-                        </button>
-                        <button
-                          onClick={() => handleIgnore(item)}
-                          disabled={loading === item.plexRatingKey}
-                          className="px-3 py-1 text-xs font-medium bg-slate-500/20 text-slate-400 rounded hover:bg-slate-500/30 transition-colors disabled:opacity-50"
-                        >
-                          {loading === item.plexRatingKey ? <LoadingSpinner size="sm" /> : "Ignore"}
-                        </button>
-                      </div>
-                    </td>
-                  </tr>
-                ))
-              )}
-            </tbody>
-          </table>
-        </div>
-      </div>
-
-      <div className="text-sm text-slate-400 text-center">
-        Showing {filteredAndSortedData.length} of {data.length} items
-      </div>
-    </div>
-  )
-}
diff --git a/components/admin/shared/admin-nav.tsx b/components/admin/shared/admin-nav.tsx
index 4ef78acb..9c48e102 100644
--- a/components/admin/shared/admin-nav.tsx
+++ b/components/admin/shared/admin-nav.tsx
@@ -41,59 +41,6 @@ const coreNavItems: NavItem[] = [
   },
 ]
 
-// Group 2: Library Maintenance
-const maintenanceNavItems: NavItem[] = [
-  {
-    href: "/admin/maintenance",
-    label: "Overview",
-    testId: "admin-nav-maintenance-overview",
-    icon: (
-      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-3 7h3m-3 4h3m-6-4h.01M9 16h.01" />
-      </svg>
-    ),
-  },
-  {
-    href: "/admin/maintenance/rules",
-    label: "Rules",
-    testId: "admin-nav-maintenance-rules",
-    icon: (
-      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
-      </svg>
-    ),
-  },
-  {
-    href: "/admin/maintenance/candidates",
-    label: "Candidates",
-    testId: "admin-nav-maintenance-candidates",
-    icon: (
-      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
-      </svg>
-    ),
-  },
-  {
-    href: "/admin/maintenance/user-feedback",
-    label: "User Feedback",
-    testId: "admin-nav-maintenance-feedback",
-    icon: (
-      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 10h.01M12 10h.01M16 10h.01M9 16H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-5l-5 5v-5z" />
-      </svg>
-    ),
-  },
-  {
-    href: "/admin/maintenance/history",
-    label: "Deletion History",
-    testId: "admin-nav-maintenance-history",
-    icon: (
-      <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" />
-      </svg>
-    ),
-  },
-]
 
 // Group 3: Monitoring & Analytics
 const analyticsNavItems: NavItem[] = [
@@ -172,14 +119,12 @@ const systemNavItems: NavItem[] = [
 const primaryMobileNavItems: NavItem[] = [
   coreNavItems[0], // Users
   coreNavItems[1], // Invites
-  maintenanceNavItems[0], // Maintenance Overview
+  coreNavItems[2], // Share Analytics
   systemNavItems[0], // Settings
 ]
 
 // Secondary mobile nav items (shown in "More" menu)
 const secondaryMobileNavItems: NavItem[] = [
-  coreNavItems[2], // Share Analytics
-  ...maintenanceNavItems.slice(1), // Rules, Candidates, User Feedback, Deletion History
   ...analyticsNavItems, // LLM Usage, Cost Analysis, Discord Bot
   ...configNavItems, // Prompts, Playground
 ]
@@ -229,10 +174,6 @@ export function AdminNav() {
       // Prompts is active for /admin/prompts and /admin/prompts/[id] but not /admin/playground
       return pathname.startsWith("/admin/prompts") && !pathname.startsWith("/admin/playground")
     }
-    if (href === "/admin/maintenance") {
-      // Only match exact path for overview, not sub-pages
-      return pathname === "/admin/maintenance"
-    }
     return pathname.startsWith(href)
   }
 
@@ -290,16 +231,6 @@ export function AdminNav() {
             {coreNavItems.map((item) => renderDesktopNavItem(item))}
           </div>
 
-          {/* Library Maintenance */}
-          <div className="space-y-1">
-            <div className="px-4 mb-2">
-              <span className="text-xs font-semibold text-slate-500 uppercase tracking-wider">
-                Library Maintenance
-              </span>
-            </div>
-            {maintenanceNavItems.map((item) => renderDesktopNavItem(item))}
-          </div>
-
           {/* Monitoring & Analytics */}
           <div className="space-y-1">
             <div className="px-4 mb-2">
diff --git a/components/maintenance/DataInspector.tsx b/components/maintenance/DataInspector.tsx
deleted file mode 100644
index 81cbf541..00000000
--- a/components/maintenance/DataInspector.tsx
+++ /dev/null
@@ -1,485 +0,0 @@
-"use client"
-
-import type { MediaItem } from "@/lib/maintenance/rule-evaluator"
-import { useState } from "react"
-
-interface DataInspectorProps {
-  item: MediaItem | null
-}
-
-export function DataInspector({ item }: DataInspectorProps) {
-  const [expandedSections, setExpandedSections] = useState<Record<string, boolean>>({
-    core: true,
-    plex: true,
-    tautulli: true,
-    radarr: true,
-    sonarr: true,
-    overseerr: false,
-  })
-
-  if (!item) {
-    return (
-      <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-4">
-        <div className="text-center py-6 text-slate-500 text-sm">
-          <svg className="w-10 h-10 mx-auto mb-2 text-slate-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-          </svg>
-          <p>Select media to inspect data</p>
-        </div>
-      </div>
-    )
-  }
-
-  const toggleSection = (section: string) => {
-    setExpandedSections(prev => ({
-      ...prev,
-      [section]: !prev[section],
-    }))
-  }
-
-  const toggleAll = () => {
-    const allExpanded = Object.values(expandedSections).every(v => v)
-    const newValue = !allExpanded
-    setExpandedSections({
-      core: newValue,
-      plex: newValue,
-      tautulli: newValue,
-      radarr: newValue,
-      sonarr: newValue,
-      overseerr: newValue,
-    })
-  }
-
-  // Type assertion helper
-  const plex = item.plex as Record<string, unknown> | null | undefined
-  const tautulli = item.tautulli as Record<string, unknown> | null | undefined
-  const radarr = item.radarr as Record<string, unknown> | undefined
-  const sonarr = item.sonarr as Record<string, unknown> | undefined
-  const overseerr = item.overseerr as Record<string, unknown> | null | undefined
-
-  return (
-    <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-4" data-testid="data-inspector">
-      <div className="flex items-center justify-between mb-4">
-        <h3 className="text-sm font-medium text-slate-400">Data Inspector</h3>
-        <button
-          onClick={toggleAll}
-          className="text-xs text-cyan-400 hover:text-cyan-300"
-        >
-          {Object.values(expandedSections).every(v => v) ? 'Collapse All' : 'Expand All'}
-        </button>
-      </div>
-
-      <div className="space-y-2 max-h-[400px] overflow-y-auto">
-        {/* Core Info */}
-        <ServiceSection
-          title="Core"
-          icon={<IconInfo />}
-          isExpanded={expandedSections.core}
-          onToggle={() => toggleSection('core')}
-          color="cyan"
-        >
-          <FieldRow label="ID" value={item.id} />
-          <FieldRow label="Title" value={item.title} />
-          <FieldRow label="Year" value={item.year} />
-          <FieldRow label="Media Type" value={item.mediaType} />
-          <FieldRow label="Genres" value={item.genres?.join(', ') || null} />
-          <FieldRow label="Play Count" value={item.playCount} />
-          <FieldRow label="Last Watched" value={formatDate(item.lastWatchedAt)} />
-          <FieldRow label="Added At" value={formatDate(item.addedAt)} />
-        </ServiceSection>
-
-        {/* Plex Section */}
-        <ServiceSection
-          title="Plex"
-          subtitle={plex ? "In Library" : "Not in Plex"}
-          icon={<IconPlex />}
-          isExpanded={expandedSections.plex}
-          onToggle={() => toggleSection('plex')}
-          color={plex ? "amber" : "slate"}
-          isEmpty={!plex}
-        >
-          {plex ? (
-            <>
-              <FieldRow label="Rating Key" value={plex.ratingKey} />
-              <FieldRow label="View Count" value={plex.viewCount} />
-              <FieldRow label="Last Viewed" value={formatDate(plex.lastViewedAt)} />
-              <FieldRow label="Added to Plex" value={formatDate(plex.addedAt)} />
-              <div className="pt-1 mt-1 border-t border-slate-700/50">
-                <span className="text-[10px] uppercase tracking-wider text-slate-500">Metadata</span>
-              </div>
-              <FieldRow label="Audience Rating" value={plex.audienceRating} />
-              <FieldRow label="Content Rating" value={plex.contentRating} />
-              <FieldRow label="Studio" value={plex.studio} />
-              <FieldRow label="Duration" value={plex.duration ? `${Math.round((plex.duration as number) / 60000)} min` : null} />
-              <FieldRow label="GUID" value={plex.guid} truncate />
-              <div className="pt-1 mt-1 border-t border-slate-700/50">
-                <span className="text-[10px] uppercase tracking-wider text-slate-500">Collections & Playlists</span>
-              </div>
-              <FieldRow label="Playlists" value={Array.isArray(plex.playlists) && plex.playlists.length > 0 ? (plex.playlists as string[]).join(', ') : null} />
-            </>
-          ) : (
-            <div className="text-xs text-slate-500 py-2">
-              Not found in Plex library. This may mean:
-              <ul className="mt-1 ml-3 list-disc text-slate-600">
-                <li>Not yet downloaded</li>
-                <li>Different title in Plex</li>
-                <li>Plex not configured</li>
-              </ul>
-            </div>
-          )}
-        </ServiceSection>
-
-        {/* Tautulli Section */}
-        <ServiceSection
-          title="Tautulli"
-          subtitle={tautulli ? "Connected" : "No data"}
-          icon={<IconTautulli />}
-          isExpanded={expandedSections.tautulli}
-          onToggle={() => toggleSection('tautulli')}
-          color={tautulli ? "purple" : "slate"}
-          isEmpty={!tautulli}
-        >
-          {tautulli ? (
-            <>
-              <FieldRow label="Plex Rating Key" value={tautulli.plexRatingKey} />
-              <div className="pt-1 mt-1 border-t border-slate-700/50">
-                <span className="text-[10px] uppercase tracking-wider text-slate-500">Playback</span>
-              </div>
-              <FieldRow label="Play Count" value={tautulli.playCount} />
-              <FieldRow label="Last Watched" value={formatDate(tautulli.lastWatchedAt)} />
-              <FieldRow label="Added to Plex" value={formatDate(tautulli.addedAt)} />
-              <div className="pt-1 mt-1 border-t border-slate-700/50">
-                <span className="text-[10px] uppercase tracking-wider text-slate-500">File Info</span>
-              </div>
-              <FieldRow label="File Size" value={formatBytes(tautulli.fileSize as number)} />
-              <FieldRow label="File Path" value={tautulli.filePath} truncate />
-              <FieldRow label="Duration" value={tautulli.duration ? `${tautulli.duration} min` : null} />
-              <div className="pt-1 mt-1 border-t border-slate-700/50">
-                <span className="text-[10px] uppercase tracking-wider text-slate-500">Quality</span>
-              </div>
-              <FieldRow label="Resolution" value={tautulli.resolution} />
-              <FieldRow label="Video Codec" value={tautulli.videoCodec} />
-              <FieldRow label="Audio Codec" value={tautulli.audioCodec} />
-              <FieldRow label="Bitrate" value={tautulli.bitrate ? `${tautulli.bitrate} kbps` : null} />
-              <FieldRow label="Container" value={tautulli.container} />
-            </>
-          ) : (
-            <div className="text-xs text-slate-500 py-2">
-              No Tautulli data available. This may mean:
-              <ul className="mt-1 ml-3 list-disc text-slate-600">
-                <li>Movie not in Plex library</li>
-                <li>Tautulli not configured</li>
-                <li>Title mismatch between services</li>
-              </ul>
-            </div>
-          )}
-        </ServiceSection>
-
-        {/* Radarr Section (Movies) */}
-        {item.mediaType === 'MOVIE' && (
-          <ServiceSection
-            title="Radarr"
-            subtitle={radarr ? (radarr.hasFile ? "Has File" : "Missing") : "No data"}
-            icon={<IconRadarr />}
-            isExpanded={expandedSections.radarr}
-            onToggle={() => toggleSection('radarr')}
-            color={radarr?.hasFile ? "green" : "amber"}
-            isEmpty={!radarr}
-          >
-            {radarr ? (
-              <>
-                <FieldRow label="Has File" value={radarr.hasFile ? 'Yes' : 'No'} highlight={!radarr.hasFile} />
-                <FieldRow label="Monitored" value={radarr.monitored ? 'Yes' : 'No'} />
-                <FieldRow label="Status" value={radarr.status} />
-                <FieldRow label="TMDB Rating" value={radarr.tmdbRating} />
-                <FieldRow label="Runtime" value={radarr.runtime ? `${radarr.runtime} min` : null} />
-                <FieldRow label="Size on Disk" value={formatBytes(radarr.sizeOnDisk as number)} />
-                <FieldRow label="Quality Profile" value={radarr.qualityProfileId} />
-                <FieldRow label="Min. Availability" value={radarr.minimumAvailability} />
-                <FieldRow label="Tags" value={Array.isArray(radarr.tags) ? radarr.tags.join(', ') : null} />
-                <FieldRow label="Digital Release" value={formatDate(radarr.digitalRelease)} />
-                <FieldRow label="In Cinemas" value={formatDate(radarr.inCinemas)} />
-                <FieldRow label="Added to Radarr" value={formatDate(radarr.addedAt)} />
-                <div className="pt-1 mt-1 border-t border-slate-700/50">
-                  <span className="text-[10px] uppercase tracking-wider text-slate-500">External IDs</span>
-                </div>
-                <FieldRow label="TMDB ID" value={radarr.tmdbId} />
-                <FieldRow label="IMDB ID" value={radarr.imdbId} />
-              </>
-            ) : (
-              <div className="text-xs text-slate-500 py-2">No Radarr data available</div>
-            )}
-          </ServiceSection>
-        )}
-
-        {/* Sonarr Section (TV) */}
-        {item.mediaType === 'TV_SERIES' && (
-          <ServiceSection
-            title="Sonarr"
-            subtitle={sonarr ? `${sonarr.episodeFileCount}/${sonarr.totalEpisodeCount} eps` : "No data"}
-            icon={<IconSonarr />}
-            isExpanded={expandedSections.sonarr}
-            onToggle={() => toggleSection('sonarr')}
-            color={sonarr ? "blue" : "slate"}
-            isEmpty={!sonarr}
-          >
-            {sonarr ? (
-              <>
-                <FieldRow label="Monitored" value={sonarr.monitored ? 'Yes' : 'No'} />
-                <FieldRow label="Status" value={sonarr.status} />
-                <FieldRow label="Series Type" value={sonarr.seriesType} />
-                <FieldRow label="Network" value={sonarr.network} />
-                <FieldRow label="Seasons" value={sonarr.seasonCount} />
-                <FieldRow label="Total Episodes" value={sonarr.totalEpisodeCount} />
-                <FieldRow label="Episode Files" value={sonarr.episodeFileCount} />
-                <FieldRow label="Completion" value={sonarr.percentOfEpisodes ? `${Math.round(sonarr.percentOfEpisodes as number)}%` : null} />
-                <FieldRow label="Size on Disk" value={formatBytes(sonarr.sizeOnDisk as number)} />
-                <FieldRow label="Ended" value={sonarr.ended ? 'Yes' : 'No'} />
-                <FieldRow label="First Aired" value={formatDate(sonarr.firstAired)} />
-                <FieldRow label="Certification" value={sonarr.certification} />
-                <FieldRow label="Quality Profile" value={sonarr.qualityProfileId} />
-                <FieldRow label="Tags" value={Array.isArray(sonarr.tags) ? sonarr.tags.join(', ') : null} />
-                <FieldRow label="Added to Sonarr" value={formatDate(sonarr.addedAt)} />
-                <div className="pt-1 mt-1 border-t border-slate-700/50">
-                  <span className="text-[10px] uppercase tracking-wider text-slate-500">External IDs</span>
-                </div>
-                <FieldRow label="TVDB ID" value={sonarr.tvdbId} />
-                <FieldRow label="IMDB ID" value={sonarr.imdbId} />
-              </>
-            ) : (
-              <div className="text-xs text-slate-500 py-2">No Sonarr data available</div>
-            )}
-          </ServiceSection>
-        )}
-
-        {/* Overseerr Section */}
-        <ServiceSection
-          title="Overseerr"
-          subtitle={overseerr ? (overseerr.hasRequest ? "Requested" : overseerr.status as string) : "No data"}
-          icon={<IconOverseerr />}
-          isExpanded={expandedSections.overseerr}
-          onToggle={() => toggleSection('overseerr')}
-          color={overseerr?.hasRequest ? "orange" : "slate"}
-          isEmpty={!overseerr}
-        >
-          {overseerr ? (
-            <>
-              <FieldRow label="Media Status" value={overseerr.status} />
-              <FieldRow label="Status Code" value={overseerr.mediaStatus} />
-              <FieldRow label="Has Request" value={overseerr.hasRequest ? 'Yes' : 'No'} />
-              <FieldRow label="Request Count" value={overseerr.requestCount} />
-              <FieldRow label="Requested By" value={overseerr.requestedBy} />
-              <FieldRow label="Requested At" value={formatDate(overseerr.requestedAt)} />
-              <FieldRow label="TMDB ID" value={overseerr.tmdbId} />
-            </>
-          ) : (
-            <div className="text-xs text-slate-500 py-2">
-              No Overseerr data available. This may mean:
-              <ul className="mt-1 ml-3 list-disc text-slate-600">
-                <li>No TMDB ID for this item</li>
-                <li>Overseerr not configured</li>
-                <li>Not in Overseerr database</li>
-              </ul>
-            </div>
-          )}
-        </ServiceSection>
-      </div>
-    </div>
-  )
-}
-
-// Service Section Component
-interface ServiceSectionProps {
-  title: string
-  subtitle?: string
-  icon: React.ReactNode
-  isExpanded: boolean
-  onToggle: () => void
-  color: 'cyan' | 'purple' | 'green' | 'amber' | 'blue' | 'orange' | 'slate'
-  isEmpty?: boolean
-  children: React.ReactNode
-}
-
-function ServiceSection({ title, subtitle, icon, isExpanded, onToggle, color, isEmpty, children }: ServiceSectionProps) {
-  const colorClasses = {
-    cyan: 'border-cyan-500/30 bg-cyan-500/5',
-    purple: 'border-purple-500/30 bg-purple-500/5',
-    green: 'border-green-500/30 bg-green-500/5',
-    amber: 'border-amber-500/30 bg-amber-500/5',
-    blue: 'border-blue-500/30 bg-blue-500/5',
-    orange: 'border-orange-500/30 bg-orange-500/5',
-    slate: 'border-slate-600/30 bg-slate-800/30',
-  }
-
-  const iconColors = {
-    cyan: 'text-cyan-400',
-    purple: 'text-purple-400',
-    green: 'text-green-400',
-    amber: 'text-amber-400',
-    blue: 'text-blue-400',
-    orange: 'text-orange-400',
-    slate: 'text-slate-500',
-  }
-
-  return (
-    <div className={`border rounded-lg overflow-hidden ${colorClasses[color]}`}>
-      <button
-        type="button"
-        onClick={onToggle}
-        className="w-full flex items-center gap-2 p-2.5 hover:bg-slate-800/30 transition-colors"
-      >
-        <span className={iconColors[color]}>{icon}</span>
-        <span className="text-sm font-medium text-slate-200 flex-1 text-left">{title}</span>
-        {subtitle && (
-          <span className={`text-xs ${isEmpty ? 'text-slate-500' : 'text-slate-400'}`}>
-            {subtitle}
-          </span>
-        )}
-        <svg
-          className={`w-4 h-4 text-slate-400 transition-transform ${isExpanded ? 'rotate-180' : ''}`}
-          fill="none"
-          stroke="currentColor"
-          viewBox="0 0 24 24"
-        >
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 9l-7 7-7-7" />
-        </svg>
-      </button>
-
-      {isExpanded && (
-        <div className="px-2.5 pb-2.5 space-y-0.5">
-          {children}
-        </div>
-      )}
-    </div>
-  )
-}
-
-// Field Row Component
-interface FieldRowProps {
-  label: string
-  value: unknown
-  truncate?: boolean
-  highlight?: boolean
-}
-
-function FieldRow({ label, value, truncate, highlight }: FieldRowProps) {
-  const [copied, setCopied] = useState(false)
-  const isNull = value === null || value === undefined || value === ''
-  const displayValue = isNull ? 'null' : String(value)
-
-  const handleCopy = () => {
-    if (!isNull) {
-      navigator.clipboard.writeText(displayValue)
-      setCopied(true)
-      setTimeout(() => setCopied(false), 1500)
-    }
-  }
-
-  return (
-    <div className="flex items-center justify-between py-1 px-1 rounded hover:bg-slate-800/30 group">
-      <span className="text-xs text-slate-500">{label}</span>
-      <div className="flex items-center gap-1.5">
-        <span
-          className={`text-xs font-mono ${
-            isNull
-              ? 'text-slate-600 italic'
-              : highlight
-                ? 'text-amber-400'
-                : 'text-slate-300'
-          } ${truncate ? 'max-w-[120px] truncate' : ''}`}
-          title={truncate ? displayValue : undefined}
-        >
-          {displayValue}
-        </span>
-        {!isNull && (
-          <button
-            type="button"
-            onClick={handleCopy}
-            className="opacity-0 group-hover:opacity-100 transition-opacity text-slate-500 hover:text-cyan-400"
-            title="Copy"
-          >
-            {copied ? (
-              <svg className="w-3 h-3 text-green-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 13l4 4L19 7" />
-              </svg>
-            ) : (
-              <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
-              </svg>
-            )}
-          </button>
-        )}
-      </div>
-    </div>
-  )
-}
-
-// Helper: Format date
-function formatDate(value: unknown): string | null {
-  if (!value) return null
-  try {
-    const date = value instanceof Date ? value : new Date(value as string)
-    return date.toLocaleDateString()
-  } catch {
-    return null
-  }
-}
-
-// Helper: Format bytes
-function formatBytes(bytes: number | null | undefined): string | null {
-  if (!bytes || bytes === 0) return null
-  const k = 1024
-  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`
-}
-
-// Icons
-function IconInfo() {
-  return (
-    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
-    </svg>
-  )
-}
-
-function IconTautulli() {
-  return (
-    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z" />
-    </svg>
-  )
-}
-
-function IconRadarr() {
-  return (
-    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 4v16M17 4v16M3 8h4m10 0h4M3 12h18M3 16h4m10 0h4M4 20h16a1 1 0 001-1V5a1 1 0 00-1-1H4a1 1 0 00-1 1v14a1 1 0 001 1z" />
-    </svg>
-  )
-}
-
-function IconSonarr() {
-  return (
-    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9.75 17L9 20l-1 1h8l-1-1-.75-3M3 13h18M5 17h14a2 2 0 002-2V5a2 2 0 00-2-2H5a2 2 0 00-2 2v10a2 2 0 002 2z" />
-    </svg>
-  )
-}
-
-function IconOverseerr() {
-  return (
-    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M15 17h5l-1.405-1.405A2.032 2.032 0 0118 14.158V11a6.002 6.002 0 00-4-5.659V5a2 2 0 10-4 0v.341C7.67 6.165 6 8.388 6 11v3.159c0 .538-.214 1.055-.595 1.436L4 17h5m6 0v1a3 3 0 11-6 0v-1m6 0H9" />
-    </svg>
-  )
-}
-
-function IconPlex() {
-  return (
-    <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z" />
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
-    </svg>
-  )
-}
diff --git a/components/maintenance/MediaBrowser.tsx b/components/maintenance/MediaBrowser.tsx
deleted file mode 100644
index 0b558860..00000000
--- a/components/maintenance/MediaBrowser.tsx
+++ /dev/null
@@ -1,273 +0,0 @@
-"use client"
-
-import { StyledInput } from "@/components/ui/styled-input"
-import { LoadingSpinner } from "@/components/ui/loading-spinner"
-import type { MediaItem } from "@/lib/maintenance/rule-evaluator"
-import type { MediaType, RuleCriteria } from "@/lib/validations/maintenance"
-import { evaluateRuleClient } from "@/lib/maintenance/client-evaluator"
-import { useQuery } from "@tanstack/react-query"
-import { useState, useMemo, useCallback, useEffect, useRef } from "react"
-
-interface MediaBrowserProps {
-  mediaType: MediaType
-  selectedItem: MediaItem | null
-  onSelectItem: (item: MediaItem | null) => void
-  criteria: RuleCriteria
-}
-
-interface MediaResponse {
-  items: MediaItem[]
-  error?: string
-}
-
-type FilterMode = 'all' | 'matching' | 'not-matching'
-
-export function MediaBrowser({ mediaType, selectedItem, onSelectItem, criteria }: MediaBrowserProps) {
-  const [search, setSearch] = useState("")
-  const [debouncedSearch, setDebouncedSearch] = useState("")
-  const [filterMode, setFilterMode] = useState<FilterMode>('all')
-  const debounceRef = useRef<NodeJS.Timeout | undefined>(undefined)
-
-  // Proper debounce with cleanup
-  useEffect(() => {
-    debounceRef.current = setTimeout(() => setDebouncedSearch(search), 300)
-    return () => {
-      if (debounceRef.current) clearTimeout(debounceRef.current)
-    }
-  }, [search])
-
-  const { data, isLoading, error } = useQuery<MediaResponse>({
-    queryKey: ['maintenance', 'media', mediaType, debouncedSearch],
-    queryFn: async () => {
-      const params = new URLSearchParams({
-        mediaType,
-        search: debouncedSearch,
-        limit: '50',
-      })
-      const response = await fetch(`/api/admin/maintenance/media?${params}`)
-      if (!response.ok) throw new Error('Failed to fetch media')
-      return response.json()
-    },
-    staleTime: 30 * 1000, // 30 seconds
-  })
-
-  const handleSelect = useCallback((item: MediaItem) => {
-    if (selectedItem?.id === item.id) {
-      onSelectItem(null)
-    } else {
-      onSelectItem(item)
-    }
-  }, [selectedItem, onSelectItem])
-
-  const items = data?.items || []
-
-  // Evaluate all items against the current criteria
-  const evaluatedItems = useMemo(() => {
-    return items.map(item => ({
-      item,
-      matches: evaluateRuleClient(item, criteria)
-    }))
-  }, [items, criteria])
-
-  // Filter based on mode
-  const filteredItems = useMemo(() => {
-    switch (filterMode) {
-      case 'matching':
-        return evaluatedItems.filter(e => e.matches)
-      case 'not-matching':
-        return evaluatedItems.filter(e => !e.matches)
-      default:
-        return evaluatedItems
-    }
-  }, [evaluatedItems, filterMode])
-
-  // Match statistics
-  const matchCount = evaluatedItems.filter(e => e.matches).length
-  const totalCount = evaluatedItems.length
-
-  // Auto-select first item when items load and nothing selected
-  useEffect(() => {
-    if (!selectedItem && filteredItems.length > 0 && !isLoading) {
-      onSelectItem(filteredItems[0].item)
-    }
-  }, [filteredItems, selectedItem, onSelectItem, isLoading])
-
-  return (
-    <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-4" data-testid="media-browser">
-      {/* Header with match summary */}
-      <div className="flex items-center justify-between mb-3">
-        <h3 className="text-sm font-medium text-slate-400">Test Media</h3>
-        {!isLoading && totalCount > 0 && (
-          <div className="flex items-center gap-1.5">
-            <span className={`text-xs font-medium ${matchCount > 0 ? 'text-green-400' : 'text-slate-500'}`}>
-              {matchCount}
-            </span>
-            <span className="text-xs text-slate-500">/</span>
-            <span className="text-xs text-slate-500">{totalCount} match</span>
-          </div>
-        )}
-      </div>
-
-      {/* Search */}
-      <div className="mb-3">
-        <StyledInput
-          type="text"
-          placeholder={`Search ${mediaType === 'MOVIE' ? 'movies' : 'series'}...`}
-          value={search}
-          onChange={(e) => setSearch(e.target.value)}
-          data-testid="media-browser-search"
-          className="text-sm"
-        />
-      </div>
-
-      {/* Filter tabs */}
-      <div className="flex gap-1 mb-3 bg-slate-900/50 p-1 rounded-lg" data-testid="media-browser-filters">
-        <FilterTab
-          active={filterMode === 'all'}
-          onClick={() => setFilterMode('all')}
-          label="All"
-          count={totalCount}
-          testId="filter-all"
-        />
-        <FilterTab
-          active={filterMode === 'matching'}
-          onClick={() => setFilterMode('matching')}
-          label="Matching"
-          count={matchCount}
-          variant="success"
-          testId="filter-matching"
-        />
-        <FilterTab
-          active={filterMode === 'not-matching'}
-          onClick={() => setFilterMode('not-matching')}
-          label="Not Matching"
-          count={totalCount - matchCount}
-          variant="danger"
-          testId="filter-not-matching"
-        />
-      </div>
-
-      {error && (
-        <div className="text-red-400 text-sm mb-3">
-          {error instanceof Error ? error.message : 'Failed to load media'}
-        </div>
-      )}
-
-      {data?.error && (
-        <div className="text-amber-400 text-sm mb-3">
-          {data.error}
-        </div>
-      )}
-
-      {/* Media list */}
-      <div className="space-y-1.5 max-h-[280px] overflow-y-auto">
-        {isLoading ? (
-          <div className="flex items-center justify-center py-6">
-            <LoadingSpinner label="Loading media" />
-          </div>
-        ) : filteredItems.length === 0 ? (
-          <div className="text-center py-6 text-slate-500 text-sm">
-            {debouncedSearch
-              ? 'No media found matching your search'
-              : filterMode !== 'all'
-                ? `No ${filterMode === 'matching' ? 'matching' : 'non-matching'} items`
-                : 'No media available'
-            }
-          </div>
-        ) : (
-          filteredItems.map(({ item, matches }) => (
-            <CompactMediaCard
-              key={item.id}
-              item={item}
-              matches={matches}
-              isSelected={selectedItem?.id === item.id}
-              onSelect={handleSelect}
-            />
-          ))
-        )}
-      </div>
-    </div>
-  )
-}
-
-interface FilterTabProps {
-  active: boolean
-  onClick: () => void
-  label: string
-  count: number
-  variant?: 'default' | 'success' | 'danger'
-  testId?: string
-}
-
-function FilterTab({ active, onClick, label, count, variant = 'default', testId }: FilterTabProps) {
-  const countColor = {
-    default: 'text-slate-400',
-    success: 'text-green-400',
-    danger: 'text-red-400',
-  }
-
-  return (
-    <button
-      type="button"
-      onClick={onClick}
-      data-testid={testId}
-      className={`
-        flex-1 px-2 py-1.5 text-xs font-medium rounded transition-colors
-        ${active
-          ? 'bg-slate-700 text-white'
-          : 'text-slate-400 hover:text-white hover:bg-slate-800'
-        }
-      `}
-    >
-      {label}
-      <span className={`ml-1 ${active ? 'text-slate-300' : countColor[variant]}`}>
-        {count}
-      </span>
-    </button>
-  )
-}
-
-interface CompactMediaCardProps {
-  item: MediaItem
-  matches: boolean
-  isSelected: boolean
-  onSelect: (item: MediaItem) => void
-}
-
-function CompactMediaCard({ item, matches, isSelected, onSelect }: CompactMediaCardProps) {
-  return (
-    <button
-      type="button"
-      onClick={() => onSelect(item)}
-      className={`
-        w-full text-left px-3 py-2 rounded-lg border transition-all flex items-center gap-3
-        ${isSelected
-          ? 'bg-cyan-900/30 border-cyan-500/50'
-          : 'bg-slate-900/50 border-slate-700/50 hover:border-slate-600'
-        }
-      `}
-      data-testid={`media-item-${item.id}`}
-    >
-      {/* Match indicator */}
-      <div className={`
-        w-2 h-2 rounded-full flex-shrink-0
-        ${matches ? 'bg-green-400' : 'bg-red-400'}
-      `} />
-
-      {/* Title and year */}
-      <div className="min-w-0 flex-1">
-        <p className="text-sm font-medium text-white truncate">{item.title}</p>
-        <p className="text-xs text-slate-500">{item.year || 'N/A'}</p>
-      </div>
-
-      {/* Quick status */}
-      <div className="text-right text-xs flex-shrink-0">
-        {item.playCount !== undefined && (
-          <p className={item.playCount > 0 ? 'text-slate-400' : 'text-amber-400'}>
-            {item.playCount > 0 ? `${item.playCount} plays` : 'Unwatched'}
-          </p>
-        )}
-      </div>
-    </button>
-  )
-}
diff --git a/components/maintenance/README.md b/components/maintenance/README.md
deleted file mode 100644
index b47872f4..00000000
--- a/components/maintenance/README.md
+++ /dev/null
@@ -1,195 +0,0 @@
-# Maintenance UI Components
-
-Reusable UI components for the maintenance feature system.
-
-## Components
-
-### ScanStatusBadge
-
-Simple badge component for displaying scan status with color coding.
-
-**Usage:**
-```tsx
-import { ScanStatusBadge } from "@/components/maintenance"
-
-<ScanStatusBadge status="COMPLETED" />
-```
-
-**Props:**
-- `status`: ScanStatus - One of "PENDING", "RUNNING", "COMPLETED", "FAILED"
-
-**Color Coding:**
-- PENDING: Yellow
-- RUNNING: Blue
-- COMPLETED: Green
-- FAILED: Red
-
----
-
-### StatsCard
-
-Displays statistics with optional icon and trend indicator.
-
-**Usage:**
-```tsx
-import { StatsCard } from "@/components/maintenance"
-
-<StatsCard
-  label="Total Candidates"
-  value={42}
-  variant="warning"
-  icon={
-    <svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
-    </svg>
-  }
-  trend={{ value: 15, isPositive: false }}
-/>
-```
-
-**Props:**
-- `label`: string - Display label
-- `value`: string | number - Main value to display
-- `icon?`: ReactNode - Optional icon
-- `trend?`: { value: number, isPositive: boolean } - Optional trend indicator
-- `variant?`: "default" | "success" | "warning" | "danger" - Color variant (default: "default")
-
----
-
-### CandidateCard
-
-Card component for displaying deletion candidate details with approve/reject actions.
-
-**Usage:**
-```tsx
-import { CandidateCard } from "@/components/maintenance"
-
-<CandidateCard
-  candidate={candidateData}
-  onApprove={(id) => console.log("Approved:", id)}
-  onReject={(id) => console.log("Rejected:", id)}
-/>
-```
-
-**Props:**
-- `candidate`: CandidateWithDetails - Candidate object with scan and rule details
-- `onApprove`: (candidateId: string) => void - Callback when approve button is clicked
-- `onReject`: (candidateId: string) => void - Callback when reject button is clicked
-
-**Features:**
-- Displays poster image or placeholder
-- Shows title, year, and media type
-- Grid layout for stats (file size, play count, last watched, added date)
-- File path display
-- Approve/Reject action buttons
-
----
-
-### RuleCriteriaBuilder
-
-Interactive form component for building and editing rule criteria.
-
-**Usage:**
-```tsx
-import { RuleCriteriaBuilder } from "@/components/maintenance"
-import { useState } from "react"
-
-const [criteria, setCriteria] = useState<RuleCriteria>({
-  operator: "AND",
-})
-
-<RuleCriteriaBuilder
-  value={criteria}
-  onChange={setCriteria}
-  libraryOptions={[
-    { id: "1", name: "Movies" },
-    { id: "2", name: "TV Shows" },
-  ]}
-/>
-```
-
-**Props:**
-- `value`: RuleCriteria - Current criteria object
-- `onChange`: (criteria: RuleCriteria) => void - Callback when criteria changes
-- `libraryOptions?`: Array<{ id: string, name: string }> - Available library options
-
-**Supported Criteria:**
-- `neverWatched`: boolean - Match items never watched
-- `lastWatchedBefore`: { value: number, unit: "days" | "months" | "years" } - Last watched timeframe
-- `maxPlayCount`: number - Maximum play count
-- `addedBefore`: { value: number, unit: "days" | "months" | "years" } - Added timeframe
-- `minFileSize`: { value: number, unit: "MB" | "GB" | "TB" } - Minimum file size
-- `maxQuality`: string - Maximum quality (e.g., "720p", "SD")
-- `maxRating`: number - Maximum rating (0-10)
-- `libraryIds`: string[] - Specific library IDs
-- `operator`: "AND" | "OR" - Criteria matching operator
-
-**Features:**
-- AND/OR operator toggle
-- Basic criteria (always visible)
-- Advanced criteria (collapsible)
-- Clear buttons for optional fields
-- Library multi-select
-- Time unit dropdowns (days/months/years)
-- File size unit dropdowns (MB/GB/TB)
-
-## Example: Complete Usage
-
-```tsx
-"use client"
-
-import { useState } from "react"
-import {
-  ScanStatusBadge,
-  StatsCard,
-  CandidateCard,
-  RuleCriteriaBuilder,
-} from "@/components/maintenance"
-import type { RuleCriteria } from "@/types/maintenance"
-
-export function MaintenanceDashboard() {
-  const [criteria, setCriteria] = useState<RuleCriteria>({
-    operator: "AND",
-  })
-
-  return (
-    <div className="space-y-6">
-      {/* Stats Overview */}
-      <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
-        <StatsCard label="Total Rules" value={5} variant="default" />
-        <StatsCard label="Pending Candidates" value={23} variant="warning" />
-        <StatsCard label="Last Scan" value={<ScanStatusBadge status="COMPLETED" />} />
-      </div>
-
-      {/* Rule Builder */}
-      <div className="bg-slate-800/30 p-6 rounded-lg border border-slate-700">
-        <h2 className="text-xl font-bold text-white mb-4">Create Rule</h2>
-        <RuleCriteriaBuilder
-          value={criteria}
-          onChange={setCriteria}
-          libraryOptions={[
-            { id: "1", name: "Movies" },
-            { id: "2", name: "TV Shows" },
-          ]}
-        />
-      </div>
-
-      {/* Candidates List */}
-      <div className="space-y-4">
-        <h2 className="text-xl font-bold text-white">Review Candidates</h2>
-        {/* Map over candidates */}
-      </div>
-    </div>
-  )
-}
-```
-
-## Styling
-
-All components follow the project's dark theme design system:
-- Background: slate-800/slate-900 tones
-- Borders: slate-700/slate-600
-- Text: white/slate-200/slate-400
-- Accent colors: cyan for primary, red for danger, green for success, yellow for warning
-- Hover states and transitions included
-- Responsive design with mobile-first approach
diff --git a/components/maintenance/RuleForm.tsx b/components/maintenance/RuleForm.tsx
deleted file mode 100644
index fe8cc8c9..00000000
--- a/components/maintenance/RuleForm.tsx
+++ /dev/null
@@ -1,524 +0,0 @@
-"use client"
-
-import { createMaintenanceRule, updateMaintenanceRule } from "@/actions/maintenance"
-import { EnhancedRuleBuilder, createDefaultCriteria } from "@/components/maintenance/enhanced-rule-builder"
-import { Button } from "@/components/ui/button"
-import { LoadingSpinner } from "@/components/ui/loading-spinner"
-import { StyledDropdown } from "@/components/ui/styled-dropdown"
-import { StyledInput } from "@/components/ui/styled-input"
-import { StyledTextarea } from "@/components/ui/styled-textarea"
-import { useToast } from "@/components/ui/toast"
-import type { ActionType, MediaType, RuleCriteria } from "@/lib/validations/maintenance"
-import { radarrServerListSchema } from "@/lib/validations/radarr"
-import { sonarrServerListSchema } from "@/lib/validations/sonarr"
-import { useRouter } from "next/navigation"
-import { useEffect, useState } from "react"
-import { useQuery } from "@tanstack/react-query"
-import { MediaBrowser } from "@/components/maintenance/MediaBrowser"
-import { RulePreviewPanel } from "@/components/maintenance/RulePreviewPanel"
-import { DataInspector } from "@/components/maintenance/DataInspector"
-import type { MediaItem } from "@/lib/maintenance/rule-evaluator"
-
-export interface MaintenanceRuleData {
-  id?: string
-  name: string
-  description?: string | null
-  enabled: boolean
-  mediaType: MediaType
-  criteria: RuleCriteria
-  actionType: ActionType
-  actionDelayDays?: number | null
-  radarrId?: string | null
-  sonarrId?: string | null
-  schedule?: string | null
-}
-
-interface RuleFormProps {
-  /** Mode of the form */
-  mode: "create" | "edit"
-  /** Initial data for edit mode */
-  initialData?: MaintenanceRuleData
-  /** Callback after successful save */
-  onSuccess?: () => void
-}
-
-export function RuleForm({ mode, initialData, onSuccess }: RuleFormProps) {
-  const toast = useToast()
-  const router = useRouter()
-  const [isSubmitting, setIsSubmitting] = useState(false)
-
-  // Form state - initialize from initialData if provided
-  const [name, setName] = useState(initialData?.name ?? "")
-  const [description, setDescription] = useState(initialData?.description ?? "")
-  const [enabled, setEnabled] = useState(initialData?.enabled ?? true)
-  const [mediaType, setMediaType] = useState<MediaType>(initialData?.mediaType ?? "MOVIE")
-  const [actionType, setActionType] = useState<ActionType>(initialData?.actionType ?? "FLAG_FOR_REVIEW")
-  const [actionDelayDays, setActionDelayDays] = useState<number | undefined>(
-    initialData?.actionDelayDays ?? undefined
-  )
-  const [radarrId, setRadarrId] = useState<string | undefined>(initialData?.radarrId ?? undefined)
-  const [sonarrId, setSonarrId] = useState<string | undefined>(initialData?.sonarrId ?? undefined)
-  const [schedule, setSchedule] = useState(initialData?.schedule ?? "")
-
-  // Criteria state - start with initial data or default
-  const [criteria, setCriteria] = useState<RuleCriteria>(
-    () => initialData?.criteria ?? createDefaultCriteria(initialData?.mediaType ?? "MOVIE")
-  )
-
-  // Media preview state
-  const [selectedMedia, setSelectedMedia] = useState<MediaItem | null>(null)
-  const [showPreview, setShowPreview] = useState(false)
-  const [previewTab, setPreviewTab] = useState<'preview' | 'inspector'>('preview')
-
-  // Fetch Radarr servers
-  const { data: radarrData, isLoading: radarrLoading, error: radarrError } = useQuery({
-    queryKey: ['admin', 'maintenance', 'radarr-servers'],
-    queryFn: async () => {
-      const response = await fetch('/api/admin/radarr')
-      if (!response.ok) throw new Error('Failed to fetch Radarr servers')
-      const data = await response.json()
-      return radarrServerListSchema.parse(data)
-    },
-    staleTime: 5 * 60 * 1000,
-    retry: 1,
-    retryDelay: 1000,
-  })
-
-  // Fetch Sonarr servers
-  const { data: sonarrData, isLoading: sonarrLoading, error: sonarrError } = useQuery({
-    queryKey: ['admin', 'maintenance', 'sonarr-servers'],
-    queryFn: async () => {
-      const response = await fetch('/api/admin/sonarr')
-      if (!response.ok) throw new Error('Failed to fetch Sonarr servers')
-      const data = await response.json()
-      return sonarrServerListSchema.parse(data)
-    },
-    staleTime: 5 * 60 * 1000,
-    retry: 1,
-    retryDelay: 1000,
-  })
-
-  // Handle Radarr fetch errors
-  useEffect(() => {
-    if (radarrError) {
-      toast.showError(`Failed to load Radarr servers: ${radarrError instanceof Error ? radarrError.message : 'Unknown error'}`)
-    }
-  }, [radarrError, toast])
-
-  // Handle Sonarr fetch errors
-  useEffect(() => {
-    if (sonarrError) {
-      toast.showError(`Failed to load Sonarr servers: ${sonarrError instanceof Error ? sonarrError.message : 'Unknown error'}`)
-    }
-  }, [sonarrError, toast])
-
-  const radarrServers = radarrData?.servers || []
-  const sonarrServers = sonarrData?.servers || []
-
-  // Update criteria when media type changes (only in create mode)
-  const handleMediaTypeChange = (newMediaType: MediaType) => {
-    setMediaType(newMediaType)
-    if (mode === "create") {
-      setCriteria(createDefaultCriteria(newMediaType))
-    }
-  }
-
-  async function handleSubmit(e: React.FormEvent) {
-    e.preventDefault()
-
-    if (!name.trim()) {
-      toast.showError("Rule name is required")
-      return
-    }
-
-    // Validate criteria has at least one condition
-    if (!criteria.conditions || criteria.conditions.length === 0) {
-      toast.showError("At least one condition is required")
-      return
-    }
-
-    setIsSubmitting(true)
-
-    try {
-      const ruleData = {
-        name: name.trim(),
-        description: description.trim() || undefined,
-        enabled,
-        mediaType,
-        criteria,
-        actionType,
-        actionDelayDays,
-        radarrId,
-        sonarrId,
-        schedule: schedule.trim() || undefined,
-      }
-
-      const result = mode === "create"
-        ? await createMaintenanceRule(ruleData)
-        : await updateMaintenanceRule(initialData!.id!, ruleData)
-
-      if (result.success) {
-        toast.showSuccess(mode === "create" ? "Maintenance rule created successfully" : "Maintenance rule updated successfully")
-        if (onSuccess) {
-          onSuccess()
-        } else {
-          // Small delay to ensure toast is visible before navigation
-          setTimeout(() => {
-            router.push("/admin/maintenance/rules")
-          }, 100)
-        }
-      } else {
-        toast.showError(result.error || `Failed to ${mode} rule`)
-      }
-    } catch (error) {
-      toast.showError(error instanceof Error ? error.message : `Failed to ${mode} rule`)
-    } finally {
-      setIsSubmitting(false)
-    }
-  }
-
-  return (
-    <div className="relative">
-      {/* Main Form - Full Width */}
-      <form onSubmit={handleSubmit} className="space-y-6">
-        {/* Basic Information */}
-        <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-6">
-          <h2 className="text-lg font-semibold text-white mb-4">Basic Information</h2>
-
-          <div className="space-y-4">
-            <div>
-              <label htmlFor="name" className="block text-sm font-medium text-slate-400 mb-2">
-                Rule Name <span className="text-red-400">*</span>
-              </label>
-              <StyledInput
-                id="name"
-                type="text"
-                value={name}
-                onChange={(e) => setName(e.target.value)}
-                placeholder="e.g., Remove unwatched movies older than 6 months"
-                required
-                data-testid="maintenance-rule-name-input"
-              />
-            </div>
-
-            <div>
-              <label htmlFor="description" className="block text-sm font-medium text-slate-400 mb-2">
-                Description
-              </label>
-              <StyledTextarea
-                id="description"
-                value={description}
-                onChange={(e) => setDescription(e.target.value)}
-                rows={3}
-                placeholder="Optional description of what this rule does"
-              />
-            </div>
-
-            <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
-              <div>
-                <label htmlFor="mediaType" className="block text-sm font-medium text-slate-400 mb-2">
-                  Media Type
-                </label>
-                <StyledDropdown
-                  id="mediaType"
-                  value={mediaType}
-                  onChange={(value) => handleMediaTypeChange(value as MediaType)}
-                  options={[
-                    { value: "MOVIE", label: "Movie" },
-                    { value: "TV_SERIES", label: "TV Series" },
-                    { value: "EPISODE", label: "Episode" },
-                  ]}
-                  size="md"
-                  data-testid="maintenance-rule-media-type-select"
-                />
-              </div>
-
-              <div>
-                <label htmlFor="actionType" className="block text-sm font-medium text-slate-400 mb-2">
-                  Action Type
-                </label>
-                <StyledDropdown
-                  id="actionType"
-                  value={actionType}
-                  onChange={(value) => setActionType(value as ActionType)}
-                  options={[
-                    { value: "FLAG_FOR_REVIEW", label: "Flag for Review" },
-                    { value: "AUTO_DELETE", label: "Auto Delete" },
-                    { value: "UNMONITOR_AND_DELETE", label: "Unmonitor & Delete" },
-                    { value: "UNMONITOR_AND_KEEP", label: "Unmonitor & Keep Files" },
-                    { value: "DO_NOTHING", label: "Report Only (No Action)" },
-                  ]}
-                  size="md"
-                  data-testid="maintenance-rule-action-type-select"
-                />
-              </div>
-            </div>
-
-            {/* Action delay */}
-            <div>
-              <label htmlFor="actionDelayDays" className="block text-sm font-medium text-slate-400 mb-2">
-                Action Delay (Optional)
-              </label>
-              <StyledInput
-                id="actionDelayDays"
-                type="number"
-                min="0"
-                value={actionDelayDays ?? ""}
-                onChange={(e) => setActionDelayDays(e.target.value ? parseInt(e.target.value) : undefined)}
-                placeholder="0"
-              />
-              <p className="text-xs text-slate-500 mt-1">
-                Number of days to wait before executing the action. Leave empty for immediate action.
-              </p>
-            </div>
-
-            {/* Server instance selection */}
-            <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
-              {mediaType === "MOVIE" && (
-                <div>
-                  <label htmlFor="radarrId" className="block text-sm font-medium text-slate-400 mb-2">
-                    Radarr Server (Optional)
-                  </label>
-                  {radarrLoading ? (
-                    <div className="w-full bg-slate-800/50 border border-slate-600 rounded-lg px-4 py-2 text-slate-400">
-                      Loading servers...
-                    </div>
-                  ) : (
-                    <StyledDropdown
-                      id="radarrId"
-                      value={radarrId ?? ""}
-                      onChange={(value) => setRadarrId(value || undefined)}
-                      options={
-                        radarrServers.length > 0
-                          ? [
-                              { value: "", label: "Use active server" },
-                              ...radarrServers.map(s => ({ value: s.id, label: s.name }))
-                            ]
-                          : [{ value: "", label: "No servers configured" }]
-                      }
-                      size="md"
-                      disabled={radarrServers.length === 0}
-                    />
-                  )}
-                  <p className="text-xs text-slate-500 mt-1">
-                    {radarrServers.length > 0
-                      ? "Defaults to the active Radarr instance if not specified."
-                      : "Configure a Radarr server in settings to enable this option."}
-                  </p>
-                </div>
-              )}
-
-              {(mediaType === "TV_SERIES" || mediaType === "EPISODE") && (
-                <div>
-                  <label htmlFor="sonarrId" className="block text-sm font-medium text-slate-400 mb-2">
-                    Sonarr Server (Optional)
-                  </label>
-                  {sonarrLoading ? (
-                    <div className="w-full bg-slate-800/50 border border-slate-600 rounded-lg px-4 py-2 text-slate-400">
-                      Loading servers...
-                    </div>
-                  ) : (
-                    <StyledDropdown
-                      id="sonarrId"
-                      value={sonarrId ?? ""}
-                      onChange={(value) => setSonarrId(value || undefined)}
-                      options={
-                        sonarrServers.length > 0
-                          ? [
-                              { value: "", label: "Use active server" },
-                              ...sonarrServers.map(s => ({ value: s.id, label: s.name }))
-                            ]
-                          : [{ value: "", label: "No servers configured" }]
-                      }
-                      size="md"
-                      disabled={sonarrServers.length === 0}
-                    />
-                  )}
-                  <p className="text-xs text-slate-500 mt-1">
-                    {sonarrServers.length > 0
-                      ? "Defaults to the active Sonarr instance if not specified."
-                      : "Configure a Sonarr server in settings to enable this option."}
-                  </p>
-                </div>
-              )}
-            </div>
-
-            <div>
-              <label className="flex items-center space-x-2 cursor-pointer">
-                <input
-                  type="checkbox"
-                  checked={enabled}
-                  onChange={(e) => setEnabled(e.target.checked)}
-                  className="rounded border-slate-600 text-cyan-600 focus:ring-cyan-500"
-                />
-                <span className="text-sm font-medium text-slate-400">
-                  Enable rule {mode === "create" ? "immediately" : ""}
-                </span>
-              </label>
-            </div>
-          </div>
-        </div>
-
-        {/* Enhanced Rule Builder */}
-        <EnhancedRuleBuilder
-          value={criteria}
-          onChange={setCriteria}
-          mediaType={mediaType}
-        />
-
-        {/* Schedule (Optional) */}
-        <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-6">
-          <h2 className="text-lg font-semibold text-white mb-4">Schedule (Optional)</h2>
-          <div>
-            <label htmlFor="schedule" className="block text-sm font-medium text-slate-400 mb-2">
-              Cron Expression
-            </label>
-            <StyledInput
-              id="schedule"
-              type="text"
-              value={schedule}
-              onChange={(e) => setSchedule(e.target.value)}
-              placeholder="0 2 * * * (2 AM daily)"
-            />
-            <div className="mt-2 space-y-1">
-              <p className="text-xs text-slate-500">
-                Leave empty to disable automatic scheduling. Examples:
-              </p>
-              <ul className="text-xs text-slate-500 list-disc list-inside space-y-0.5 pl-1">
-                <li><code className="text-slate-400 bg-slate-800 px-1 rounded">0 2 * * *</code> — Daily at 2 AM</li>
-                <li><code className="text-slate-400 bg-slate-800 px-1 rounded">0 */6 * * *</code> — Every 6 hours</li>
-                <li><code className="text-slate-400 bg-slate-800 px-1 rounded">30 3 * * 0</code> — Weekly on Sunday at 3:30 AM</li>
-              </ul>
-            </div>
-          </div>
-        </div>
-
-        {/* Actions */}
-        <div className="flex gap-3">
-          <Button
-            type="button"
-            variant="secondary"
-            onClick={() => router.back()}
-            className="flex-1"
-            data-testid="maintenance-rule-cancel"
-          >
-            Cancel
-          </Button>
-          <Button
-            type="submit"
-            variant="primary"
-            disabled={isSubmitting}
-            className="flex-1"
-            data-testid="maintenance-rule-submit"
-          >
-            {isSubmitting ? (
-              <>
-                <LoadingSpinner size="sm" label={mode === "create" ? "Creating rule" : "Saving rule"} className="text-white" />
-                {mode === "create" ? "Creating..." : "Saving..."}
-              </>
-            ) : (
-              mode === "create" ? "Create Rule" : "Save Changes"
-            )}
-          </Button>
-        </div>
-      </form>
-
-      {/* Floating Test Rule Button - positioned to avoid AI assistant button */}
-      <button
-        type="button"
-        onClick={() => setShowPreview(true)}
-        className={`fixed bottom-6 right-24 flex items-center gap-2 px-4 py-3 bg-cyan-600 hover:bg-cyan-700 text-white rounded-full shadow-lg transition-all z-40 ${
-          showPreview ? 'opacity-0 pointer-events-none' : 'opacity-100'
-        }`}
-        data-testid="rule-preview-toggle"
-      >
-        <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-          <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-        </svg>
-        <span className="font-medium">Test Rule</span>
-      </button>
-
-      {/* Slide-out Drawer */}
-      {showPreview && (
-        <>
-          {/* Backdrop */}
-          <div
-            className="fixed inset-0 bg-black/50 z-40"
-            onClick={() => setShowPreview(false)}
-          />
-
-          {/* Drawer Panel */}
-          <div className="fixed top-0 right-0 h-full w-full sm:w-[480px] bg-slate-900 border-l border-slate-700 z-50 overflow-y-auto animate-in slide-in-from-right duration-300">
-            {/* Drawer Header */}
-            <div className="sticky top-0 bg-slate-900 border-b border-slate-700 p-4 flex items-center justify-between">
-              <div>
-                <h2 className="text-lg font-semibold text-white">Test Rule</h2>
-                <p className="text-sm text-slate-400">
-                  Select media to see real-time evaluation
-                </p>
-              </div>
-              <button
-                type="button"
-                onClick={() => setShowPreview(false)}
-                className="p-2 text-slate-400 hover:text-white rounded-lg hover:bg-slate-800 transition-colors"
-              >
-                <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                  <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
-                </svg>
-              </button>
-            </div>
-
-            {/* Drawer Content */}
-            <div className="p-4 space-y-4">
-              {/* Media Browser */}
-              <MediaBrowser
-                mediaType={mediaType}
-                selectedItem={selectedMedia}
-                onSelectItem={setSelectedMedia}
-                criteria={criteria}
-              />
-
-              {/* Tabs for Preview / Inspector */}
-              <div className="flex gap-1 bg-slate-800/50 p-1 rounded-lg">
-                <button
-                  type="button"
-                  onClick={() => setPreviewTab('preview')}
-                  className={`flex-1 px-3 py-2 text-sm font-medium rounded-md transition-colors ${
-                    previewTab === 'preview'
-                      ? 'bg-cyan-600 text-white'
-                      : 'text-slate-400 hover:text-white hover:bg-slate-700'
-                  }`}
-                  data-testid="rule-preview-tab"
-                >
-                  Rule Preview
-                </button>
-                <button
-                  type="button"
-                  onClick={() => setPreviewTab('inspector')}
-                  className={`flex-1 px-3 py-2 text-sm font-medium rounded-md transition-colors ${
-                    previewTab === 'inspector'
-                      ? 'bg-cyan-600 text-white'
-                      : 'text-slate-400 hover:text-white hover:bg-slate-700'
-                  }`}
-                  data-testid="data-inspector-tab"
-                >
-                  Data Inspector
-                </button>
-              </div>
-
-              {/* Preview/Inspector Content */}
-              {previewTab === 'preview' ? (
-                <RulePreviewPanel
-                  criteria={criteria}
-                  selectedItem={selectedMedia}
-                />
-              ) : (
-                <DataInspector item={selectedMedia} />
-              )}
-            </div>
-          </div>
-        </>
-      )}
-    </div>
-  )
-}
diff --git a/components/maintenance/RulePreviewPanel.tsx b/components/maintenance/RulePreviewPanel.tsx
deleted file mode 100644
index 37f22346..00000000
--- a/components/maintenance/RulePreviewPanel.tsx
+++ /dev/null
@@ -1,134 +0,0 @@
-"use client"
-
-import type { MediaItem } from "@/lib/maintenance/rule-evaluator"
-import type { RuleCriteria } from "@/lib/validations/maintenance"
-import { evaluateRuleWithDetails, type ConditionResult } from "@/lib/maintenance/client-evaluator"
-import { useMemo } from "react"
-
-interface RulePreviewPanelProps {
-  criteria: RuleCriteria
-  selectedItem: MediaItem | null
-}
-
-export function RulePreviewPanel({ criteria, selectedItem }: RulePreviewPanelProps) {
-  const evaluationResult = useMemo(() => {
-    if (!selectedItem) return null
-    return evaluateRuleWithDetails(selectedItem, criteria)
-  }, [criteria, selectedItem])
-
-  if (!selectedItem) {
-    return (
-      <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-4" data-testid="rule-preview-panel">
-        <div className="text-center py-6 text-slate-500 text-sm">
-          <svg className="w-10 h-10 mx-auto mb-2 text-slate-600" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M15 12a3 3 0 11-6 0 3 3 0 016 0z" />
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z" />
-          </svg>
-          <p>Select media to see evaluation</p>
-        </div>
-      </div>
-    )
-  }
-
-  const matches = evaluationResult?.matches ?? false
-  const conditionResults = evaluationResult?.conditionResults ?? []
-  const passedCount = conditionResults.filter(r => r.passed).length
-
-  return (
-    <div className="bg-slate-800/50 rounded-lg border border-slate-700 p-4" data-testid="rule-preview-panel">
-      {/* Result header */}
-      <div className={`flex items-center justify-between p-3 rounded-lg mb-4 ${
-        matches ? 'bg-green-900/20' : 'bg-red-900/20'
-      }`} data-testid="rule-preview-result">
-        <div className="flex items-center gap-2">
-          <div className={`w-3 h-3 rounded-full ${matches ? 'bg-green-400' : 'bg-red-400'}`} />
-          <span className={`text-sm font-medium ${matches ? 'text-green-400' : 'text-red-400'}`}>
-            {matches ? 'Would be flagged' : 'Would NOT be flagged'}
-          </span>
-        </div>
-        <span className="text-xs text-slate-500">
-          {passedCount}/{conditionResults.length} pass
-        </span>
-      </div>
-
-      {/* Condition results */}
-      {conditionResults.length === 0 ? (
-        <div className="text-sm text-slate-500 text-center py-4">
-          No conditions to evaluate
-        </div>
-      ) : (
-        <div className="space-y-1.5 max-h-[300px] overflow-y-auto">
-          {conditionResults.map((result, index) => (
-            <ConditionResultRow key={index} result={result} />
-          ))}
-        </div>
-      )}
-    </div>
-  )
-}
-
-interface ConditionResultRowProps {
-  result: ConditionResult
-}
-
-function ConditionResultRow({ result }: ConditionResultRowProps) {
-  const formatValue = (value: unknown): string => {
-    if (value === null || value === undefined) return 'null'
-    if (value instanceof Date) return value.toLocaleDateString()
-    if (typeof value === 'boolean') return value ? 'true' : 'false'
-    if (Array.isArray(value)) {
-      if (value.length === 0) return '(empty)'
-      if (value.length > 3) return `${value.slice(0, 3).join(', ')}...`
-      return value.join(', ')
-    }
-    if (typeof value === 'object') return JSON.stringify(value)
-    const str = String(value)
-    return str.length > 20 ? str.slice(0, 20) + '...' : str
-  }
-
-  // Format operator to be more readable
-  const formatOperator = (op: string): string => {
-    const opMap: Record<string, string> = {
-      equals: '=',
-      notEquals: '≠',
-      contains: 'contains',
-      notContains: '!contains',
-      greaterThan: '>',
-      greaterThanOrEqual: '≥',
-      lessThan: '<',
-      lessThanOrEqual: '≤',
-      olderThan: 'older than',
-      newerThan: 'newer than',
-      null: 'is null',
-      notNull: 'is not null',
-    }
-    return opMap[op] || op
-  }
-
-  return (
-    <div className={`
-      flex items-center gap-2 px-3 py-2 rounded-lg text-xs
-      ${result.passed
-        ? 'bg-green-900/10 border border-green-500/20'
-        : 'bg-red-900/10 border border-red-500/20'
-      }
-    `}>
-      {/* Pass/fail indicator */}
-      <div className={`w-1.5 h-1.5 rounded-full flex-shrink-0 ${result.passed ? 'bg-green-400' : 'bg-red-400'}`} />
-
-      {/* Field and condition */}
-      <div className="flex-1 min-w-0">
-        <span className="text-slate-300">{result.fieldLabel}</span>
-        <span className="text-cyan-400 mx-1">{formatOperator(result.operator)}</span>
-        <span className="text-slate-400 font-mono">{formatValue(result.expectedValue)}</span>
-      </div>
-
-      {/* Actual value (on hover/always shown for failed) */}
-      {!result.passed && (
-        <div className="text-slate-500 flex-shrink-0">
-          got: <span className="font-mono text-red-300">{formatValue(result.actualValue)}</span>
-        </div>
-      )}
-    </div>
-  )
-}
diff --git a/components/maintenance/candidate-card.tsx b/components/maintenance/candidate-card.tsx
deleted file mode 100644
index f77d6a86..00000000
--- a/components/maintenance/candidate-card.tsx
+++ /dev/null
@@ -1,110 +0,0 @@
-"use client"
-
-import type { CandidateWithDetails } from "@/types/maintenance"
-import { formatFileSize, formatDate } from "@/lib/utils/formatters"
-import { Film, Check, X } from "lucide-react"
-import { Button } from "@/components/ui/button"
-
-interface CandidateCardProps {
-  candidate: CandidateWithDetails
-  onApprove: (candidateId: string) => void
-  onReject: (candidateId: string) => void
-}
-
-export function CandidateCard({ candidate, onApprove, onReject }: CandidateCardProps) {
-  return (
-    <div className="bg-slate-800/50 border border-slate-700 rounded-lg p-4 hover:border-slate-600 transition-colors" data-testid="maintenance-candidate-card">
-      <div className="flex gap-4">
-        {/* Poster */}
-        <div className="flex-shrink-0">
-          {candidate.poster ? (
-            <img
-              src={candidate.poster}
-              alt={candidate.title}
-              className="w-24 h-36 object-cover rounded-lg"
-            />
-          ) : (
-            <div className="w-24 h-36 bg-slate-700 rounded-lg flex items-center justify-center">
-              <Film className="w-8 h-8 text-slate-500" />
-            </div>
-          )}
-        </div>
-
-        {/* Content */}
-        <div className="flex-1 min-w-0">
-          <div className="flex items-start justify-between gap-2 mb-2">
-            <div>
-              <h3 className="text-lg font-semibold text-white truncate">
-                {candidate.title}
-              </h3>
-              {candidate.year && (
-                <p className="text-sm text-slate-400">({candidate.year})</p>
-              )}
-            </div>
-            <span className="text-xs px-2 py-1 bg-slate-700 text-slate-300 rounded whitespace-nowrap">
-              {candidate.mediaType}
-            </span>
-          </div>
-
-          {/* Stats Grid */}
-          <div className="grid grid-cols-2 gap-3 mb-3">
-            <div>
-              <p className="text-xs text-slate-400">File Size</p>
-              <p className="text-sm text-white font-medium">
-                {formatFileSize(candidate.fileSize)}
-              </p>
-            </div>
-            <div>
-              <p className="text-xs text-slate-400">Play Count</p>
-              <p className="text-sm text-white font-medium">{candidate.playCount}</p>
-            </div>
-            <div>
-              <p className="text-xs text-slate-400">Last Watched</p>
-              <p className="text-sm text-white font-medium">
-                {formatDate(candidate.lastWatchedAt)}
-              </p>
-            </div>
-            <div>
-              <p className="text-xs text-slate-400">Added</p>
-              <p className="text-sm text-white font-medium">
-                {formatDate(candidate.addedAt)}
-              </p>
-            </div>
-          </div>
-
-          {/* File Path */}
-          {candidate.filePath && (
-            <div className="mb-3">
-              <p className="text-xs text-slate-400 mb-1">File Path</p>
-              <p className="text-xs text-slate-300 font-mono bg-slate-900/50 p-2 rounded truncate">
-                {candidate.filePath}
-              </p>
-            </div>
-          )}
-
-          {/* Action Buttons */}
-          <div className="flex gap-2 mt-4">
-            <Button
-              variant="danger"
-              onClick={() => onApprove(candidate.id)}
-              className="flex-1"
-              data-testid="maintenance-candidate-approve"
-            >
-              <Check className="w-4 h-4" />
-              Approve for Deletion
-            </Button>
-            <Button
-              variant="secondary"
-              onClick={() => onReject(candidate.id)}
-              className="flex-1"
-              data-testid="maintenance-candidate-reject"
-            >
-              <X className="w-4 h-4" />
-              Reject
-            </Button>
-          </div>
-        </div>
-      </div>
-    </div>
-  )
-}
diff --git a/components/maintenance/condition-builder.tsx b/components/maintenance/condition-builder.tsx
deleted file mode 100644
index 0d522c79..00000000
--- a/components/maintenance/condition-builder.tsx
+++ /dev/null
@@ -1,145 +0,0 @@
-"use client"
-
-/**
- * Single Condition Builder
- *
- * UI for building a single field comparison (leaf node in the rule tree).
- */
-
-import type { Condition, MediaType } from "@/lib/validations/maintenance"
-import type { FieldDefinition } from "@/lib/maintenance/field-registry"
-import { formatOperatorLabel, getFieldsByDataSource } from "@/lib/maintenance/field-registry"
-import { ConditionValueInput } from "./condition-value-input"
-import { StyledDropdown } from "@/components/ui/styled-dropdown"
-import type { DropdownOptGroup } from "@/components/ui/styled-dropdown"
-import { useMemo } from "react"
-
-interface ConditionBuilderProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-  onRemove: () => void
-  availableFields: FieldDefinition[]
-  mediaType: MediaType
-}
-
-export function ConditionBuilder({
-  condition,
-  onChange,
-  onRemove,
-  availableFields,
-  mediaType,
-}: ConditionBuilderProps) {
-  const fieldDef = useMemo(
-    () => availableFields.find(f => f.key === condition.field),
-    [availableFields, condition.field]
-  )
-
-  const fieldsByDataSource = useMemo(
-    () => getFieldsByDataSource(mediaType),
-    [mediaType]
-  )
-
-  const fieldOptgroups: DropdownOptGroup[] = useMemo(() => {
-    const sourceLabels: Record<string, string> = {
-      plex: 'Plex',
-      tautulli: 'Tautulli',
-      radarr: 'Radarr',
-      sonarr: 'Sonarr',
-    }
-
-    return Object.entries(fieldsByDataSource)
-      .filter(([_, fields]) => fields.length > 0)
-      .map(([dataSource, fields]) => ({
-        label: sourceLabels[dataSource] || dataSource,
-        options: fields.map(f => ({
-          value: f.key,
-          label: f.description ? `${f.label} - ${f.description}` : f.label,
-        })),
-      }))
-  }, [fieldsByDataSource])
-
-  const operatorOptions = useMemo(() => {
-    if (!fieldDef) return []
-    return fieldDef.allowedOperators.map(op => ({
-      value: op,
-      label: formatOperatorLabel(op),
-    }))
-  }, [fieldDef])
-
-  if (!fieldDef) {
-    return (
-      <div className="p-3 bg-red-500/10 border border-red-500/30 rounded text-red-400 text-sm">
-        Unknown field: {condition.field}
-      </div>
-    )
-  }
-
-  const handleFieldChange = (newFieldKey: string) => {
-    const newFieldDef = availableFields.find(f => f.key === newFieldKey)
-    if (!newFieldDef) return
-
-    onChange({
-      ...condition,
-      field: newFieldKey,
-      operator: newFieldDef.allowedOperators[0],
-      value: null,
-      valueUnit: undefined,
-    })
-  }
-
-  const handleOperatorChange = (newOperator: string) => {
-    onChange({
-      ...condition,
-      operator: newOperator,
-      value: null,
-    })
-  }
-
-  return (
-    <div className="p-4 bg-slate-800/50 border border-slate-700 rounded-lg hover:border-slate-600 transition-colors space-y-3">
-      {/* Row 1: Field selector with remove button */}
-      <div className="flex items-center gap-3">
-        <div className="flex-1">
-          <label className="block text-xs text-slate-500 mb-1.5">Field</label>
-          <StyledDropdown
-            value={condition.field}
-            onChange={handleFieldChange}
-            optgroups={fieldOptgroups}
-            size="md"
-          />
-        </div>
-        <button
-          type="button"
-          onClick={onRemove}
-          className="text-red-400 hover:text-red-300 p-2 rounded hover:bg-red-400/10 transition-colors flex-shrink-0 mt-5"
-          title="Remove condition"
-        >
-          <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
-          </svg>
-        </button>
-      </div>
-
-      {/* Row 2: Operator and Value */}
-      <div className="flex items-end gap-3">
-        <div className="w-[180px] flex-shrink-0">
-          <label className="block text-xs text-slate-500 mb-1.5">Operator</label>
-          <StyledDropdown
-            value={condition.operator}
-            onChange={handleOperatorChange}
-            options={operatorOptions}
-            size="md"
-          />
-        </div>
-        <div className="flex-1">
-          <label className="block text-xs text-slate-500 mb-1.5">Value</label>
-          <ConditionValueInput
-            fieldDef={fieldDef}
-            condition={condition}
-            onChange={onChange}
-          />
-        </div>
-      </div>
-    </div>
-  )
-}
diff --git a/components/maintenance/condition-group-builder.tsx b/components/maintenance/condition-group-builder.tsx
deleted file mode 100644
index e4eaa837..00000000
--- a/components/maintenance/condition-group-builder.tsx
+++ /dev/null
@@ -1,299 +0,0 @@
-"use client"
-
-/**
- * Recursive Condition Group Builder
- *
- * A React component for building nested condition groups with AND/OR logic.
- * This component renders a tree structure of conditions and groups, allowing
- * users to create complex filter rules through an intuitive UI.
- *
- * ## Recursion Model
- *
- * The component uses self-referential recursion to handle nested groups:
- * - Root group (depth=0): Primary container with cyan styling
- * - Nested groups (depth>0): Rendered as children with purple styling
- * - Each group can contain conditions OR other groups (not both types are required)
- *
- * ## Depth Handling
- *
- * While there's no hard-coded depth limit, the UI uses depth-based styling:
- * - depth=0: Cyan left border (root)
- * - depth=1: Purple left border (first-level nesting)
- * - depth>1: Slate border (deep nesting)
- *
- * ## Empty Group Behavior
- *
- * When the last condition is removed from a non-root group, the entire group
- * is automatically removed to prevent orphaned empty groups.
- *
- * @module components/maintenance/condition-group-builder
- */
-
-import type { ConditionGroup, Condition, MediaType } from "@/lib/validations/maintenance"
-import type { FieldDefinition } from "@/lib/maintenance/field-registry"
-import { generateId } from "@/lib/maintenance/field-registry"
-import { ConditionBuilder } from "./condition-builder"
-import { cn } from "@/lib/utils"
-
-/**
- * Props for the ConditionGroupBuilder component.
- */
-interface ConditionGroupBuilderProps {
-  /** The condition group data to render and edit */
-  group: ConditionGroup
-  /** Callback fired when the group structure or contents change */
-  onChange: (group: ConditionGroup) => void
-  /** Available fields that can be used in conditions (filtered by media type) */
-  availableFields: FieldDefinition[]
-  /** Current nesting depth (0 = root, used for styling and empty-group removal logic) */
-  depth: number
-  /** Media type context for field filtering (MOVIE or TV_SERIES) */
-  mediaType: MediaType
-  /** Optional callback to remove this group (not available at root level) */
-  onRemove?: () => void
-}
-
-/**
- * Recursive condition group builder supporting nested AND/OR logic.
- *
- * Renders a tree of conditions and groups with add/remove controls.
- * Each node in the tree is either a single condition (field comparison)
- * or a group containing multiple conditions/groups combined with AND/OR.
- *
- * @param props - Component props
- * @param props.group - Current condition group to render
- * @param props.onChange - Callback fired when group structure changes
- * @param props.availableFields - Fields that can be used in conditions
- * @param props.depth - Current nesting depth (0 = root, used for UI styling)
- * @param props.mediaType - Media type (MOVIE/TV_SERIES) for field filtering
- * @param props.onRemove - Optional callback to remove this group from parent
- *
- * @example
- * ```tsx
- * // Basic usage at root level
- * <ConditionGroupBuilder
- *   group={rootGroup}
- *   onChange={handleChange}
- *   availableFields={movieFields}
- *   depth={0}
- *   mediaType="MOVIE"
- * />
- *
- * // Nested usage (handled internally via recursion)
- * <ConditionGroupBuilder
- *   group={nestedGroup}
- *   onChange={(updated) => updateChild(index, updated)}
- *   onRemove={() => removeChild(index)}
- *   availableFields={movieFields}
- *   depth={1}
- *   mediaType="MOVIE"
- * />
- * ```
- */
-export function ConditionGroupBuilder({
-  group,
-  onChange,
-  availableFields,
-  depth,
-  mediaType,
-  onRemove,
-}: ConditionGroupBuilderProps) {
-  /**
-   * Adds a new condition to this group.
-   * Uses the first available field as the default, with its first allowed operator.
-   */
-  const addCondition = () => {
-    const firstField = availableFields[0]
-    onChange({
-      ...group,
-      conditions: [
-        ...group.conditions,
-        {
-          type: 'condition',
-          id: generateId(),
-          field: firstField.key,
-          operator: firstField.allowedOperators[0],
-          value: null,
-        }
-      ]
-    })
-  }
-
-  /**
-   * Adds a new nested group to this group.
-   * Creates a group with AND operator containing one default condition.
-   * This enables users to build complex nested logic like:
-   * `(A AND B) OR (C AND D)`
-   */
-  const addGroup = () => {
-    const firstField = availableFields[0]
-    onChange({
-      ...group,
-      conditions: [
-        ...group.conditions,
-        {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: firstField.key,
-              operator: firstField.allowedOperators[0],
-              value: null,
-            }
-          ]
-        }
-      ]
-    })
-  }
-
-  /**
-   * Toggles the group's logical operator between AND and OR.
-   * - AND: All conditions in this group must match
-   * - OR: At least one condition in this group must match
-   */
-  const toggleOperator = () => {
-    onChange({
-      ...group,
-      operator: group.operator === 'AND' ? 'OR' : 'AND'
-    })
-  }
-
-  /**
-   * Updates a condition or nested group at the specified index.
-   * Called when a child component reports changes to its state.
-   *
-   * @param index - Position of the child in the conditions array
-   * @param updated - New state for the condition or group
-   */
-  const updateCondition = (index: number, updated: Condition | ConditionGroup) => {
-    const newConditions = [...group.conditions]
-    newConditions[index] = updated
-    onChange({ ...group, conditions: newConditions })
-  }
-
-  /**
-   * Removes a condition or nested group at the specified index.
-   *
-   * Special behavior: If this removal would leave a non-root group empty,
-   * the entire group is removed instead (via onRemove callback) to prevent
-   * orphaned empty groups in the tree.
-   *
-   * @param index - Position of the child to remove
-   */
-  const removeCondition = (index: number) => {
-    const newConditions = group.conditions.filter((_, i) => i !== index)
-
-    // If this would leave the group empty and it's not the root, remove the group itself
-    if (newConditions.length === 0 && depth > 0 && onRemove) {
-      onRemove()
-    } else {
-      onChange({ ...group, conditions: newConditions })
-    }
-  }
-
-  /** Whether this is the root group (depth === 0) - affects styling and removal behavior */
-  const isRoot = depth === 0
-
-  /** Border color based on nesting depth for visual hierarchy */
-  const borderColor = isRoot ? 'border-cyan-500' : depth === 1 ? 'border-purple-500/50' : 'border-slate-600'
-
-  return (
-    <div
-      className={cn(
-        "border-l-2 pl-4 space-y-3",
-        borderColor,
-        depth > 0 && "mt-2"
-      )}
-    >
-      {/* Group Header */}
-      <div className="flex items-center gap-3 flex-wrap">
-        {/* AND/OR Toggle */}
-        <button
-          type="button"
-          onClick={toggleOperator}
-          className={cn(
-            "px-3 py-1.5 rounded-md text-xs font-bold transition-colors",
-            group.operator === 'AND'
-              ? "bg-cyan-600 hover:bg-cyan-700 text-white"
-              : "bg-purple-600 hover:bg-purple-700 text-white"
-          )}
-          data-testid="maintenance-rule-operator-toggle"
-        >
-          {group.operator}
-        </button>
-
-        <span className="text-xs text-slate-400">
-          {group.operator === 'AND' ? 'All conditions must match' : 'Any condition can match'}
-        </span>
-
-        {/* Remove Group Button (only for non-root groups) */}
-        {!isRoot && onRemove && (
-          <button
-            type="button"
-            onClick={onRemove}
-            className="ml-auto text-xs text-red-400 hover:text-red-300 px-2 py-1 rounded hover:bg-red-400/10 transition-colors"
-            data-testid="maintenance-rule-remove-group"
-          >
-            Remove Group
-          </button>
-        )}
-      </div>
-
-      {/* Conditions */}
-      <div className="space-y-2">
-        {group.conditions.map((node, index) => (
-          <div key={node.id}>
-            {node.type === 'condition' ? (
-              <ConditionBuilder
-                condition={node}
-                onChange={(updated) => updateCondition(index, updated)}
-                onRemove={() => removeCondition(index)}
-                availableFields={availableFields}
-                mediaType={mediaType}
-              />
-            ) : (
-              <ConditionGroupBuilder
-                group={node}
-                onChange={(updated) => updateCondition(index, updated)}
-                onRemove={() => removeCondition(index)}
-                availableFields={availableFields}
-                depth={depth + 1}
-                mediaType={mediaType}
-              />
-            )}
-          </div>
-        ))}
-      </div>
-
-      {/* Add Buttons */}
-      <div className="flex gap-2 pt-2">
-        <button
-          type="button"
-          onClick={addCondition}
-          className="text-xs text-cyan-400 hover:text-cyan-300 hover:bg-cyan-400/10 px-3 py-1.5 rounded transition-colors flex items-center gap-1"
-          data-testid="maintenance-rule-add-condition"
-        >
-          <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-          </svg>
-          Add Condition
-        </button>
-
-        <button
-          type="button"
-          onClick={addGroup}
-          className="text-xs text-purple-400 hover:text-purple-300 hover:bg-purple-400/10 px-3 py-1.5 rounded transition-colors flex items-center gap-1"
-          data-testid="maintenance-rule-add-group"
-        >
-          <svg className="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
-          </svg>
-          Add Group
-        </button>
-      </div>
-    </div>
-  )
-}
diff --git a/components/maintenance/condition-value-input.tsx b/components/maintenance/condition-value-input.tsx
deleted file mode 100644
index d11e3af2..00000000
--- a/components/maintenance/condition-value-input.tsx
+++ /dev/null
@@ -1,86 +0,0 @@
-"use client"
-
-/**
- * Type-Specific Value Input Components
- *
- * Renders appropriate input controls based on field type and operator.
- */
-
-import type { Condition } from "@/lib/validations/maintenance"
-import type { FieldDefinition } from "@/lib/maintenance/field-registry"
-import { StringInput } from "./inputs/StringInput"
-import { NumberInput } from "./inputs/NumberInput"
-import { DateInput } from "./inputs/DateInput"
-import { RelativeDateInput } from "./inputs/RelativeDateInput"
-import { DateRangeInput } from "./inputs/DateRangeInput"
-import { RangeInput } from "./inputs/RangeInput"
-import { BooleanToggle } from "./inputs/BooleanToggle"
-import { MultiTextInput } from "./inputs/MultiTextInput"
-import { SelectInput } from "./inputs/SelectInput"
-import { MultiSelectInput } from "./inputs/MultiSelectInput"
-
-interface ConditionValueInputProps {
-  fieldDef: FieldDefinition
-  condition: Condition
-  onChange: (condition: Condition) => void
-}
-
-export function ConditionValueInput({ fieldDef, condition, onChange }: ConditionValueInputProps) {
-  // No value needed for these operators
-  if (
-    condition.operator === 'null' ||
-    condition.operator === 'notNull' ||
-    condition.operator === 'isEmpty' ||
-    condition.operator === 'isNotEmpty'
-  ) {
-    return (
-      <div className="flex-1 px-3 py-2 text-sm text-slate-400 italic">
-        no value needed
-      </div>
-    )
-  }
-
-  switch (fieldDef.type) {
-    case 'string':
-      if (condition.operator === 'in' || condition.operator === 'notIn') {
-        return <MultiTextInput condition={condition} onChange={onChange} />
-      }
-      return <StringInput condition={condition} onChange={onChange} />
-
-    case 'number':
-      if (condition.operator === 'between') {
-        return <RangeInput condition={condition} onChange={onChange} unit={fieldDef.unit} min={fieldDef.min} max={fieldDef.max} />
-      }
-      return <NumberInput condition={condition} onChange={onChange} unit={fieldDef.unit} min={fieldDef.min} max={fieldDef.max} />
-
-    case 'date':
-      if (condition.operator === 'olderThan' || condition.operator === 'newerThan') {
-        return <RelativeDateInput condition={condition} onChange={onChange} />
-      }
-      if (condition.operator === 'between') {
-        return <DateRangeInput condition={condition} onChange={onChange} />
-      }
-      return <DateInput condition={condition} onChange={onChange} />
-
-    case 'boolean':
-      return <BooleanToggle condition={condition} onChange={onChange} />
-
-    case 'array':
-      if (condition.operator === 'containsAny' || condition.operator === 'containsAll') {
-        return <MultiTextInput condition={condition} onChange={onChange} />
-      }
-      return <StringInput condition={condition} onChange={onChange} placeholder="Enter value" />
-
-    case 'enum':
-      if (fieldDef.enumValues) {
-        if (condition.operator === 'in' || condition.operator === 'notIn') {
-          return <MultiSelectInput condition={condition} onChange={onChange} options={fieldDef.enumValues} />
-        }
-        return <SelectInput condition={condition} onChange={onChange} options={fieldDef.enumValues} />
-      }
-      return <StringInput condition={condition} onChange={onChange} />
-
-    default:
-      return <StringInput condition={condition} onChange={onChange} />
-  }
-}
diff --git a/components/maintenance/enhanced-rule-builder.tsx b/components/maintenance/enhanced-rule-builder.tsx
deleted file mode 100644
index 6427c040..00000000
--- a/components/maintenance/enhanced-rule-builder.tsx
+++ /dev/null
@@ -1,157 +0,0 @@
-"use client"
-
-/**
- * Enhanced Hierarchical Rule Builder
- *
- * A powerful, intuitive UI component for building complex maintenance rules
- * with nested AND/OR groups. This is the main entry point for the rule
- * building interface.
- *
- * ## Features
- *
- * - Hierarchical condition building with unlimited nesting
- * - Support for all field types from Plex, Tautulli, Radarr, and Sonarr
- * - Real-time complexity indicator showing rule metrics
- * - Context-aware field filtering based on media type
- * - Inline help text explaining the UI
- *
- * ## Architecture
- *
- * This component serves as the main container and orchestrator:
- * - Delegates condition/group rendering to {@link ConditionGroupBuilder}
- * - Calculates and displays complexity metrics
- * - Provides context-aware field definitions based on media type
- *
- * @module components/maintenance/enhanced-rule-builder
- */
-
-import type { RuleCriteria, MediaType } from "@/lib/validations/maintenance"
-import { getFieldsForMediaType, generateId } from "@/lib/maintenance/field-registry"
-import { calculateComplexity } from "@/lib/maintenance/rule-evaluator"
-import { ConditionGroupBuilder } from "./condition-group-builder"
-import { RuleComplexityIndicator } from "./rule-complexity-indicator"
-
-/**
- * Props for the EnhancedRuleBuilder component.
- */
-interface EnhancedRuleBuilderProps {
-  /** The current rule criteria being edited */
-  value: RuleCriteria
-  /** Callback fired when the criteria changes */
-  onChange: (criteria: RuleCriteria) => void
-  /** Media type context - determines available fields (MOVIE or TV_SERIES) */
-  mediaType: MediaType
-}
-
-/**
- * Main rule builder component for creating hierarchical maintenance rules.
- *
- * Provides a complete UI for building rules including:
- * - A header with title and description
- * - The main rule tree (via ConditionGroupBuilder)
- * - Complexity indicator showing rule metrics
- * - Help text explaining how to use the interface
- *
- * @param props - Component props
- * @param props.value - The current rule criteria (root condition group)
- * @param props.onChange - Called when any part of the rule changes
- * @param props.mediaType - Determines which fields are available
- *
- * @example
- * ```tsx
- * const [criteria, setCriteria] = useState(() => createDefaultCriteria("MOVIE"))
- *
- * <EnhancedRuleBuilder
- *   value={criteria}
- *   onChange={setCriteria}
- *   mediaType="MOVIE"
- * />
- * ```
- */
-export function EnhancedRuleBuilder({ value, onChange, mediaType }: EnhancedRuleBuilderProps) {
-  /** Fields available for conditions, filtered by the current media type */
-  const availableFields = getFieldsForMediaType(mediaType)
-
-  /** Complexity metrics for the current rule (condition count, depth, etc.) */
-  const complexity = calculateComplexity(value)
-
-  return (
-    <div className="space-y-6">
-      {/* Header */}
-      <div className="flex items-center justify-between">
-        <div>
-          <h3 className="text-lg font-semibold text-white">Rule Criteria</h3>
-          <p className="text-sm text-slate-400 mt-1">
-            Define conditions that media must match. Combine conditions with AND/OR groups for complex logic.
-          </p>
-        </div>
-      </div>
-
-      {/* Rule Tree */}
-      <div className="bg-slate-900/50 border border-slate-700 rounded-lg p-6">
-        <ConditionGroupBuilder
-          group={value}
-          onChange={onChange}
-          availableFields={availableFields}
-          depth={0}
-          mediaType={mediaType}
-        />
-      </div>
-
-      {/* Complexity Indicator */}
-      <RuleComplexityIndicator complexity={complexity} />
-
-      {/* Help Text */}
-      <div className="bg-slate-800/30 border border-slate-700/50 rounded-lg p-4">
-        <h4 className="text-sm font-medium text-white mb-2">How to use</h4>
-        <ul className="text-sm text-slate-400 space-y-1">
-          <li>• Click <span className="text-cyan-400 font-medium">+ Add Condition</span> to add a new field comparison</li>
-          <li>• Click <span className="text-purple-400 font-medium">+ Add Group</span> to create a nested AND/OR group</li>
-          <li>• Use the <span className="font-medium">AND/OR</span> toggle to change how conditions are combined</li>
-          <li>• <span className="font-medium">AND</span> = all conditions must match</li>
-          <li>• <span className="font-medium">OR</span> = any condition can match</li>
-        </ul>
-      </div>
-    </div>
-  )
-}
-
-/**
- * Creates a default empty rule criteria with one initial condition.
- *
- * Used when creating new rules to provide a valid starting state.
- * The initial condition uses the first available field for the given
- * media type with its first allowed operator and a null value.
- *
- * @param mediaType - The media type to create criteria for (MOVIE or TV_SERIES)
- * @returns A new RuleCriteria object with a root AND group containing one condition
- *
- * @example
- * ```tsx
- * // Create default criteria for a movie rule
- * const criteria = createDefaultCriteria("MOVIE")
- * // Returns: { type: 'group', operator: 'AND', conditions: [{ type: 'condition', ... }] }
- *
- * // Use in state initialization
- * const [criteria, setCriteria] = useState(() => createDefaultCriteria("TV_SERIES"))
- * ```
- */
-export function createDefaultCriteria(mediaType: MediaType): RuleCriteria {
-  const availableFields = getFieldsForMediaType(mediaType)
-  const firstField = availableFields[0]
-
-  return {
-    type: 'group',
-    id: generateId(),
-    operator: 'AND',
-    conditions: [
-      {
-        type: 'condition',
-        id: generateId(),
-        field: firstField.key,
-        operator: firstField.allowedOperators[0],
-        value: null,
-      }
-    ],
-  }
-}
diff --git a/components/maintenance/index.ts b/components/maintenance/index.ts
deleted file mode 100644
index ea1b6c63..00000000
--- a/components/maintenance/index.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-export { CandidateCard } from "./candidate-card"
-export { RuleCriteriaBuilder } from "./rule-criteria-builder"
-export { ScanStatusBadge } from "./scan-status-badge"
-export { StatsCard } from "./stats-card"
diff --git a/components/maintenance/inputs/BooleanToggle.tsx b/components/maintenance/inputs/BooleanToggle.tsx
deleted file mode 100644
index b3e2ab64..00000000
--- a/components/maintenance/inputs/BooleanToggle.tsx
+++ /dev/null
@@ -1,39 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-import { Button } from "@/components/ui/button"
-
-interface BooleanToggleProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-}
-
-export function BooleanToggle({
-  condition,
-  onChange,
-}: BooleanToggleProps) {
-  const value = condition.value as boolean
-
-  return (
-    <div className="flex-1 flex items-center gap-3">
-      <Button
-        type="button"
-        onClick={() => onChange({ ...condition, value: true })}
-        variant={value === true ? "success" : "secondary"}
-        size="md"
-        data-testid="boolean-toggle-true"
-      >
-        True
-      </Button>
-      <Button
-        type="button"
-        onClick={() => onChange({ ...condition, value: false })}
-        variant={value === false ? "danger" : "secondary"}
-        size="md"
-        data-testid="boolean-toggle-false"
-      >
-        False
-      </Button>
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/DateInput.tsx b/components/maintenance/inputs/DateInput.tsx
deleted file mode 100644
index a7ef6fa7..00000000
--- a/components/maintenance/inputs/DateInput.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface DateInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-}
-
-export function DateInput({
-  condition,
-  onChange,
-}: DateInputProps) {
-  return (
-    <input
-      type="date"
-      value={(condition.value as string) || ''}
-      onChange={(e) => onChange({ ...condition, value: e.target.value })}
-      className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-    />
-  )
-}
diff --git a/components/maintenance/inputs/DateRangeInput.tsx b/components/maintenance/inputs/DateRangeInput.tsx
deleted file mode 100644
index f632e641..00000000
--- a/components/maintenance/inputs/DateRangeInput.tsx
+++ /dev/null
@@ -1,34 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface DateRangeInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-}
-
-export function DateRangeInput({
-  condition,
-  onChange,
-}: DateRangeInputProps) {
-  const values = (condition.value as string[]) || ['', '']
-  const [start, end] = values
-
-  return (
-    <div className="flex-1 flex items-center gap-2">
-      <input
-        type="date"
-        value={start}
-        onChange={(e) => onChange({ ...condition, value: [e.target.value, end] })}
-        className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-      />
-      <span className="text-slate-400">to</span>
-      <input
-        type="date"
-        value={end}
-        onChange={(e) => onChange({ ...condition, value: [start, e.target.value] })}
-        className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-      />
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/MultiSelectInput.tsx b/components/maintenance/inputs/MultiSelectInput.tsx
deleted file mode 100644
index 68b954a4..00000000
--- a/components/maintenance/inputs/MultiSelectInput.tsx
+++ /dev/null
@@ -1,46 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface MultiSelectInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-  options: Array<{ value: string; label: string }>
-}
-
-export function MultiSelectInput({
-  condition,
-  onChange,
-  options,
-}: MultiSelectInputProps) {
-  const values = (condition.value as string[]) || []
-
-  const toggleValue = (optValue: string) => {
-    if (values.includes(optValue)) {
-      onChange({ ...condition, value: values.filter(v => v !== optValue) })
-    } else {
-      onChange({ ...condition, value: [...values, optValue] })
-    }
-  }
-
-  return (
-    <div className="flex-1 space-y-2">
-      <div className="grid grid-cols-2 gap-2">
-        {options.map(opt => (
-          <label
-            key={opt.value}
-            className="flex items-center gap-2 px-3 py-2 bg-slate-900 border border-slate-600 rounded cursor-pointer hover:border-slate-500 transition-colors"
-          >
-            <input
-              type="checkbox"
-              checked={values.includes(opt.value)}
-              onChange={() => toggleValue(opt.value)}
-              className="rounded border-slate-600 text-cyan-600 focus:ring-cyan-500"
-            />
-            <span className="text-sm text-white">{opt.label}</span>
-          </label>
-        ))}
-      </div>
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/MultiTextInput.tsx b/components/maintenance/inputs/MultiTextInput.tsx
deleted file mode 100644
index 806d0130..00000000
--- a/components/maintenance/inputs/MultiTextInput.tsx
+++ /dev/null
@@ -1,69 +0,0 @@
-"use client"
-
-import { useState } from "react"
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface MultiTextInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-}
-
-export function MultiTextInput({
-  condition,
-  onChange,
-}: MultiTextInputProps) {
-  const [input, setInput] = useState('')
-  const values = (condition.value as string[]) || []
-
-  const addValue = () => {
-    if (input.trim()) {
-      onChange({ ...condition, value: [...values, input.trim()] })
-      setInput('')
-    }
-  }
-
-  const removeValue = (index: number) => {
-    onChange({ ...condition, value: values.filter((_, i) => i !== index) })
-  }
-
-  return (
-    <div className="flex-1 space-y-2">
-      <div className="flex gap-2">
-        <input
-          type="text"
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          onKeyDown={(e) => e.key === 'Enter' && (e.preventDefault(), addValue())}
-          placeholder="Type and press Enter"
-          className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-        />
-        <button
-          type="button"
-          onClick={addValue}
-          className="px-3 py-2 bg-cyan-600 hover:bg-cyan-700 text-white rounded text-sm transition-colors"
-        >
-          Add
-        </button>
-      </div>
-      {values.length > 0 && (
-        <div className="flex flex-wrap gap-2">
-          {values.map((value, index) => (
-            <span
-              key={index}
-              className="inline-flex items-center gap-1 px-2 py-1 bg-slate-700 rounded text-xs text-white"
-            >
-              {value}
-              <button
-                type="button"
-                onClick={() => removeValue(index)}
-                className="hover:text-red-400"
-              >
-                ×
-              </button>
-            </span>
-          ))}
-        </div>
-      )}
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/NumberInput.tsx b/components/maintenance/inputs/NumberInput.tsx
deleted file mode 100644
index 46bb62b3..00000000
--- a/components/maintenance/inputs/NumberInput.tsx
+++ /dev/null
@@ -1,76 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface NumberInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-  unit?: string
-  min?: number
-  max?: number
-}
-
-export function NumberInput({
-  condition,
-  onChange,
-  unit,
-  min,
-  max,
-}: NumberInputProps) {
-  const getPlaceholder = () => {
-    if (unit === 'bytes') return 'Size in GB (e.g., 10)'
-    if (unit === 'minutes') return 'Duration in minutes'
-    if (unit === 'kbps') return 'Bitrate in Mbps'
-    return 'Enter number'
-  }
-
-  const handleChange = (value: string) => {
-    const num = parseFloat(value)
-    if (isNaN(num)) {
-      onChange({ ...condition, value: null })
-      return
-    }
-
-    // Convert display units to storage units
-    let finalValue = num
-    if (unit === 'bytes') {
-      finalValue = num * 1024 * 1024 * 1024 // GB to bytes
-    } else if (unit === 'kbps') {
-      finalValue = num * 1000 // Mbps to kbps
-    }
-
-    onChange({ ...condition, value: finalValue })
-  }
-
-  const getDisplayValue = () => {
-    const val = condition.value as number
-    if (!val) return ''
-
-    if (unit === 'bytes') {
-      return (val / (1024 * 1024 * 1024)).toString()
-    } else if (unit === 'kbps') {
-      return (val / 1000).toString()
-    }
-    return val.toString()
-  }
-
-  return (
-    <div className="flex-1 flex items-center gap-2">
-      <input
-        type="number"
-        value={getDisplayValue()}
-        onChange={(e) => handleChange(e.target.value)}
-        placeholder={getPlaceholder()}
-        className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-        step="any"
-        min={min}
-        max={max}
-      />
-      {unit && (
-        <span className="text-xs text-slate-400">
-          {unit === 'bytes' ? 'GB' : unit === 'kbps' ? 'Mbps' : unit === 'minutes' ? 'min' : ''}
-        </span>
-      )}
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/RangeInput.tsx b/components/maintenance/inputs/RangeInput.tsx
deleted file mode 100644
index 366d7a6f..00000000
--- a/components/maintenance/inputs/RangeInput.tsx
+++ /dev/null
@@ -1,81 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface RangeInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-  unit?: string
-  min?: number
-  max?: number
-}
-
-export function RangeInput({
-  condition,
-  onChange,
-  unit,
-  min: minLimit,
-  max: maxLimit,
-}: RangeInputProps) {
-  const values = (condition.value as number[]) || [0, 0]
-  const [min, max] = values
-
-  const convertToStorage = (displayValue: number): number => {
-    if (unit === 'bytes') {
-      return displayValue * 1024 * 1024 * 1024 // GB to bytes
-    } else if (unit === 'kbps') {
-      return displayValue * 1000 // Mbps to kbps
-    }
-    return displayValue
-  }
-
-  const convertToDisplay = (storageValue: number): number => {
-    if (unit === 'bytes') {
-      return storageValue / (1024 * 1024 * 1024) // bytes to GB
-    } else if (unit === 'kbps') {
-      return storageValue / 1000 // kbps to Mbps
-    }
-    return storageValue
-  }
-
-  const handleMinChange = (value: string) => {
-    const num = parseFloat(value) || 0
-    onChange({ ...condition, value: [convertToStorage(num), max] })
-  }
-
-  const handleMaxChange = (value: string) => {
-    const num = parseFloat(value) || 0
-    onChange({ ...condition, value: [min, convertToStorage(num)] })
-  }
-
-  return (
-    <div className="flex-1 flex items-center gap-2">
-      <input
-        type="number"
-        value={convertToDisplay(min)}
-        onChange={(e) => handleMinChange(e.target.value)}
-        placeholder="Min"
-        className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-        step="any"
-        min={minLimit}
-        max={maxLimit}
-      />
-      <span className="text-slate-400">to</span>
-      <input
-        type="number"
-        value={convertToDisplay(max)}
-        onChange={(e) => handleMaxChange(e.target.value)}
-        placeholder="Max"
-        className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-        step="any"
-        min={minLimit}
-        max={maxLimit}
-      />
-      {unit && (
-        <span className="text-xs text-slate-400">
-          {unit === 'bytes' ? 'GB' : unit === 'kbps' ? 'Mbps' : unit === 'minutes' ? 'min' : ''}
-        </span>
-      )}
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/RelativeDateInput.tsx b/components/maintenance/inputs/RelativeDateInput.tsx
deleted file mode 100644
index 62b8b544..00000000
--- a/components/maintenance/inputs/RelativeDateInput.tsx
+++ /dev/null
@@ -1,42 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-import { StyledDropdown } from "@/components/ui/styled-dropdown"
-
-interface RelativeDateInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-}
-
-export function RelativeDateInput({
-  condition,
-  onChange,
-}: RelativeDateInputProps) {
-  const value = (condition.value as number) || 0
-  const unit = condition.valueUnit || 'days'
-
-  return (
-    <div className="flex-1 flex items-center gap-2">
-      <input
-        type="number"
-        value={value}
-        onChange={(e) => onChange({ ...condition, value: parseInt(e.target.value) || 0 })}
-        placeholder="Enter number"
-        className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-        min="1"
-      />
-      <StyledDropdown
-        value={unit}
-        onChange={(value) => onChange({ ...condition, valueUnit: value as any })}
-        options={[
-          { value: 'days', label: 'days' },
-          { value: 'months', label: 'months' },
-          { value: 'years', label: 'years' },
-        ]}
-        size="md"
-        className="w-28"
-      />
-      <span className="text-xs text-slate-400">ago</span>
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/SelectInput.tsx b/components/maintenance/inputs/SelectInput.tsx
deleted file mode 100644
index 6a4ebf8d..00000000
--- a/components/maintenance/inputs/SelectInput.tsx
+++ /dev/null
@@ -1,28 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-import { StyledDropdown } from "@/components/ui/styled-dropdown"
-
-interface SelectInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-  options: Array<{ value: string; label: string }>
-}
-
-export function SelectInput({
-  condition,
-  onChange,
-  options,
-}: SelectInputProps) {
-  return (
-    <div className="flex-1">
-      <StyledDropdown
-        value={(condition.value as string) || ''}
-        onChange={(value) => onChange({ ...condition, value })}
-        options={options}
-        placeholder="Select..."
-        size="md"
-      />
-    </div>
-  )
-}
diff --git a/components/maintenance/inputs/StringInput.tsx b/components/maintenance/inputs/StringInput.tsx
deleted file mode 100644
index 615e8320..00000000
--- a/components/maintenance/inputs/StringInput.tsx
+++ /dev/null
@@ -1,25 +0,0 @@
-"use client"
-
-import type { Condition } from "@/lib/validations/maintenance"
-
-interface StringInputProps {
-  condition: Condition
-  onChange: (condition: Condition) => void
-  placeholder?: string
-}
-
-export function StringInput({
-  condition,
-  onChange,
-  placeholder = "Enter value",
-}: StringInputProps) {
-  return (
-    <input
-      type="text"
-      value={(condition.value as string) || ''}
-      onChange={(e) => onChange({ ...condition, value: e.target.value })}
-      placeholder={placeholder}
-      className="flex-1 bg-slate-900 border border-slate-600 rounded px-3 py-2 text-sm text-white focus:outline-none focus:ring-2 focus:ring-cyan-500"
-    />
-  )
-}
diff --git a/components/maintenance/inputs/__tests__/BooleanToggle.test.tsx b/components/maintenance/inputs/__tests__/BooleanToggle.test.tsx
deleted file mode 100644
index f45592d8..00000000
--- a/components/maintenance/inputs/__tests__/BooleanToggle.test.tsx
+++ /dev/null
@@ -1,266 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { BooleanToggle } from '../BooleanToggle'
-import type { Condition } from '@/lib/validations/maintenance'
-
-// Mock Button component
-jest.mock('@/components/ui/button', () => ({
-  Button: ({
-    children,
-    onClick,
-    variant,
-    'data-testid': dataTestId,
-  }: {
-    children: React.ReactNode
-    onClick: () => void
-    variant?: string
-    'data-testid'?: string
-  }) => (
-    <button onClick={onClick} data-variant={variant} data-testid={dataTestId}>
-      {children}
-    </button>
-  ),
-}))
-
-describe('BooleanToggle', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: boolean | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'neverWatched',
-    operator: 'equals',
-    value,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render True and False buttons', () => {
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByTestId('boolean-toggle-true')).toBeInTheDocument()
-      expect(screen.getByTestId('boolean-toggle-false')).toBeInTheDocument()
-      expect(screen.getByText('True')).toBeInTheDocument()
-      expect(screen.getByText('False')).toBeInTheDocument()
-    })
-
-    it('should have type="button" on buttons', () => {
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      // The mock doesn't set type, but we can verify buttons render
-      expect(screen.getByTestId('boolean-toggle-true')).toBeInTheDocument()
-      expect(screen.getByTestId('boolean-toggle-false')).toBeInTheDocument()
-    })
-  })
-
-  describe('Value Display', () => {
-    it('should show success variant for True button when value is true', () => {
-      const condition = createCondition(true)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      const trueButton = screen.getByTestId('boolean-toggle-true')
-      expect(trueButton).toHaveAttribute('data-variant', 'success')
-    })
-
-    it('should show secondary variant for False button when value is true', () => {
-      const condition = createCondition(true)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      const falseButton = screen.getByTestId('boolean-toggle-false')
-      expect(falseButton).toHaveAttribute('data-variant', 'secondary')
-    })
-
-    it('should show danger variant for False button when value is false', () => {
-      const condition = createCondition(false)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      const falseButton = screen.getByTestId('boolean-toggle-false')
-      expect(falseButton).toHaveAttribute('data-variant', 'danger')
-    })
-
-    it('should show secondary variant for True button when value is false', () => {
-      const condition = createCondition(false)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      const trueButton = screen.getByTestId('boolean-toggle-true')
-      expect(trueButton).toHaveAttribute('data-variant', 'secondary')
-    })
-
-    it('should show secondary variant for both buttons when value is null', () => {
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      const trueButton = screen.getByTestId('boolean-toggle-true')
-      const falseButton = screen.getByTestId('boolean-toggle-false')
-
-      expect(trueButton).toHaveAttribute('data-variant', 'secondary')
-      expect(falseButton).toHaveAttribute('data-variant', 'secondary')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange with true when True button is clicked', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-true'))
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: true,
-        })
-      )
-    })
-
-    it('should call onChange with false when False button is clicked', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-false'))
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: false,
-        })
-      )
-    })
-
-    it('should preserve condition field and operator when clicking True', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-true'))
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'neverWatched',
-        operator: 'equals',
-        value: true,
-      })
-    })
-
-    it('should preserve condition field and operator when clicking False', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-false'))
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'neverWatched',
-        operator: 'equals',
-        value: false,
-      })
-    })
-
-    it('should allow toggling from true to false', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(true)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-false'))
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: false,
-        })
-      )
-    })
-
-    it('should allow toggling from false to true', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(false)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-true'))
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: true,
-        })
-      )
-    })
-
-    it('should call onChange even when clicking already selected value', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(true)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByTestId('boolean-toggle-true'))
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: true,
-        })
-      )
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle undefined value like null', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'neverWatched',
-        operator: 'equals',
-        value: null,
-      }
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      const trueButton = screen.getByTestId('boolean-toggle-true')
-      const falseButton = screen.getByTestId('boolean-toggle-false')
-
-      // Both should be secondary when value is null/undefined
-      expect(trueButton).toHaveAttribute('data-variant', 'secondary')
-      expect(falseButton).toHaveAttribute('data-variant', 'secondary')
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have data-testid attributes for testing', () => {
-      const condition = createCondition(null)
-
-      render(<BooleanToggle condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByTestId('boolean-toggle-true')).toBeInTheDocument()
-      expect(screen.getByTestId('boolean-toggle-false')).toBeInTheDocument()
-    })
-
-    it('should render buttons in a flex container', () => {
-      const condition = createCondition(null)
-
-      const { container } = render(
-        <BooleanToggle condition={condition} onChange={mockOnChange} />
-      )
-
-      const wrapper = container.firstChild
-      expect(wrapper).toHaveClass('flex-1', 'flex')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/DateInput.test.tsx b/components/maintenance/inputs/__tests__/DateInput.test.tsx
deleted file mode 100644
index 67e5aeba..00000000
--- a/components/maintenance/inputs/__tests__/DateInput.test.tsx
+++ /dev/null
@@ -1,154 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import { fireEvent } from '@testing-library/react'
-import { DateInput } from '../DateInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('DateInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: string | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'addedAt',
-    operator: 'before',
-    value,
-  })
-
-  const getDateInput = (container: HTMLElement) => {
-    return container.querySelector('input[type="date"]') as HTMLInputElement
-  }
-
-  describe('Basic Rendering', () => {
-    it('should render date input', () => {
-      const condition = createCondition(null)
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toBeInTheDocument()
-      expect(input).toHaveAttribute('type', 'date')
-    })
-
-    it('should display current value', () => {
-      const condition = createCondition('2024-01-15')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveValue('2024-01-15')
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should handle null value as empty string', () => {
-      const condition = createCondition(null)
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveValue('')
-    })
-
-    it('should handle empty string value', () => {
-      const condition = createCondition('')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveValue('')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange when value changes', () => {
-      const condition = createCondition('')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      fireEvent.change(input, { target: { value: '2024-06-15' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: '2024-06-15',
-        })
-      )
-    })
-
-    it('should preserve condition field and operator when changing value', () => {
-      const condition = createCondition('')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      fireEvent.change(input, { target: { value: '2024-06-15' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'addedAt',
-        operator: 'before',
-        value: '2024-06-15',
-      })
-    })
-
-    it('should handle clearing the input', () => {
-      const condition = createCondition('2024-01-15')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      fireEvent.change(input, { target: { value: '' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: '',
-        })
-      )
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle different date formats in display', () => {
-      const condition = createCondition('2023-12-31')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveValue('2023-12-31')
-    })
-
-    it('should handle first day of year', () => {
-      const condition = createCondition('2024-01-01')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveValue('2024-01-01')
-    })
-
-    it('should handle last day of year', () => {
-      const condition = createCondition('2024-12-31')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveValue('2024-12-31')
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have proper input styling classes', () => {
-      const condition = createCondition('')
-
-      const { container } = render(<DateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = getDateInput(container)
-      expect(input).toHaveClass('flex-1')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/DateRangeInput.test.tsx b/components/maintenance/inputs/__tests__/DateRangeInput.test.tsx
deleted file mode 100644
index ae5b8ccd..00000000
--- a/components/maintenance/inputs/__tests__/DateRangeInput.test.tsx
+++ /dev/null
@@ -1,254 +0,0 @@
-import { render, screen, fireEvent } from '@testing-library/react'
-import { DateRangeInput } from '../DateRangeInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('DateRangeInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: string[] | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'addedAt',
-    operator: 'between',
-    value,
-  })
-
-  const getDateInputs = (container: HTMLElement) => {
-    return container.querySelectorAll('input[type="date"]') as NodeListOf<HTMLInputElement>
-  }
-
-  describe('Basic Rendering', () => {
-    it('should render two date inputs', () => {
-      const condition = createCondition(['', ''])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs).toHaveLength(2)
-      expect(inputs[0]).toHaveAttribute('type', 'date')
-      expect(inputs[1]).toHaveAttribute('type', 'date')
-    })
-
-    it('should render "to" separator between inputs', () => {
-      const condition = createCondition(['', ''])
-
-      render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('to')).toBeInTheDocument()
-    })
-
-    it('should display current start and end values', () => {
-      const condition = createCondition(['2024-01-01', '2024-12-31'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('2024-01-01')
-      expect(inputs[1]).toHaveValue('2024-12-31')
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should handle null value as empty strings', () => {
-      const condition = createCondition(null)
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('')
-      expect(inputs[1]).toHaveValue('')
-    })
-
-    it('should handle partial values', () => {
-      const condition = createCondition(['2024-01-01', ''])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('2024-01-01')
-      expect(inputs[1]).toHaveValue('')
-    })
-
-    it('should handle only end date provided', () => {
-      const condition = createCondition(['', '2024-12-31'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('')
-      expect(inputs[1]).toHaveValue('2024-12-31')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange when start date changes', () => {
-      const condition = createCondition(['', '2024-12-31'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[0], { target: { value: '2024-01-01' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['2024-01-01', '2024-12-31'],
-        })
-      )
-    })
-
-    it('should call onChange when end date changes', () => {
-      const condition = createCondition(['2024-01-01', ''])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[1], { target: { value: '2024-12-31' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['2024-01-01', '2024-12-31'],
-        })
-      )
-    })
-
-    it('should preserve end date when changing start date', () => {
-      const condition = createCondition(['', '2024-12-31'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[0], { target: { value: '2024-01-01' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['2024-01-01', '2024-12-31'],
-        })
-      )
-    })
-
-    it('should preserve start date when changing end date', () => {
-      const condition = createCondition(['2024-01-01', ''])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[1], { target: { value: '2024-12-31' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['2024-01-01', '2024-12-31'],
-        })
-      )
-    })
-
-    it('should preserve condition field and operator when changing dates', () => {
-      const condition = createCondition(['', ''])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[0], { target: { value: '2024-01-01' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'addedAt',
-        operator: 'between',
-        value: ['2024-01-01', ''],
-      })
-    })
-
-    it('should handle clearing start date', () => {
-      const condition = createCondition(['2024-01-01', '2024-12-31'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[0], { target: { value: '' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['', '2024-12-31'],
-        })
-      )
-    })
-
-    it('should handle clearing end date', () => {
-      const condition = createCondition(['2024-01-01', '2024-12-31'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      fireEvent.change(inputs[1], { target: { value: '' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['2024-01-01', ''],
-        })
-      )
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle same start and end date', () => {
-      const condition = createCondition(['2024-06-15', '2024-06-15'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('2024-06-15')
-      expect(inputs[1]).toHaveValue('2024-06-15')
-    })
-
-    it('should handle year boundaries', () => {
-      const condition = createCondition(['2023-12-31', '2024-01-01'])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('2023-12-31')
-      expect(inputs[1]).toHaveValue('2024-01-01')
-    })
-
-    it('should handle empty array as initial value', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'addedAt',
-        operator: 'between',
-        value: [],
-      }
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveValue('')
-      expect(inputs[1]).toHaveValue('')
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have proper input styling classes', () => {
-      const condition = createCondition(['', ''])
-
-      const { container } = render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = getDateInputs(container)
-      expect(inputs[0]).toHaveClass('flex-1')
-      expect(inputs[1]).toHaveClass('flex-1')
-    })
-
-    it('should display "to" separator with proper styling', () => {
-      const condition = createCondition(['', ''])
-
-      render(<DateRangeInput condition={condition} onChange={mockOnChange} />)
-
-      const separator = screen.getByText('to')
-      expect(separator).toHaveClass('text-slate-400')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/MultiSelectInput.test.tsx b/components/maintenance/inputs/__tests__/MultiSelectInput.test.tsx
deleted file mode 100644
index 9f46cf26..00000000
--- a/components/maintenance/inputs/__tests__/MultiSelectInput.test.tsx
+++ /dev/null
@@ -1,500 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { MultiSelectInput } from '../MultiSelectInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('MultiSelectInput', () => {
-  const mockOnChange = jest.fn()
-
-  const defaultOptions = [
-    { value: 'action', label: 'Action' },
-    { value: 'comedy', label: 'Comedy' },
-    { value: 'drama', label: 'Drama' },
-    { value: 'horror', label: 'Horror' },
-  ]
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: string[] | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'genres',
-    operator: 'containsAny',
-    value,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render all options as checkboxes', () => {
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const checkboxes = screen.getAllByRole('checkbox')
-      expect(checkboxes).toHaveLength(4)
-    })
-
-    it('should display option labels', () => {
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      expect(screen.getByText('Action')).toBeInTheDocument()
-      expect(screen.getByText('Comedy')).toBeInTheDocument()
-      expect(screen.getByText('Drama')).toBeInTheDocument()
-      expect(screen.getByText('Horror')).toBeInTheDocument()
-    })
-
-    it('should render checkboxes in a 2-column grid', () => {
-      const condition = createCondition([])
-
-      const { container } = render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const grid = container.querySelector('.grid-cols-2')
-      expect(grid).toBeInTheDocument()
-    })
-  })
-
-  describe('Value Display', () => {
-    it('should check boxes for selected values', () => {
-      const condition = createCondition(['action', 'drama'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const checkboxes = screen.getAllByRole('checkbox')
-      expect(checkboxes[0]).toBeChecked() // action
-      expect(checkboxes[1]).not.toBeChecked() // comedy
-      expect(checkboxes[2]).toBeChecked() // drama
-      expect(checkboxes[3]).not.toBeChecked() // horror
-    })
-
-    it('should handle empty array', () => {
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const checkboxes = screen.getAllByRole('checkbox')
-      checkboxes.forEach((checkbox) => {
-        expect(checkbox).not.toBeChecked()
-      })
-    })
-
-    it('should handle null value as empty array', () => {
-      const condition = createCondition(null)
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const checkboxes = screen.getAllByRole('checkbox')
-      checkboxes.forEach((checkbox) => {
-        expect(checkbox).not.toBeChecked()
-      })
-    })
-
-    it('should handle all values selected', () => {
-      const condition = createCondition(['action', 'comedy', 'drama', 'horror'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const checkboxes = screen.getAllByRole('checkbox')
-      checkboxes.forEach((checkbox) => {
-        expect(checkbox).toBeChecked()
-      })
-    })
-  })
-
-  describe('User Interactions - Selecting', () => {
-    it('should add value when unchecked option is clicked', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const actionCheckbox = screen.getAllByRole('checkbox')[0]
-      await user.click(actionCheckbox)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['action'],
-        })
-      )
-    })
-
-    it('should append value to existing selections', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['action'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const comedyCheckbox = screen.getAllByRole('checkbox')[1]
-      await user.click(comedyCheckbox)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['action', 'comedy'],
-        })
-      )
-    })
-
-    it('should allow selecting multiple values', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['action', 'comedy'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const dramaCheckbox = screen.getAllByRole('checkbox')[2]
-      await user.click(dramaCheckbox)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['action', 'comedy', 'drama'],
-        })
-      )
-    })
-  })
-
-  describe('User Interactions - Deselecting', () => {
-    it('should remove value when checked option is clicked', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['action', 'comedy'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const actionCheckbox = screen.getAllByRole('checkbox')[0]
-      await user.click(actionCheckbox)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['comedy'],
-        })
-      )
-    })
-
-    it('should handle removing the only selected value', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['action'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const actionCheckbox = screen.getAllByRole('checkbox')[0]
-      await user.click(actionCheckbox)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [],
-        })
-      )
-    })
-
-    it('should handle removing from middle of selected values', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['action', 'comedy', 'drama'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const comedyCheckbox = screen.getAllByRole('checkbox')[1]
-      await user.click(comedyCheckbox)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['action', 'drama'],
-        })
-      )
-    })
-  })
-
-  describe('Preserving Condition Properties', () => {
-    it('should preserve condition field and operator when selecting', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      await user.click(screen.getAllByRole('checkbox')[0])
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'genres',
-        operator: 'containsAny',
-        value: ['action'],
-      })
-    })
-
-    it('should preserve condition field and operator when deselecting', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['action'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      await user.click(screen.getAllByRole('checkbox')[0])
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'genres',
-        operator: 'containsAny',
-        value: [],
-      })
-    })
-  })
-
-  describe('Different Option Sets', () => {
-    it('should work with resolution options', () => {
-      const resolutionOptions = [
-        { value: '4k', label: '4K UHD' },
-        { value: '1080p', label: 'Full HD' },
-        { value: '720p', label: 'HD' },
-        { value: '480p', label: 'SD' },
-      ]
-      const condition = createCondition(['4k', '1080p'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={resolutionOptions}
-        />
-      )
-
-      expect(screen.getByText('4K UHD')).toBeInTheDocument()
-      expect(screen.getByText('Full HD')).toBeInTheDocument()
-
-      const checkboxes = screen.getAllByRole('checkbox')
-      expect(checkboxes[0]).toBeChecked() // 4k
-      expect(checkboxes[1]).toBeChecked() // 1080p
-      expect(checkboxes[2]).not.toBeChecked() // 720p
-    })
-
-    it('should work with single option', () => {
-      const singleOption = [{ value: 'only', label: 'Only Option' }]
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={singleOption}
-        />
-      )
-
-      expect(screen.getByText('Only Option')).toBeInTheDocument()
-      expect(screen.getAllByRole('checkbox')).toHaveLength(1)
-    })
-
-    it('should work with many options', () => {
-      const manyOptions = Array.from({ length: 10 }, (_, i) => ({
-        value: `option${i + 1}`,
-        label: `Option ${i + 1}`,
-      }))
-      const condition = createCondition(['option1', 'option5', 'option10'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={manyOptions}
-        />
-      )
-
-      expect(screen.getByText('Option 1')).toBeInTheDocument()
-      expect(screen.getByText('Option 10')).toBeInTheDocument()
-      expect(screen.getAllByRole('checkbox')).toHaveLength(10)
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle options with special characters in labels', () => {
-      const specialOptions = [
-        { value: 'sci-fi', label: 'Sci-Fi & Fantasy' },
-        { value: 'kids', label: "Kids' Shows" },
-        { value: 'documentary', label: 'Documentary/Non-Fiction' },
-      ]
-      const condition = createCondition(['sci-fi'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={specialOptions}
-        />
-      )
-
-      expect(screen.getByText('Sci-Fi & Fantasy')).toBeInTheDocument()
-      expect(screen.getByText("Kids' Shows")).toBeInTheDocument()
-      expect(screen.getByText('Documentary/Non-Fiction')).toBeInTheDocument()
-    })
-
-    it('should handle empty options array', () => {
-      const condition = createCondition([])
-
-      const { container } = render(
-        <MultiSelectInput condition={condition} onChange={mockOnChange} options={[]} />
-      )
-
-      expect(screen.queryAllByRole('checkbox')).toHaveLength(0)
-      // Container should still render
-      expect(container.firstChild).toBeInTheDocument()
-    })
-
-    it('should handle value not in options', () => {
-      const condition = createCondition(['unknown'])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      // All checkboxes should be unchecked since 'unknown' is not in options
-      const checkboxes = screen.getAllByRole('checkbox')
-      checkboxes.forEach((checkbox) => {
-        expect(checkbox).not.toBeChecked()
-      })
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should associate labels with checkboxes', () => {
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      // Click on label text should toggle checkbox
-      const actionLabel = screen.getByText('Action')
-      expect(actionLabel.closest('label')).toBeInTheDocument()
-    })
-
-    it('should have clickable labels', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      // Clicking the label should trigger onChange
-      const actionLabel = screen.getByText('Action')
-      await user.click(actionLabel)
-
-      expect(mockOnChange).toHaveBeenCalled()
-    })
-
-    it('should have proper styling classes on labels', () => {
-      const condition = createCondition([])
-
-      render(
-        <MultiSelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const label = screen.getByText('Action').closest('label')
-      expect(label).toHaveClass('cursor-pointer')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/MultiTextInput.test.tsx b/components/maintenance/inputs/__tests__/MultiTextInput.test.tsx
deleted file mode 100644
index 7a48ac38..00000000
--- a/components/maintenance/inputs/__tests__/MultiTextInput.test.tsx
+++ /dev/null
@@ -1,357 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { MultiTextInput } from '../MultiTextInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('MultiTextInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: string[] | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'genres',
-    operator: 'containsAny',
-    value,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render text input and Add button', () => {
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByPlaceholderText('Type and press Enter')).toBeInTheDocument()
-      expect(screen.getByRole('button', { name: 'Add' })).toBeInTheDocument()
-    })
-
-    it('should not display tags when array is empty', () => {
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      // No tags should be visible
-      expect(screen.queryByText('×')).not.toBeInTheDocument()
-    })
-
-    it('should display existing values as tags', () => {
-      const condition = createCondition(['Action', 'Comedy', 'Drama'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('Action')).toBeInTheDocument()
-      expect(screen.getByText('Comedy')).toBeInTheDocument()
-      expect(screen.getByText('Drama')).toBeInTheDocument()
-    })
-
-    it('should display remove button for each tag', () => {
-      const condition = createCondition(['Tag1', 'Tag2'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const removeButtons = screen.getAllByText('×')
-      expect(removeButtons).toHaveLength(2)
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should handle null value as empty array', () => {
-      const condition = createCondition(null)
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.queryByText('×')).not.toBeInTheDocument()
-    })
-
-    it('should handle undefined value as empty array', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'genres',
-        operator: 'containsAny',
-        value: null,
-      }
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.queryByText('×')).not.toBeInTheDocument()
-    })
-  })
-
-  describe('Adding Values', () => {
-    it('should add value when Add button is clicked', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, 'NewTag')
-      await user.click(screen.getByRole('button', { name: 'Add' }))
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['NewTag'],
-        })
-      )
-    })
-
-    it('should add value when Enter key is pressed', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, 'NewTag{Enter}')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['NewTag'],
-        })
-      )
-    })
-
-    it('should append to existing values', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['Existing'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, 'New{Enter}')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['Existing', 'New'],
-        })
-      )
-    })
-
-    it('should clear input after adding value', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, 'Test{Enter}')
-
-      // The input should be cleared
-      expect(input).toHaveValue('')
-    })
-
-    it('should trim whitespace from values', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, '  SpacedTag  {Enter}')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['SpacedTag'],
-        })
-      )
-    })
-
-    it('should not add empty values', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, '   {Enter}')
-
-      expect(mockOnChange).not.toHaveBeenCalled()
-    })
-
-    it('should not add value when clicking Add with empty input', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByRole('button', { name: 'Add' }))
-
-      expect(mockOnChange).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Removing Values', () => {
-    it('should remove value when × button is clicked', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['Tag1', 'Tag2', 'Tag3'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const removeButtons = screen.getAllByText('×')
-      await user.click(removeButtons[1]) // Remove 'Tag2'
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['Tag1', 'Tag3'],
-        })
-      )
-    })
-
-    it('should remove first value correctly', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['First', 'Second'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const removeButtons = screen.getAllByText('×')
-      await user.click(removeButtons[0])
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['Second'],
-        })
-      )
-    })
-
-    it('should remove last value correctly', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['First', 'Second'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const removeButtons = screen.getAllByText('×')
-      await user.click(removeButtons[1])
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['First'],
-        })
-      )
-    })
-
-    it('should handle removing the only value', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['OnlyTag'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const removeButton = screen.getByText('×')
-      await user.click(removeButton)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [],
-        })
-      )
-    })
-  })
-
-  describe('Preserving Condition Properties', () => {
-    it('should preserve condition field and operator when adding', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, 'Test{Enter}')
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'genres',
-        operator: 'containsAny',
-        value: ['Test'],
-      })
-    })
-
-    it('should preserve condition field and operator when removing', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(['Tag1'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      await user.click(screen.getByText('×'))
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'genres',
-        operator: 'containsAny',
-        value: [],
-      })
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle special characters in values', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Type and press Enter')
-      await user.type(input, 'Sci-Fi & Fantasy{Enter}')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: ['Sci-Fi & Fantasy'],
-        })
-      )
-    })
-
-    it('should display special characters correctly', () => {
-      const condition = createCondition(['Sci-Fi & Fantasy', "Kids' Shows"])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('Sci-Fi & Fantasy')).toBeInTheDocument()
-      expect(screen.getByText("Kids' Shows")).toBeInTheDocument()
-    })
-
-    it('should handle many values', () => {
-      const manyValues = Array.from({ length: 20 }, (_, i) => `Tag${i + 1}`)
-      const condition = createCondition(manyValues)
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('Tag1')).toBeInTheDocument()
-      expect(screen.getByText('Tag20')).toBeInTheDocument()
-
-      const removeButtons = screen.getAllByText('×')
-      expect(removeButtons).toHaveLength(20)
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have proper input placeholder', () => {
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByPlaceholderText('Type and press Enter')).toBeInTheDocument()
-    })
-
-    it('should have type="button" on Add button', () => {
-      const condition = createCondition([])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const addButton = screen.getByRole('button', { name: 'Add' })
-      expect(addButton).toHaveAttribute('type', 'button')
-    })
-
-    it('should have type="button" on remove buttons', () => {
-      const condition = createCondition(['Tag1'])
-
-      render(<MultiTextInput condition={condition} onChange={mockOnChange} />)
-
-      const removeButton = screen.getByText('×').closest('button')
-      expect(removeButton).toHaveAttribute('type', 'button')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/NumberInput.test.tsx b/components/maintenance/inputs/__tests__/NumberInput.test.tsx
deleted file mode 100644
index 637b9a42..00000000
--- a/components/maintenance/inputs/__tests__/NumberInput.test.tsx
+++ /dev/null
@@ -1,337 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { NumberInput } from '../NumberInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('NumberInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render number input with placeholder', () => {
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toBeInTheDocument()
-      expect(input).toHaveAttribute('type', 'number')
-    })
-
-    it('should display correct placeholder for bytes unit', () => {
-      const condition: Condition = {
-        field: 'fileSize',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="bytes" />)
-
-      expect(screen.getByPlaceholderText('Size in GB (e.g., 10)')).toBeInTheDocument()
-    })
-
-    it('should display correct placeholder for minutes unit', () => {
-      const condition: Condition = {
-        field: 'duration',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="minutes" />)
-
-      expect(screen.getByPlaceholderText('Duration in minutes')).toBeInTheDocument()
-    })
-
-    it('should display correct placeholder for kbps unit', () => {
-      const condition: Condition = {
-        field: 'bitrate',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="kbps" />)
-
-      expect(screen.getByPlaceholderText('Bitrate in Mbps')).toBeInTheDocument()
-    })
-  })
-
-  describe('Min/Max Validation', () => {
-    it('should add min attribute when min prop is provided', () => {
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: 5,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} min={0} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveAttribute('min', '0')
-    })
-
-    it('should add max attribute when max prop is provided', () => {
-      const condition: Condition = {
-        field: 'rating',
-        operator: 'lessThan',
-        value: 8,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} max={10} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveAttribute('max', '10')
-    })
-
-    it('should add both min and max attributes when both props are provided', () => {
-      const condition: Condition = {
-        field: 'rating',
-        operator: 'equals',
-        value: 7,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} min={0} max={10} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveAttribute('min', '0')
-      expect(input).toHaveAttribute('max', '10')
-    })
-
-    it('should not add min/max attributes when props are not provided', () => {
-      const condition: Condition = {
-        field: 'year',
-        operator: 'equals',
-        value: 2020,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).not.toHaveAttribute('min')
-      expect(input).not.toHaveAttribute('max')
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should display current value', () => {
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'equals',
-        value: 42,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(42)
-    })
-
-    it('should handle null value', () => {
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'equals',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(null)
-    })
-
-    it('should call onChange when value changes', async () => {
-      const user = userEvent.setup()
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      await user.type(input, '7')
-
-      expect(mockOnChange).toHaveBeenCalled()
-      // Find the call with value 7
-      const matchingCall = mockOnChange.mock.calls.find(call => call[0].value === 7)
-      expect(matchingCall).toBeDefined()
-      expect(matchingCall[0].value).toBe(7)
-    })
-
-    it('should call onChange with null for invalid input', async () => {
-      const user = userEvent.setup()
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: 10,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByDisplayValue('10')
-      await user.clear(input)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: null,
-        })
-      )
-    })
-  })
-
-  describe('Unit Conversion', () => {
-    it('should convert bytes to GB for display', () => {
-      const oneGB = 1024 * 1024 * 1024
-      const condition: Condition = {
-        field: 'fileSize',
-        operator: 'greaterThan',
-        value: oneGB * 5, // 5 GB
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="bytes" />)
-
-      const input = screen.getByPlaceholderText('Size in GB (e.g., 10)')
-      expect(input).toHaveValue(5)
-      expect(screen.getByText('GB')).toBeInTheDocument()
-    })
-
-    it('should convert GB input to bytes for storage', async () => {
-      const user = userEvent.setup()
-      const condition: Condition = {
-        field: 'fileSize',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="bytes" />)
-
-      const input = screen.getByPlaceholderText('Size in GB (e.g., 10)')
-      await user.type(input, '2')
-
-      expect(mockOnChange).toHaveBeenCalled()
-      // Find the call where value is 2 GB converted to bytes
-      const expectedBytes = 2 * 1024 * 1024 * 1024
-      const matchingCall = mockOnChange.mock.calls.find(call => call[0].value === expectedBytes)
-      expect(matchingCall).toBeDefined()
-    })
-
-    it('should convert kbps to Mbps for display', () => {
-      const condition: Condition = {
-        field: 'bitrate',
-        operator: 'greaterThan',
-        value: 5000, // 5000 kbps = 5 Mbps
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="kbps" />)
-
-      const input = screen.getByPlaceholderText('Bitrate in Mbps')
-      expect(input).toHaveValue(5)
-      expect(screen.getByText('Mbps')).toBeInTheDocument()
-    })
-
-    it('should convert Mbps input to kbps for storage', async () => {
-      const user = userEvent.setup()
-      const condition: Condition = {
-        field: 'bitrate',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="kbps" />)
-
-      const input = screen.getByPlaceholderText('Bitrate in Mbps')
-      await user.type(input, '5')
-
-      expect(mockOnChange).toHaveBeenCalled()
-      // Find the call where value is 5 Mbps converted to kbps
-      const expectedKbps = 5000
-      const matchingCall = mockOnChange.mock.calls.find(call => call[0].value === expectedKbps)
-      expect(matchingCall).toBeDefined()
-    })
-
-    it('should display unit label for minutes', () => {
-      const condition: Condition = {
-        field: 'duration',
-        operator: 'greaterThan',
-        value: 90,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} unit="minutes" />)
-
-      expect(screen.getByText('min')).toBeInTheDocument()
-    })
-
-    it('should not display unit label when no unit is provided', () => {
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: 10,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.queryByText('GB')).not.toBeInTheDocument()
-      expect(screen.queryByText('Mbps')).not.toBeInTheDocument()
-      expect(screen.queryByText('min')).not.toBeInTheDocument()
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle zero value', () => {
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'equals',
-        value: 0,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      // Zero value is treated as falsy and displays as empty string
-      expect(input).toHaveValue(null)
-    })
-
-    it('should handle decimal values', () => {
-      const condition: Condition = {
-        field: 'rating',
-        operator: 'greaterThan',
-        value: 7.5,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      // Verify the decimal value is displayed
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(7.5)
-    })
-
-    it('should preserve condition field and operator when changing value', async () => {
-      const user = userEvent.setup()
-      const condition: Condition = {
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: null,
-      }
-
-      render(<NumberInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      await user.type(input, '5')
-
-      expect(mockOnChange).toHaveBeenCalled()
-      const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
-      expect(lastCall).toMatchObject({
-        field: 'playCount',
-        operator: 'greaterThan',
-        value: 5,
-      })
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/RangeInput.test.tsx b/components/maintenance/inputs/__tests__/RangeInput.test.tsx
deleted file mode 100644
index 316ad515..00000000
--- a/components/maintenance/inputs/__tests__/RangeInput.test.tsx
+++ /dev/null
@@ -1,342 +0,0 @@
-import { render, screen, fireEvent } from '@testing-library/react'
-import { RangeInput } from '../RangeInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('RangeInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: number[] | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'playCount',
-    operator: 'between',
-    value,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render two number inputs', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs).toHaveLength(2)
-      expect(inputs[0]).toHaveAttribute('placeholder', 'Min')
-      expect(inputs[1]).toHaveAttribute('placeholder', 'Max')
-    })
-
-    it('should render "to" separator between inputs', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('to')).toBeInTheDocument()
-    })
-
-    it('should display current min and max values', () => {
-      const condition = createCondition([5, 10])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(5)
-      expect(inputs[1]).toHaveValue(10)
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should handle null value as zeros', () => {
-      const condition = createCondition(null)
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(0)
-      expect(inputs[1]).toHaveValue(0)
-    })
-
-    it('should handle empty array as zeros', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'playCount',
-        operator: 'between',
-        value: [],
-      }
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      // Empty array defaults to [0, 0], but 0 displays as null in number inputs
-      expect(inputs[0]).toHaveValue(null)
-      expect(inputs[1]).toHaveValue(null)
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange when min value changes', () => {
-      const condition = createCondition([0, 100])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[0], { target: { value: '10' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [10, 100],
-        })
-      )
-    })
-
-    it('should call onChange when max value changes', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[1], { target: { value: '50' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [0, 50],
-        })
-      )
-    })
-
-    it('should preserve max when changing min', () => {
-      const condition = createCondition([0, 100])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[0], { target: { value: '25' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [25, 100],
-        })
-      )
-    })
-
-    it('should preserve min when changing max', () => {
-      const condition = createCondition([25, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[1], { target: { value: '75' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [25, 75],
-        })
-      )
-    })
-
-    it('should preserve condition field and operator', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[0], { target: { value: '5' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'playCount',
-        operator: 'between',
-        value: [5, 0],
-      })
-    })
-  })
-
-  describe('Unit Conversion - Bytes', () => {
-    const createBytesCondition = (value: number[]): Condition => ({
-      type: 'condition',
-      id: 'test-id',
-      field: 'fileSize',
-      operator: 'between',
-      value,
-    })
-
-    const oneGB = 1024 * 1024 * 1024
-
-    it('should convert bytes to GB for display', () => {
-      const condition = createBytesCondition([oneGB * 5, oneGB * 10])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="bytes" />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(5)
-      expect(inputs[1]).toHaveValue(10)
-    })
-
-    it('should display GB unit label', () => {
-      const condition = createBytesCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="bytes" />)
-
-      expect(screen.getByText('GB')).toBeInTheDocument()
-    })
-
-    it('should convert GB input to bytes for storage', () => {
-      const condition = createBytesCondition([0, oneGB * 100])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="bytes" />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[0], { target: { value: '2' } })
-
-      // 2 GB converted to bytes
-      const expectedBytes = 2 * oneGB
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [expectedBytes, oneGB * 100],
-        })
-      )
-    })
-  })
-
-  describe('Unit Conversion - kbps', () => {
-    const createKbpsCondition = (value: number[]): Condition => ({
-      type: 'condition',
-      id: 'test-id',
-      field: 'bitrate',
-      operator: 'between',
-      value,
-    })
-
-    it('should convert kbps to Mbps for display', () => {
-      const condition = createKbpsCondition([5000, 10000]) // 5 Mbps, 10 Mbps
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="kbps" />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(5)
-      expect(inputs[1]).toHaveValue(10)
-    })
-
-    it('should display Mbps unit label', () => {
-      const condition = createKbpsCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="kbps" />)
-
-      expect(screen.getByText('Mbps')).toBeInTheDocument()
-    })
-
-    it('should convert Mbps input to kbps for storage', () => {
-      const condition = createKbpsCondition([0, 10000])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="kbps" />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      fireEvent.change(inputs[0], { target: { value: '3' } })
-
-      // 3 Mbps converted to kbps
-      const expectedKbps = 3000
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: [expectedKbps, 10000],
-        })
-      )
-    })
-  })
-
-  describe('Unit Conversion - Minutes', () => {
-    const createMinutesCondition = (value: number[]): Condition => ({
-      type: 'condition',
-      id: 'test-id',
-      field: 'duration',
-      operator: 'between',
-      value,
-    })
-
-    it('should display values without conversion for minutes', () => {
-      const condition = createMinutesCondition([30, 120])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="minutes" />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(30)
-      expect(inputs[1]).toHaveValue(120)
-    })
-
-    it('should display min unit label', () => {
-      const condition = createMinutesCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} unit="minutes" />)
-
-      expect(screen.getByText('min')).toBeInTheDocument()
-    })
-  })
-
-  describe('Min/Max Limits', () => {
-    it('should apply min attribute to both inputs', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} min={0} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveAttribute('min', '0')
-      expect(inputs[1]).toHaveAttribute('min', '0')
-    })
-
-    it('should apply max attribute to both inputs', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} max={100} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveAttribute('max', '100')
-      expect(inputs[1]).toHaveAttribute('max', '100')
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle decimal values', () => {
-      const condition = createCondition([1.5, 2.5])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(1.5)
-      expect(inputs[1]).toHaveValue(2.5)
-    })
-
-    it('should handle same min and max values', () => {
-      const condition = createCondition([50, 50])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveValue(50)
-      expect(inputs[1]).toHaveValue(50)
-    })
-
-    it('should not display unit label when no unit provided', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.queryByText('GB')).not.toBeInTheDocument()
-      expect(screen.queryByText('Mbps')).not.toBeInTheDocument()
-      expect(screen.queryByText('min')).not.toBeInTheDocument()
-    })
-
-    it('should have step="any" for decimal support', () => {
-      const condition = createCondition([0, 0])
-
-      render(<RangeInput condition={condition} onChange={mockOnChange} />)
-
-      const inputs = screen.getAllByRole('spinbutton')
-      expect(inputs[0]).toHaveAttribute('step', 'any')
-      expect(inputs[1]).toHaveAttribute('step', 'any')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/RelativeDateInput.test.tsx b/components/maintenance/inputs/__tests__/RelativeDateInput.test.tsx
deleted file mode 100644
index a1018118..00000000
--- a/components/maintenance/inputs/__tests__/RelativeDateInput.test.tsx
+++ /dev/null
@@ -1,260 +0,0 @@
-import { render, screen, fireEvent } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { RelativeDateInput } from '../RelativeDateInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-// Mock StyledDropdown component
-jest.mock('@/components/ui/styled-dropdown', () => ({
-  StyledDropdown: ({
-    value,
-    onChange,
-    options,
-  }: {
-    value: string
-    onChange: (value: string) => void
-    options: Array<{ value: string; label: string }>
-  }) => (
-    <select
-      value={value}
-      onChange={(e) => onChange(e.target.value)}
-      data-testid="unit-dropdown"
-    >
-      {options.map((opt) => (
-        <option key={opt.value} value={opt.value}>
-          {opt.label}
-        </option>
-      ))}
-    </select>
-  ),
-}))
-
-describe('RelativeDateInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (
-    value: number,
-    valueUnit: 'days' | 'months' | 'years' = 'days'
-  ): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'lastWatchedAt',
-    operator: 'olderThan',
-    value,
-    valueUnit,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render number input and unit dropdown', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByPlaceholderText('Enter number')).toBeInTheDocument()
-      expect(screen.getByTestId('unit-dropdown')).toBeInTheDocument()
-      expect(screen.getByText('ago')).toBeInTheDocument()
-    })
-
-    it('should display current value', () => {
-      const condition = createCondition(90)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(90)
-    })
-
-    it('should display current unit', () => {
-      const condition = createCondition(6, 'months')
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const dropdown = screen.getByTestId('unit-dropdown')
-      expect(dropdown).toHaveValue('months')
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should handle zero value', () => {
-      const condition = createCondition(0)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(0)
-    })
-
-    it('should default unit to days when not provided', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'lastWatchedAt',
-        operator: 'olderThan',
-        value: 30,
-      }
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const dropdown = screen.getByTestId('unit-dropdown')
-      expect(dropdown).toHaveValue('days')
-    })
-
-    it('should default value to 0 when null', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'lastWatchedAt',
-        operator: 'olderThan',
-        value: null,
-        valueUnit: 'days',
-      }
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(0)
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange when number value changes', () => {
-      const condition = createCondition(0)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      fireEvent.change(input, { target: { value: '60' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: 60,
-        })
-      )
-    })
-
-    it('should call onChange when unit changes', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(30, 'days')
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const dropdown = screen.getByTestId('unit-dropdown')
-      await user.selectOptions(dropdown, 'months')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          valueUnit: 'months',
-        })
-      )
-    })
-
-    it('should preserve condition field and operator when changing value', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      fireEvent.change(input, { target: { value: '7' } })
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'lastWatchedAt',
-        operator: 'olderThan',
-        value: 7,
-        valueUnit: 'days',
-      })
-    })
-
-    it('should handle clearing value', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      fireEvent.change(input, { target: { value: '' } })
-
-      // After clearing, value should be 0
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: 0,
-        })
-      )
-    })
-  })
-
-  describe('Unit Options', () => {
-    it('should have days option', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('days')).toBeInTheDocument()
-    })
-
-    it('should have months option', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('months')).toBeInTheDocument()
-    })
-
-    it('should have years option', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('years')).toBeInTheDocument()
-    })
-
-    it('should switch from days to years', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition(365, 'days')
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const dropdown = screen.getByTestId('unit-dropdown')
-      await user.selectOptions(dropdown, 'years')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          valueUnit: 'years',
-        })
-      )
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle large numbers', () => {
-      const condition = createCondition(9999)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveValue(9999)
-    })
-
-    it('should have min attribute of 1', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter number')
-      expect(input).toHaveAttribute('min', '1')
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should render the "ago" label', () => {
-      const condition = createCondition(30)
-
-      render(<RelativeDateInput condition={condition} onChange={mockOnChange} />)
-
-      expect(screen.getByText('ago')).toBeInTheDocument()
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/SelectInput.test.tsx b/components/maintenance/inputs/__tests__/SelectInput.test.tsx
deleted file mode 100644
index 3363366f..00000000
--- a/components/maintenance/inputs/__tests__/SelectInput.test.tsx
+++ /dev/null
@@ -1,354 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { SelectInput } from '../SelectInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-// Mock StyledDropdown component
-jest.mock('@/components/ui/styled-dropdown', () => ({
-  StyledDropdown: ({
-    value,
-    onChange,
-    options,
-    placeholder,
-  }: {
-    value: string
-    onChange: (value: string) => void
-    options: Array<{ value: string; label: string }>
-    placeholder?: string
-  }) => (
-    <select
-      value={value}
-      onChange={(e) => onChange(e.target.value)}
-      data-testid="select-input"
-    >
-      {placeholder && (
-        <option value="" disabled>
-          {placeholder}
-        </option>
-      )}
-      {options.map((opt) => (
-        <option key={opt.value} value={opt.value}>
-          {opt.label}
-        </option>
-      ))}
-    </select>
-  ),
-}))
-
-describe('SelectInput', () => {
-  const mockOnChange = jest.fn()
-
-  const defaultOptions = [
-    { value: '1080p', label: '1080p' },
-    { value: '720p', label: '720p' },
-    { value: '480p', label: '480p' },
-  ]
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: string | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'resolution',
-    operator: 'equals',
-    value,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render a select dropdown', () => {
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      expect(screen.getByTestId('select-input')).toBeInTheDocument()
-    })
-
-    it('should render all provided options', () => {
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      expect(screen.getByText('1080p')).toBeInTheDocument()
-      expect(screen.getByText('720p')).toBeInTheDocument()
-      expect(screen.getByText('480p')).toBeInTheDocument()
-    })
-
-    it('should display placeholder text', () => {
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      expect(screen.getByText('Select...')).toBeInTheDocument()
-    })
-  })
-
-  describe('Value Display', () => {
-    it('should display current value', () => {
-      const condition = createCondition('720p')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      expect(select).toHaveValue('720p')
-    })
-
-    it('should handle empty string value', () => {
-      const condition = createCondition('')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      expect(select).toHaveValue('')
-    })
-
-    it('should handle null value as empty string', () => {
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      expect(select).toHaveValue('')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange when value changes', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      await user.selectOptions(select, '1080p')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: '1080p',
-        })
-      )
-    })
-
-    it('should preserve condition field and operator when changing value', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      await user.selectOptions(select, '720p')
-
-      expect(mockOnChange).toHaveBeenCalledWith({
-        type: 'condition',
-        id: 'test-id',
-        field: 'resolution',
-        operator: 'equals',
-        value: '720p',
-      })
-    })
-
-    it('should allow changing from one value to another', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('1080p')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      await user.selectOptions(select, '480p')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: '480p',
-        })
-      )
-    })
-  })
-
-  describe('Different Option Sets', () => {
-    it('should work with quality options', () => {
-      const qualityOptions = [
-        { value: 'SD', label: 'SD (480p)' },
-        { value: 'HD', label: 'HD (720p)' },
-        { value: 'FHD', label: 'Full HD (1080p)' },
-        { value: 'UHD', label: '4K UHD' },
-      ]
-      const condition = createCondition('HD')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={qualityOptions}
-        />
-      )
-
-      expect(screen.getByText('SD (480p)')).toBeInTheDocument()
-      expect(screen.getByText('HD (720p)')).toBeInTheDocument()
-      expect(screen.getByText('Full HD (1080p)')).toBeInTheDocument()
-      expect(screen.getByText('4K UHD')).toBeInTheDocument()
-    })
-
-    it('should work with single option', () => {
-      const singleOption = [{ value: 'only', label: 'Only Option' }]
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={singleOption}
-        />
-      )
-
-      expect(screen.getByText('Only Option')).toBeInTheDocument()
-    })
-
-    it('should work with many options', () => {
-      const manyOptions = Array.from({ length: 10 }, (_, i) => ({
-        value: `option${i + 1}`,
-        label: `Option ${i + 1}`,
-      }))
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={manyOptions}
-        />
-      )
-
-      expect(screen.getByText('Option 1')).toBeInTheDocument()
-      expect(screen.getByText('Option 10')).toBeInTheDocument()
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle options with special characters in labels', () => {
-      const specialOptions = [
-        { value: 'hevc', label: 'H.265/HEVC' },
-        { value: 'avc', label: 'H.264/AVC' },
-        { value: 'av1', label: 'AV1 (AOMedia)' },
-      ]
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={specialOptions}
-        />
-      )
-
-      expect(screen.getByText('H.265/HEVC')).toBeInTheDocument()
-      expect(screen.getByText('H.264/AVC')).toBeInTheDocument()
-      expect(screen.getByText('AV1 (AOMedia)')).toBeInTheDocument()
-    })
-
-    it('should handle options where value differs from label', () => {
-      const diffOptions = [
-        { value: 'en', label: 'English' },
-        { value: 'es', label: 'Spanish' },
-        { value: 'fr', label: 'French' },
-      ]
-      const condition = createCondition('es')
-
-      render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={diffOptions}
-        />
-      )
-
-      const select = screen.getByTestId('select-input')
-      expect(select).toHaveValue('es')
-      expect(screen.getByText('Spanish')).toBeInTheDocument()
-    })
-
-    it('should handle empty options array', () => {
-      const condition = createCondition(null)
-
-      render(
-        <SelectInput condition={condition} onChange={mockOnChange} options={[]} />
-      )
-
-      const select = screen.getByTestId('select-input')
-      expect(select).toBeInTheDocument()
-      // Only placeholder should be present
-      expect(screen.getByText('Select...')).toBeInTheDocument()
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should wrap in flex container', () => {
-      const condition = createCondition(null)
-
-      const { container } = render(
-        <SelectInput
-          condition={condition}
-          onChange={mockOnChange}
-          options={defaultOptions}
-        />
-      )
-
-      const wrapper = container.firstChild
-      expect(wrapper).toHaveClass('flex-1')
-    })
-  })
-})
diff --git a/components/maintenance/inputs/__tests__/StringInput.test.tsx b/components/maintenance/inputs/__tests__/StringInput.test.tsx
deleted file mode 100644
index 9ef0cb2c..00000000
--- a/components/maintenance/inputs/__tests__/StringInput.test.tsx
+++ /dev/null
@@ -1,193 +0,0 @@
-import { render, screen } from '@testing-library/react'
-import userEvent from '@testing-library/user-event'
-import { StringInput } from '../StringInput'
-import type { Condition } from '@/lib/validations/maintenance'
-
-describe('StringInput', () => {
-  const mockOnChange = jest.fn()
-
-  beforeEach(() => {
-    mockOnChange.mockClear()
-  })
-
-  const createCondition = (value: string | null): Condition => ({
-    type: 'condition',
-    id: 'test-id',
-    field: 'title',
-    operator: 'contains',
-    value,
-  })
-
-  describe('Basic Rendering', () => {
-    it('should render text input with default placeholder', () => {
-      const condition = createCondition(null)
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toBeInTheDocument()
-      expect(input).toHaveAttribute('type', 'text')
-    })
-
-    it('should render with custom placeholder', () => {
-      const condition = createCondition(null)
-
-      render(
-        <StringInput
-          condition={condition}
-          onChange={mockOnChange}
-          placeholder="Enter title"
-        />
-      )
-
-      expect(screen.getByPlaceholderText('Enter title')).toBeInTheDocument()
-    })
-
-    it('should display current value', () => {
-      const condition = createCondition('test value')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveValue('test value')
-    })
-  })
-
-  describe('Value Handling', () => {
-    it('should handle null value as empty string', () => {
-      const condition = createCondition(null)
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveValue('')
-    })
-
-    it('should handle undefined-like value as empty string', () => {
-      const condition: Condition = {
-        type: 'condition',
-        id: 'test-id',
-        field: 'title',
-        operator: 'contains',
-        value: '',
-      }
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveValue('')
-    })
-  })
-
-  describe('User Interactions', () => {
-    it('should call onChange when value changes', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      await user.type(input, 'x')
-
-      // Each character typed triggers onChange
-      expect(mockOnChange).toHaveBeenCalledTimes(1)
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: 'x',
-        })
-      )
-    })
-
-    it('should preserve condition field and operator when changing value', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      await user.type(input, 'x')
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          type: 'condition',
-          id: 'test-id',
-          field: 'title',
-          operator: 'contains',
-          value: 'x',
-        })
-      )
-    })
-
-    it('should handle clearing the input', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('existing value')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      await user.clear(input)
-
-      expect(mockOnChange).toHaveBeenCalledWith(
-        expect.objectContaining({
-          value: '',
-        })
-      )
-    })
-
-    it('should handle pasting text', async () => {
-      const user = userEvent.setup()
-      const condition = createCondition('')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      await user.click(input)
-      await user.paste('pasted text')
-
-      expect(mockOnChange).toHaveBeenCalled()
-      const lastCall = mockOnChange.mock.calls[mockOnChange.mock.calls.length - 1][0]
-      expect(lastCall.value).toBe('pasted text')
-    })
-  })
-
-  describe('Edge Cases', () => {
-    it('should handle special characters in display', () => {
-      const condition = createCondition('!@#$%^&*()')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveValue('!@#$%^&*()')
-    })
-
-    it('should handle whitespace in display', () => {
-      const condition = createCondition('  spaces  ')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveValue('  spaces  ')
-    })
-
-    it('should handle long text', () => {
-      const longText = 'a'.repeat(1000)
-      const condition = createCondition(longText)
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveValue(longText)
-    })
-  })
-
-  describe('Accessibility', () => {
-    it('should have proper input styling classes', () => {
-      const condition = createCondition('')
-
-      render(<StringInput condition={condition} onChange={mockOnChange} />)
-
-      const input = screen.getByPlaceholderText('Enter value')
-      expect(input).toHaveClass('flex-1')
-    })
-  })
-})
diff --git a/components/maintenance/rule-complexity-indicator.tsx b/components/maintenance/rule-complexity-indicator.tsx
deleted file mode 100644
index 112c2289..00000000
--- a/components/maintenance/rule-complexity-indicator.tsx
+++ /dev/null
@@ -1,147 +0,0 @@
-"use client"
-
-/**
- * Rule Complexity Indicator
- *
- * Displays metrics about rule complexity and provides warnings for overly complex rules.
- */
-
-interface RuleComplexityIndicatorProps {
-  complexity: {
-    conditionCount: number
-    groupCount: number
-    maxDepth: number
-    complexity: 'simple' | 'moderate' | 'complex'
-  }
-}
-
-export function RuleComplexityIndicator({ complexity }: RuleComplexityIndicatorProps) {
-  const { conditionCount, groupCount, maxDepth, complexity: level } = complexity
-
-  const getComplexityColor = () => {
-    switch (level) {
-      case 'simple':
-        return 'text-green-400 bg-green-400/10 border-green-400/30'
-      case 'moderate':
-        return 'text-yellow-400 bg-yellow-400/10 border-yellow-400/30'
-      case 'complex':
-        return 'text-orange-400 bg-orange-400/10 border-orange-400/30'
-    }
-  }
-
-  const getComplexityLabel = () => {
-    switch (level) {
-      case 'simple':
-        return 'Simple Rule'
-      case 'moderate':
-        return 'Moderate Complexity'
-      case 'complex':
-        return 'Complex Rule'
-    }
-  }
-
-  const getComplexityMessage = () => {
-    switch (level) {
-      case 'simple':
-        return 'This rule is straightforward and will evaluate quickly.'
-      case 'moderate':
-        return 'This rule has some complexity. Consider testing it with a small set first.'
-      case 'complex':
-        return 'This rule is very complex. It may be slower to evaluate and harder to debug. Consider simplifying if possible.'
-    }
-  }
-
-  return (
-    <div className="space-y-3">
-      {/* Metrics */}
-      <div className="grid grid-cols-3 gap-4">
-        <MetricCard
-          label="Conditions"
-          value={conditionCount}
-          icon={
-            <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2" />
-            </svg>
-          }
-        />
-        <MetricCard
-          label="Groups"
-          value={groupCount}
-          icon={
-            <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M19 11H5m14 0a2 2 0 012 2v6a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2m14 0V9a2 2 0 00-2-2M5 11V9a2 2 0 012-2m0 0V5a2 2 0 012-2h6a2 2 0 012 2v2M7 7h10" />
-            </svg>
-          }
-        />
-        <MetricCard
-          label="Max Depth"
-          value={maxDepth}
-          icon={
-            <svg className="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M7 16V4m0 0L3 8m4-4l4 4m6 0v12m0 0l4-4m-4 4l-4-4" />
-            </svg>
-          }
-        />
-      </div>
-
-      {/* Complexity Badge */}
-      <div className={`border rounded-lg p-4 ${getComplexityColor()}`}>
-        <div className="flex items-start gap-3">
-          <div className="flex-shrink-0 mt-0.5">
-            {level === 'simple' && (
-              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z" />
-              </svg>
-            )}
-            {level === 'moderate' && (
-              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
-              </svg>
-            )}
-            {level === 'complex' && (
-              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
-              </svg>
-            )}
-          </div>
-          <div className="flex-1">
-            <div className="font-medium text-sm mb-1">{getComplexityLabel()}</div>
-            <div className="text-xs opacity-90">{getComplexityMessage()}</div>
-          </div>
-        </div>
-      </div>
-
-      {/* Performance Warning for Very Deep Nesting */}
-      {maxDepth > 3 && (
-        <div className="bg-red-400/10 border border-red-400/30 rounded-lg p-4 text-red-400">
-          <div className="flex items-start gap-3">
-            <div className="flex-shrink-0 mt-0.5">
-              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
-              </svg>
-            </div>
-            <div className="flex-1">
-              <div className="font-medium text-sm mb-1">Very Deep Nesting Detected</div>
-              <div className="text-xs opacity-90">
-                Rules with {maxDepth} levels of nesting may be difficult to understand and maintain.
-                Consider restructuring into multiple simpler rules.
-              </div>
-            </div>
-          </div>
-        </div>
-      )}
-    </div>
-  )
-}
-
-function MetricCard({ label, value, icon }: { label: string; value: number; icon: React.ReactNode }) {
-  return (
-    <div className="bg-slate-800/50 border border-slate-700 rounded-lg p-4">
-      <div className="flex items-center gap-2 text-slate-400 mb-1">
-        {icon}
-        <div className="text-xs font-medium">{label}</div>
-      </div>
-      <div className="text-2xl font-bold text-white">{value}</div>
-    </div>
-  )
-}
diff --git a/components/maintenance/rule-criteria-builder.tsx b/components/maintenance/rule-criteria-builder.tsx
deleted file mode 100644
index 3e3b1417..00000000
--- a/components/maintenance/rule-criteria-builder.tsx
+++ /dev/null
@@ -1,351 +0,0 @@
-"use client"
-
-import { useState } from "react"
-import type { LegacyRuleCriteriaFlat as RuleCriteria } from "@/types/maintenance"
-import { StyledInput } from "@/components/ui/styled-input"
-import { StyledDropdown } from "@/components/ui/styled-dropdown"
-import { StyledCheckbox } from "@/components/ui/styled-checkbox"
-
-interface RuleCriteriaBuilderProps {
-  value: RuleCriteria
-  onChange: (criteria: RuleCriteria) => void
-  libraryOptions?: Array<{ id: string; name: string }>
-}
-
-const TIME_UNITS = [
-  { value: "days", label: "Days" },
-  { value: "months", label: "Months" },
-  { value: "years", label: "Years" },
-]
-
-const SIZE_UNITS = [
-  { value: "MB", label: "MB" },
-  { value: "GB", label: "GB" },
-  { value: "TB", label: "TB" },
-]
-
-export function RuleCriteriaBuilder({
-  value,
-  onChange,
-  libraryOptions = [],
-}: RuleCriteriaBuilderProps) {
-  const [showAdvanced, setShowAdvanced] = useState(false)
-
-  const updateCriteria = (updates: Partial<RuleCriteria>) => {
-    onChange({ ...value, ...updates })
-  }
-
-  const toggleNeverWatched = (checked: boolean) => {
-    updateCriteria({ neverWatched: checked || undefined })
-  }
-
-  const updateLastWatchedBefore = (field: "value" | "unit", val: string | number) => {
-    const current = value.lastWatchedBefore || { value: 30, unit: "days" as const }
-    updateCriteria({
-      lastWatchedBefore: {
-        ...current,
-        [field]: field === "value" ? Number(val) : val,
-      },
-    })
-  }
-
-  const clearLastWatchedBefore = () => {
-    updateCriteria({ lastWatchedBefore: undefined })
-  }
-
-  const updateAddedBefore = (field: "value" | "unit", val: string | number) => {
-    const current = value.addedBefore || { value: 365, unit: "days" as const }
-    updateCriteria({
-      addedBefore: {
-        ...current,
-        [field]: field === "value" ? Number(val) : val,
-      },
-    })
-  }
-
-  const clearAddedBefore = () => {
-    updateCriteria({ addedBefore: undefined })
-  }
-
-  const updateMinFileSize = (field: "value" | "unit", val: string | number) => {
-    const current = value.minFileSize || { value: 1, unit: "GB" as const }
-    updateCriteria({
-      minFileSize: {
-        ...current,
-        [field]: field === "value" ? Number(val) : val,
-      },
-    })
-  }
-
-  const clearMinFileSize = () => {
-    updateCriteria({ minFileSize: undefined })
-  }
-
-  const updateMaxPlayCount = (val: string) => {
-    const num = parseInt(val)
-    updateCriteria({ maxPlayCount: isNaN(num) ? undefined : num })
-  }
-
-  const updateMaxQuality = (val: string) => {
-    updateCriteria({ maxQuality: val || undefined })
-  }
-
-  const updateMaxRating = (val: string) => {
-    const num = parseFloat(val)
-    updateCriteria({ maxRating: isNaN(num) ? undefined : num })
-  }
-
-  const updateLibraryIds = (libraryId: string, checked: boolean) => {
-    const current = value.libraryIds || []
-    if (checked) {
-      updateCriteria({ libraryIds: [...current, libraryId] })
-    } else {
-      updateCriteria({ libraryIds: current.filter((id) => id !== libraryId) })
-    }
-  }
-
-  const toggleOperator = () => {
-    updateCriteria({ operator: value.operator === "AND" ? "OR" : "AND" })
-  }
-
-  return (
-    <div className="space-y-6">
-      {/* Operator Toggle */}
-      <div className="flex items-center justify-between p-4 bg-slate-800/30 rounded-lg border border-slate-700">
-        <div>
-          <p className="text-sm font-medium text-white">Match Criteria</p>
-          <p className="text-xs text-slate-400 mt-1">
-            {value.operator === "AND"
-              ? "All criteria must match"
-              : "Any criteria can match"}
-          </p>
-        </div>
-        <button
-          type="button"
-          onClick={toggleOperator}
-          className={`px-4 py-2 rounded-lg font-medium text-sm transition-colors ${
-            value.operator === "AND"
-              ? "bg-cyan-600 hover:bg-cyan-700 text-white"
-              : "bg-purple-600 hover:bg-purple-700 text-white"
-          }`}
-        >
-          {value.operator}
-        </button>
-      </div>
-
-      {/* Basic Criteria */}
-      <div className="space-y-4">
-        <h3 className="text-sm font-medium text-white">Basic Criteria</h3>
-
-        {/* Never Watched */}
-        <div className="flex items-center gap-3">
-          <StyledCheckbox
-            id="neverWatched"
-            checked={value.neverWatched || false}
-            onChange={(e) => toggleNeverWatched(e.target.checked)}
-          />
-          <label htmlFor="neverWatched" className="text-sm text-slate-200 cursor-pointer">
-            Never watched
-          </label>
-        </div>
-
-        {/* Last Watched Before */}
-        <div className="space-y-2">
-          <div className="flex items-center justify-between">
-            <label className="text-sm text-slate-200">Last watched before</label>
-            {value.lastWatchedBefore && (
-              <button
-                type="button"
-                onClick={clearLastWatchedBefore}
-                className="text-xs text-red-400 hover:text-red-300"
-              >
-                Clear
-              </button>
-            )}
-          </div>
-          <div className="flex gap-2">
-            <StyledInput
-              type="number"
-              min="1"
-              placeholder="30"
-              value={value.lastWatchedBefore?.value || ""}
-              onChange={(e) => updateLastWatchedBefore("value", e.target.value)}
-              className="flex-1"
-            />
-            <StyledDropdown
-              value={value.lastWatchedBefore?.unit || "days"}
-              onChange={(val) => updateLastWatchedBefore("unit", val)}
-              options={TIME_UNITS}
-              className="w-32"
-            />
-          </div>
-        </div>
-
-        {/* Max Play Count */}
-        <div className="space-y-2">
-          <label className="text-sm text-slate-200">Max play count</label>
-          <StyledInput
-            type="number"
-            min="0"
-            placeholder="e.g., 1"
-            value={value.maxPlayCount ?? ""}
-            onChange={(e) => updateMaxPlayCount(e.target.value)}
-          />
-          <p className="text-xs text-slate-400">
-            Match items played this many times or fewer
-          </p>
-        </div>
-
-        {/* Added Before */}
-        <div className="space-y-2">
-          <div className="flex items-center justify-between">
-            <label className="text-sm text-slate-200">Added before</label>
-            {value.addedBefore && (
-              <button
-                type="button"
-                onClick={clearAddedBefore}
-                className="text-xs text-red-400 hover:text-red-300"
-              >
-                Clear
-              </button>
-            )}
-          </div>
-          <div className="flex gap-2">
-            <StyledInput
-              type="number"
-              min="1"
-              placeholder="365"
-              value={value.addedBefore?.value || ""}
-              onChange={(e) => updateAddedBefore("value", e.target.value)}
-              className="flex-1"
-            />
-            <StyledDropdown
-              value={value.addedBefore?.unit || "days"}
-              onChange={(val) => updateAddedBefore("unit", val)}
-              options={TIME_UNITS}
-              className="w-32"
-            />
-          </div>
-        </div>
-
-        {/* Min File Size */}
-        <div className="space-y-2">
-          <div className="flex items-center justify-between">
-            <label className="text-sm text-slate-200">Minimum file size</label>
-            {value.minFileSize && (
-              <button
-                type="button"
-                onClick={clearMinFileSize}
-                className="text-xs text-red-400 hover:text-red-300"
-              >
-                Clear
-              </button>
-            )}
-          </div>
-          <div className="flex gap-2">
-            <StyledInput
-              type="number"
-              min="0"
-              step="0.1"
-              placeholder="1"
-              value={value.minFileSize?.value || ""}
-              onChange={(e) => updateMinFileSize("value", e.target.value)}
-              className="flex-1"
-            />
-            <StyledDropdown
-              value={value.minFileSize?.unit || "GB"}
-              onChange={(val) => updateMinFileSize("unit", val)}
-              options={SIZE_UNITS}
-              className="w-32"
-            />
-          </div>
-        </div>
-      </div>
-
-      {/* Advanced Criteria Toggle */}
-      <button
-        type="button"
-        onClick={() => setShowAdvanced(!showAdvanced)}
-        className="flex items-center gap-2 text-sm text-cyan-400 hover:text-cyan-300 transition-colors"
-      >
-        <svg
-          className={`w-4 h-4 transition-transform ${showAdvanced ? "rotate-90" : ""}`}
-          fill="none"
-          stroke="currentColor"
-          viewBox="0 0 24 24"
-        >
-          <path
-            strokeLinecap="round"
-            strokeLinejoin="round"
-            strokeWidth={2}
-            d="M9 5l7 7-7 7"
-          />
-        </svg>
-        Advanced Criteria
-      </button>
-
-      {/* Advanced Criteria */}
-      {showAdvanced && (
-        <div className="space-y-4 pl-6 border-l-2 border-slate-700">
-          {/* Max Quality */}
-          <div className="space-y-2">
-            <label className="text-sm text-slate-200">Max quality</label>
-            <StyledInput
-              type="text"
-              placeholder="e.g., 720p, SD"
-              value={value.maxQuality || ""}
-              onChange={(e) => updateMaxQuality(e.target.value)}
-            />
-            <p className="text-xs text-slate-400">
-              Match items with this quality or lower
-            </p>
-          </div>
-
-          {/* Max Rating */}
-          <div className="space-y-2">
-            <label className="text-sm text-slate-200">Max rating</label>
-            <StyledInput
-              type="number"
-              min="0"
-              max="10"
-              step="0.1"
-              placeholder="e.g., 5.0"
-              value={value.maxRating ?? ""}
-              onChange={(e) => updateMaxRating(e.target.value)}
-            />
-            <p className="text-xs text-slate-400">
-              Match items rated this value or lower (0-10)
-            </p>
-          </div>
-
-          {/* Library Selection */}
-          {libraryOptions.length > 0 && (
-            <div className="space-y-2">
-              <label className="text-sm text-slate-200">Libraries</label>
-              <div className="space-y-2 max-h-48 overflow-y-auto p-3 bg-slate-900/50 rounded-lg">
-                {libraryOptions.map((library) => (
-                  <div key={library.id} className="flex items-center gap-3">
-                    <StyledCheckbox
-                      id={`library-${library.id}`}
-                      checked={value.libraryIds?.includes(library.id) || false}
-                      onChange={(e) => updateLibraryIds(library.id, e.target.checked)}
-                    />
-                    <label
-                      htmlFor={`library-${library.id}`}
-                      className="text-sm text-slate-200 cursor-pointer"
-                    >
-                      {library.name}
-                    </label>
-                  </div>
-                ))}
-              </div>
-              <p className="text-xs text-slate-400">
-                Leave empty to match all libraries
-              </p>
-            </div>
-          )}
-        </div>
-      )}
-    </div>
-  )
-}
diff --git a/components/maintenance/scan-status-badge.tsx b/components/maintenance/scan-status-badge.tsx
deleted file mode 100644
index 6b0fb135..00000000
--- a/components/maintenance/scan-status-badge.tsx
+++ /dev/null
@@ -1,40 +0,0 @@
-import type { ScanStatus } from "@/lib/validations/maintenance"
-
-interface ScanStatusBadgeProps {
-  status: ScanStatus
-}
-
-export function ScanStatusBadge({ status }: ScanStatusBadgeProps) {
-  switch (status) {
-    case "PENDING":
-      return (
-        <span className="px-1.5 py-0.5 bg-yellow-500/20 text-yellow-400 text-xs font-medium rounded">
-          Pending
-        </span>
-      )
-    case "RUNNING":
-      return (
-        <span className="px-1.5 py-0.5 bg-blue-500/20 text-blue-400 text-xs font-medium rounded">
-          Running
-        </span>
-      )
-    case "COMPLETED":
-      return (
-        <span className="px-1.5 py-0.5 bg-green-500/20 text-green-400 text-xs font-medium rounded">
-          Completed
-        </span>
-      )
-    case "FAILED":
-      return (
-        <span className="px-1.5 py-0.5 bg-red-500/20 text-red-400 text-xs font-medium rounded">
-          Failed
-        </span>
-      )
-    default:
-      return (
-        <span className="px-1.5 py-0.5 bg-slate-700/50 text-slate-300 text-xs font-medium rounded">
-          Unknown
-        </span>
-      )
-  }
-}
diff --git a/components/maintenance/stats-card.tsx b/components/maintenance/stats-card.tsx
deleted file mode 100644
index 70ddf1b7..00000000
--- a/components/maintenance/stats-card.tsx
+++ /dev/null
@@ -1,73 +0,0 @@
-import { ReactNode } from "react"
-
-interface StatsCardProps {
-  label: string
-  value: string | number
-  icon?: ReactNode
-  trend?: {
-    value: number
-    isPositive: boolean
-  }
-  variant?: "default" | "success" | "warning" | "danger"
-}
-
-const variantClasses = {
-  default: "bg-slate-800/50 border-slate-700",
-  success: "bg-green-500/10 border-green-500/30",
-  warning: "bg-yellow-500/10 border-yellow-500/30",
-  danger: "bg-red-500/10 border-red-500/30",
-}
-
-const iconColorClasses = {
-  default: "text-cyan-400",
-  success: "text-green-400",
-  warning: "text-yellow-400",
-  danger: "text-red-400",
-}
-
-export function StatsCard({ label, value, icon, trend, variant = "default" }: StatsCardProps) {
-  return (
-    <div className={`p-4 rounded-lg border ${variantClasses[variant]}`}>
-      <div className="flex items-start justify-between">
-        <div className="flex-1">
-          <p className="text-sm text-slate-400 mb-1">{label}</p>
-          <p className="text-2xl font-bold text-white">{value}</p>
-          {trend && (
-            <div className="flex items-center gap-1 mt-2">
-              <svg
-                className={`w-4 h-4 ${trend.isPositive ? "text-green-400" : "text-red-400"}`}
-                fill="none"
-                stroke="currentColor"
-                viewBox="0 0 24 24"
-              >
-                {trend.isPositive ? (
-                  <path
-                    strokeLinecap="round"
-                    strokeLinejoin="round"
-                    strokeWidth={2}
-                    d="M13 7h8m0 0v8m0-8l-8 8-4-4-6 6"
-                  />
-                ) : (
-                  <path
-                    strokeLinecap="round"
-                    strokeLinejoin="round"
-                    strokeWidth={2}
-                    d="M13 17h8m0 0v-8m0 8l-8-8-4 4-6-6"
-                  />
-                )}
-              </svg>
-              <span className={`text-xs ${trend.isPositive ? "text-green-400" : "text-red-400"}`}>
-                {Math.abs(trend.value)}%
-              </span>
-            </div>
-          )}
-        </div>
-        {icon && (
-          <div className={`p-2 rounded-lg ${iconColorClasses[variant]}`}>
-            {icon}
-          </div>
-        )}
-      </div>
-    </div>
-  )
-}
diff --git a/e2e/admin-maintenance.spec.ts b/e2e/admin-maintenance.spec.ts
deleted file mode 100644
index 20ea8969..00000000
--- a/e2e/admin-maintenance.spec.ts
+++ /dev/null
@@ -1,484 +0,0 @@
-import { expect, test } from './fixtures/auth';
-import { waitForAdminContent, waitForAdminPageReady, waitForToast, WAIT_TIMEOUTS } from './helpers/test-utils';
-import { seedMaintenanceData, cleanupMaintenanceData, resetCandidateStatuses, MAINTENANCE_TEST_DATA } from './helpers/maintenance-seed';
-import { createE2EPrismaClient } from './helpers/prisma';
-import type { PrismaClient } from '../lib/generated/prisma/client';
-
-/**
- * Admin Maintenance Feature E2E Tests
- *
- * These tests cover the complete maintenance workflow including:
- * - Creating and managing maintenance rules
- * - Reviewing and acting on candidates
- * - Bulk operations
- * - Viewing deletion history
- */
-test.describe('Admin Maintenance Feature', () => {
-  // Shared Prisma client for all maintenance tests to avoid creating multiple connection pools
-  let prisma: PrismaClient;
-
-  test.beforeAll(async () => {
-    prisma = createE2EPrismaClient();
-  });
-
-  test.afterAll(async () => {
-    await prisma.$disconnect();
-  });
-  test.describe('Maintenance Rules', () => {
-    test.describe('UI Structure', () => {
-      test('should access maintenance rules page', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-
-        // Click the Rules link in sidebar
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-      });
-
-      test('should navigate to create rule page', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        await adminPage.getByTestId('maintenance-rule-create').click();
-
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Create Maintenance Rule' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-      });
-
-      test('should display rule creation form', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-        await adminPage.getByTestId('maintenance-rule-create').click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Create Maintenance Rule' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        await expect(adminPage.getByTestId('maintenance-rule-name-input')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-media-type-select')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-action-type-select')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-submit')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-cancel')).toBeVisible();
-      });
-
-      test('should show rule builder interface', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-        await adminPage.getByTestId('maintenance-rule-create').click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Create Maintenance Rule' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        await expect(adminPage.getByTestId('maintenance-rule-add-condition')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-add-group')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-operator-toggle')).toBeVisible();
-      });
-    });
-
-    test.describe('Rule Creation Workflow', () => {
-      test('should show validation error when submitting empty form', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-        await adminPage.getByTestId('maintenance-rule-create').click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Create Maintenance Rule' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Clear any default name and submit
-        const nameInput = adminPage.getByTestId('maintenance-rule-name-input');
-        await nameInput.fill('');
-
-        await adminPage.getByTestId('maintenance-rule-submit').click();
-
-        // HTML5 validation prevents submission - verify field is invalid
-        const validationMessage = await nameInput.evaluate(
-          (el: HTMLInputElement) => el.validationMessage
-        );
-        expect(validationMessage).toBeTruthy();
-
-        // Should still be on create page (form didn't submit)
-        await expect(adminPage.getByRole('heading', { name: 'Create Maintenance Rule' })).toBeVisible();
-      });
-
-      test('should navigate back when cancel button is clicked', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        await adminPage.getByTestId('maintenance-rule-create').click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Create Maintenance Rule' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Click cancel button
-        await adminPage.getByTestId('maintenance-rule-cancel').click();
-
-        // Should navigate back to rules list
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-      });
-
-      test('should create a complete rule successfully', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Rules' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-        await adminPage.getByTestId('maintenance-rule-create').click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Create Maintenance Rule' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        const uniqueRuleName = `E2E Test Rule ${Date.now()}`;
-
-        // Fill in rule name
-        await adminPage.getByTestId('maintenance-rule-name-input').fill(uniqueRuleName);
-
-        // The form should have default media type and action type selected
-        // Verify they are visible (defaults are Movie and Flag for Review)
-        await expect(adminPage.getByTestId('maintenance-rule-media-type-select')).toBeVisible();
-        await expect(adminPage.getByTestId('maintenance-rule-action-type-select')).toBeVisible();
-
-        // The default condition should already be present
-        // Verify we can see the condition builder elements
-        await expect(adminPage.getByTestId('maintenance-rule-add-condition')).toBeVisible();
-
-        // Submit the form
-        await adminPage.getByTestId('maintenance-rule-submit').click();
-
-        // Should show success toast
-        await waitForToast(adminPage, /created successfully/i, { timeout: WAIT_TIMEOUTS.PAGE_CONTENT });
-
-        // Should redirect to rules list
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Maintenance Rules' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Force page reload to ensure fresh data
-        await adminPage.reload();
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-
-        // The new rule should appear in the list
-        await expect(adminPage.getByText(uniqueRuleName)).toBeVisible({ timeout: WAIT_TIMEOUTS.PAGE_CONTENT });
-      });
-    });
-  });
-
-  test.describe('Maintenance Candidates', () => {
-    test.describe('UI Structure', () => {
-      test('should access candidates page', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-      });
-
-      test('should display candidate filters', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        await expect(adminPage.getByTestId('review-status-filter')).toBeVisible();
-        await expect(adminPage.getByTestId('media-type-filter')).toBeVisible();
-      });
-
-      test('should show bulk actions in DOM', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Bulk actions exist in DOM (hidden when no selection)
-        const bulkApprove = adminPage.getByTestId('bulk-approve-button');
-        const bulkReject = adminPage.getByTestId('bulk-reject-button');
-
-        expect(await bulkApprove.count()).toBe(1);
-        expect(await bulkReject.count()).toBe(1);
-      });
-    });
-
-    test.describe('Candidate Review Workflow', () => {
-      test.beforeAll(async () => {
-        await seedMaintenanceData(prisma);
-      });
-
-      test.afterAll(async () => {
-        await cleanupMaintenanceData(prisma);
-      });
-
-      test.beforeEach(async () => {
-        await resetCandidateStatuses(prisma);
-      });
-
-      test('should display seeded candidates', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Should show candidates in the list
-        // Wait for the first candidate to appear
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-      });
-
-      test('should approve individual candidate', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Wait for candidates to load
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-
-        // Find and click the approve button for the first candidate
-        const approveButton = adminPage.getByTestId(`approve-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[0].id}`);
-        await expect(approveButton).toBeVisible();
-        await approveButton.click();
-
-        // Should show success toast
-        await waitForToast(adminPage, /status updated|approved/i, { timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-
-        // The candidate status should update (may need to check the status badge)
-        // After approval, the approve/reject buttons should disappear for that candidate
-        await expect(approveButton).not.toBeVisible({ timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-      });
-
-      test('should reject individual candidate', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Wait for candidates to load
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[1].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-
-        // Find and click the reject button for the second candidate
-        const rejectButton = adminPage.getByTestId(`reject-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[1].id}`);
-        await expect(rejectButton).toBeVisible();
-        await rejectButton.click();
-
-        // Should show success toast
-        await waitForToast(adminPage, /status updated|rejected/i, { timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-
-        // The reject button should disappear after rejection
-        await expect(rejectButton).not.toBeVisible({ timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-      });
-
-      test('should select candidates using checkboxes', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Wait for candidates to load
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-
-        // Select the first candidate
-        const firstCheckbox = adminPage.getByTestId(`select-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[0].id}`);
-        await expect(firstCheckbox).toBeVisible();
-        await firstCheckbox.click();
-
-        // Bulk actions should now be visible
-        const bulkApproveButton = adminPage.getByTestId('bulk-approve-button');
-        await expect(bulkApproveButton).toBeVisible({ timeout: WAIT_TIMEOUTS.DIALOG_APPEAR });
-
-        // Select another candidate
-        const secondCheckbox = adminPage.getByTestId(`select-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[1].id}`);
-        await expect(secondCheckbox).toBeVisible();
-        await secondCheckbox.click();
-
-        // Button should show count of selected candidates (2)
-        await expect(bulkApproveButton).toContainText('2');
-      });
-
-      test('should perform bulk approve operation', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Wait for candidates to load
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-
-        // Select multiple candidates
-        await adminPage.getByTestId(`select-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[0].id}`).click();
-        await adminPage.getByTestId(`select-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[1].id}`).click();
-
-        // Click bulk approve
-        const bulkApproveButton = adminPage.getByTestId('bulk-approve-button');
-        await expect(bulkApproveButton).toBeVisible();
-        await bulkApproveButton.click();
-
-        // Should show success toast
-        await waitForToast(adminPage, /2 candidates approved/i, { timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-
-        // The approve buttons for those candidates should disappear
-        await expect(adminPage.getByTestId(`approve-candidate-${MAINTENANCE_TEST_DATA.CANDIDATES[0].id}`)).not.toBeVisible({ timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-      });
-
-      test('should perform bulk reject operation', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Wait for candidates to load
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-
-        // Select candidates using select-all checkbox
-        const selectAllCheckbox = adminPage.getByTestId('select-all-candidates');
-        await expect(selectAllCheckbox).toBeVisible();
-        await selectAllCheckbox.click();
-
-        // Click bulk reject
-        const bulkRejectButton = adminPage.getByTestId('bulk-reject-button');
-        await expect(bulkRejectButton).toBeVisible();
-        await bulkRejectButton.click();
-
-        // Should show success toast
-        await waitForToast(adminPage, /candidates rejected/i, { timeout: WAIT_TIMEOUTS.TOAST_APPEAR });
-      });
-
-      test('should filter candidates by review status', async ({ adminPage }) => {
-        await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-        await adminPage.getByRole('link', { name: 'Candidates' }).click();
-        await waitForAdminContent(adminPage, [
-          { type: 'heading', value: 'Review Candidates' }
-        ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-        // Wait for initial load with PENDING filter (default)
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-
-        // Change the review status filter to ALL
-        const statusFilter = adminPage.getByTestId('review-status-filter');
-        await statusFilter.click();
-
-        // Select ALL option (custom dropdown uses buttons, not native options)
-        await adminPage.getByRole('button', { name: /all status/i }).click();
-
-        // Page should update - verify we still see candidates
-        await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.CANDIDATES[0].title)).toBeVisible({
-          timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-        });
-      });
-    });
-  });
-
-  test.describe('Maintenance History', () => {
-    test.beforeAll(async () => {
-      await seedMaintenanceData(prisma);
-    });
-
-    test.afterAll(async () => {
-      await cleanupMaintenanceData(prisma);
-    });
-
-    test('should access history page', async ({ adminPage }) => {
-      await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-      await adminPage.getByRole('link', { name: 'Deletion History' }).click();
-
-      await waitForAdminContent(adminPage, [
-        { type: 'heading', value: 'Deletion History' }
-      ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-    });
-
-    test('should display deletion history entries', async ({ adminPage }) => {
-      await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-      await adminPage.getByRole('link', { name: 'Deletion History' }).click();
-      await waitForAdminContent(adminPage, [
-        { type: 'heading', value: 'Deletion History' }
-      ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-      // Should show the seeded deletion log entry
-      await expect(adminPage.getByText(MAINTENANCE_TEST_DATA.DELETION_LOG.title)).toBeVisible({
-        timeout: WAIT_TIMEOUTS.ADMIN_CONTENT
-      });
-    });
-
-    test('should show deletion statistics', async ({ adminPage }) => {
-      await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-      await adminPage.getByRole('link', { name: 'Deletion History' }).click();
-      await waitForAdminContent(adminPage, [
-        { type: 'heading', value: 'Deletion History' }
-      ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-      // The history page should show statistics cards or summary
-      // Look for common stat elements
-      await expect(adminPage.locator('main')).toBeVisible({ timeout: WAIT_TIMEOUTS.PAGE_CONTENT });
-    });
-  });
-
-  test.describe('Navigation', () => {
-    test('should navigate between maintenance pages', async ({ adminPage }) => {
-      await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-
-      // Start at rules page
-      await adminPage.getByRole('link', { name: 'Rules' }).click();
-      await waitForAdminContent(adminPage, [
-        { type: 'heading', value: 'Maintenance Rules' }
-      ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-      // Navigate to candidates
-      await adminPage.getByRole('link', { name: 'Candidates' }).click();
-      await waitForAdminContent(adminPage, [
-        { type: 'heading', value: 'Review Candidates' }
-      ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-
-      // Navigate to history
-      await adminPage.getByRole('link', { name: 'Deletion History' }).click();
-      await waitForAdminContent(adminPage, [
-        { type: 'heading', value: 'Deletion History' }
-      ], { timeout: WAIT_TIMEOUTS.ADMIN_CONTENT });
-    });
-
-    test('should access maintenance overview page', async ({ adminPage }) => {
-      await waitForAdminPageReady(adminPage, WAIT_TIMEOUTS.ADMIN_CONTENT);
-      await adminPage.getByRole('link', { name: 'Overview' }).click();
-
-      // Should load without error
-      await expect(adminPage.locator('main')).toBeVisible({ timeout: WAIT_TIMEOUTS.PAGE_CONTENT });
-    });
-  });
-});
diff --git a/e2e/helpers/maintenance-seed.ts b/e2e/helpers/maintenance-seed.ts
deleted file mode 100644
index 24edaacc..00000000
--- a/e2e/helpers/maintenance-seed.ts
+++ /dev/null
@@ -1,277 +0,0 @@
-import { createE2EPrismaClient } from './prisma';
-import type { PrismaClient } from '../../lib/generated/prisma/client';
-
-/**
- * Test data constants for maintenance tests
- */
-export const MAINTENANCE_TEST_DATA = {
-  RULE: {
-    id: 'test-maintenance-rule-id',
-    name: 'Test Maintenance Rule',
-    description: 'A test rule for E2E testing',
-  },
-  SCAN: {
-    id: 'test-maintenance-scan-id',
-  },
-  CANDIDATES: [
-    {
-      id: 'test-candidate-1',
-      title: 'Test Movie Alpha',
-      year: 2020,
-      plexRatingKey: 'plex-rating-1',
-      mediaType: 'MOVIE' as const,
-      playCount: 0,
-      fileSize: BigInt(5368709120), // 5GB
-      filePath: '/media/movies/test-movie-alpha.mkv',
-    },
-    {
-      id: 'test-candidate-2',
-      title: 'Test Movie Beta',
-      year: 2019,
-      plexRatingKey: 'plex-rating-2',
-      mediaType: 'MOVIE' as const,
-      playCount: 2,
-      fileSize: BigInt(3221225472), // 3GB
-      filePath: '/media/movies/test-movie-beta.mkv',
-    },
-    {
-      id: 'test-candidate-3',
-      title: 'Test Series Gamma',
-      year: 2021,
-      plexRatingKey: 'plex-rating-3',
-      mediaType: 'TV_SERIES' as const,
-      playCount: 1,
-      fileSize: BigInt(10737418240), // 10GB
-      filePath: '/media/tv/test-series-gamma',
-    },
-  ],
-  DELETION_LOG: {
-    id: 'test-deletion-log-id',
-    title: 'Deleted Test Movie',
-    year: 2018,
-    mediaType: 'MOVIE' as const,
-    fileSize: BigInt(4294967296), // 4GB
-  },
-} as const;
-
-/**
- * Seeds maintenance test data into the database
- * Creates a rule, scan, and candidates for testing
- */
-export async function seedMaintenanceData(prisma?: PrismaClient): Promise<void> {
-  const client = prisma || createE2EPrismaClient();
-
-  try {
-    console.log('[E2E Maintenance Seed] Starting maintenance data seeding...');
-
-    // Create a maintenance rule
-    await client.maintenanceRule.upsert({
-      where: { id: MAINTENANCE_TEST_DATA.RULE.id },
-      create: {
-        id: MAINTENANCE_TEST_DATA.RULE.id,
-        name: MAINTENANCE_TEST_DATA.RULE.name,
-        description: MAINTENANCE_TEST_DATA.RULE.description,
-        enabled: true,
-        mediaType: 'MOVIE',
-        actionType: 'FLAG_FOR_REVIEW',
-        criteria: {
-          type: 'group',
-          id: 'root-group',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'cond-1',
-              field: 'playCount',
-              operator: 'equals',
-              value: 0,
-            }
-          ],
-        },
-      },
-      update: {
-        name: MAINTENANCE_TEST_DATA.RULE.name,
-        enabled: true,
-      },
-    });
-    console.log('[E2E Maintenance Seed] Created maintenance rule');
-
-    // Create a completed scan
-    await client.maintenanceScan.upsert({
-      where: { id: MAINTENANCE_TEST_DATA.SCAN.id },
-      create: {
-        id: MAINTENANCE_TEST_DATA.SCAN.id,
-        ruleId: MAINTENANCE_TEST_DATA.RULE.id,
-        status: 'COMPLETED',
-        startedAt: new Date(Date.now() - 3600000), // 1 hour ago
-        completedAt: new Date(),
-        itemsScanned: 100,
-        itemsFlagged: MAINTENANCE_TEST_DATA.CANDIDATES.length,
-      },
-      update: {
-        status: 'COMPLETED',
-        completedAt: new Date(),
-        itemsFlagged: MAINTENANCE_TEST_DATA.CANDIDATES.length,
-      },
-    });
-    console.log('[E2E Maintenance Seed] Created maintenance scan');
-
-    // Create candidates
-    for (const candidate of MAINTENANCE_TEST_DATA.CANDIDATES) {
-      await client.maintenanceCandidate.upsert({
-        where: {
-          scanId_plexRatingKey: {
-            scanId: MAINTENANCE_TEST_DATA.SCAN.id,
-            plexRatingKey: candidate.plexRatingKey,
-          }
-        },
-        create: {
-          id: candidate.id,
-          scanId: MAINTENANCE_TEST_DATA.SCAN.id,
-          title: candidate.title,
-          year: candidate.year,
-          plexRatingKey: candidate.plexRatingKey,
-          mediaType: candidate.mediaType,
-          playCount: candidate.playCount,
-          fileSize: candidate.fileSize,
-          filePath: candidate.filePath,
-          reviewStatus: 'PENDING',
-          matchedRules: [{ ruleName: MAINTENANCE_TEST_DATA.RULE.name }],
-          addedAt: new Date(Date.now() - 86400000 * 180), // 180 days ago
-        },
-        update: {
-          title: candidate.title,
-          reviewStatus: 'PENDING',
-        },
-      });
-    }
-    console.log(`[E2E Maintenance Seed] Created ${MAINTENANCE_TEST_DATA.CANDIDATES.length} candidates`);
-
-    // Create a deletion log entry for history tests
-    await client.maintenanceDeletionLog.upsert({
-      where: { id: MAINTENANCE_TEST_DATA.DELETION_LOG.id },
-      create: {
-        id: MAINTENANCE_TEST_DATA.DELETION_LOG.id,
-        title: MAINTENANCE_TEST_DATA.DELETION_LOG.title,
-        year: MAINTENANCE_TEST_DATA.DELETION_LOG.year,
-        mediaType: MAINTENANCE_TEST_DATA.DELETION_LOG.mediaType,
-        fileSize: MAINTENANCE_TEST_DATA.DELETION_LOG.fileSize,
-        deletedBy: 'admin-user-id',
-        deletedAt: new Date(Date.now() - 86400000), // 1 day ago
-        deletedFrom: 'Radarr',
-        filesDeleted: true,
-        ruleNames: [MAINTENANCE_TEST_DATA.RULE.name],
-      },
-      update: {
-        title: MAINTENANCE_TEST_DATA.DELETION_LOG.title,
-      },
-    });
-    console.log('[E2E Maintenance Seed] Created deletion log entry');
-
-    console.log('[E2E Maintenance Seed] Maintenance data seeding complete');
-  } finally {
-    if (!prisma) {
-      await client.$disconnect();
-    }
-  }
-}
-
-/**
- * Cleans up maintenance test data from the database
- * Removes all test rules, scans, candidates, and deletion logs
- */
-export async function cleanupMaintenanceData(prisma?: PrismaClient): Promise<void> {
-  const client = prisma || createE2EPrismaClient();
-
-  try {
-    console.log('[E2E Maintenance Cleanup] Starting maintenance data cleanup...');
-
-    // Delete in order due to foreign key constraints
-    await client.maintenanceCandidate.deleteMany({
-      where: {
-        scanId: MAINTENANCE_TEST_DATA.SCAN.id,
-      },
-    });
-    console.log('[E2E Maintenance Cleanup] Deleted candidates');
-
-    await client.maintenanceScan.deleteMany({
-      where: {
-        id: MAINTENANCE_TEST_DATA.SCAN.id,
-      },
-    });
-    console.log('[E2E Maintenance Cleanup] Deleted scans');
-
-    await client.maintenanceRule.deleteMany({
-      where: {
-        id: MAINTENANCE_TEST_DATA.RULE.id,
-      },
-    });
-    console.log('[E2E Maintenance Cleanup] Deleted rules');
-
-    await client.maintenanceDeletionLog.deleteMany({
-      where: {
-        id: MAINTENANCE_TEST_DATA.DELETION_LOG.id,
-      },
-    });
-    console.log('[E2E Maintenance Cleanup] Deleted deletion logs');
-
-    console.log('[E2E Maintenance Cleanup] Maintenance data cleanup complete');
-  } finally {
-    if (!prisma) {
-      await client.$disconnect();
-    }
-  }
-}
-
-/**
- * Resets candidate review statuses back to PENDING
- * Useful for tests that modify candidate statuses
- */
-export async function resetCandidateStatuses(prisma?: PrismaClient): Promise<void> {
-  const client = prisma || createE2EPrismaClient();
-
-  try {
-    await client.maintenanceCandidate.updateMany({
-      where: {
-        scanId: MAINTENANCE_TEST_DATA.SCAN.id,
-      },
-      data: {
-        reviewStatus: 'PENDING',
-        reviewedAt: null,
-        reviewedBy: null,
-        reviewNote: null,
-      },
-    });
-    console.log('[E2E Maintenance Reset] Reset candidate statuses to PENDING');
-  } finally {
-    if (!prisma) {
-      await client.$disconnect();
-    }
-  }
-}
-
-/**
- * Gets the current state of test candidates
- * Useful for debugging and assertions
- */
-export async function getTestCandidates(prisma?: PrismaClient) {
-  const client = prisma || createE2EPrismaClient();
-
-  try {
-    return await client.maintenanceCandidate.findMany({
-      where: {
-        scanId: MAINTENANCE_TEST_DATA.SCAN.id,
-      },
-      select: {
-        id: true,
-        title: true,
-        reviewStatus: true,
-        reviewedAt: true,
-      },
-    });
-  } finally {
-    if (!prisma) {
-      await client.$disconnect();
-    }
-  }
-}
diff --git a/lib/maintenance/__tests__/client-evaluator.test.ts b/lib/maintenance/__tests__/client-evaluator.test.ts
deleted file mode 100644
index d2e167c6..00000000
--- a/lib/maintenance/__tests__/client-evaluator.test.ts
+++ /dev/null
@@ -1,961 +0,0 @@
-import {
-  evaluateRuleClient,
-  evaluateRuleWithDetails,
-  evaluateMany,
-} from '../client-evaluator'
-import type { RuleCriteria, Condition, ConditionGroup } from '@/lib/validations/maintenance'
-
-describe('client-evaluator', () => {
-  // Base media item for testing
-  const baseItem = {
-    plexRatingKey: '12345',
-    title: 'Test Movie',
-    year: 2020,
-    libraryId: 'lib1',
-    playCount: 5,
-    lastWatchedAt: new Date('2024-01-15').toISOString(),
-    addedAt: new Date('2023-06-01').toISOString(),
-    fileSize: 5368709120, // 5GB in bytes
-    filePath: '/media/movies/test.mkv',
-    resolution: '1080',
-    rating: 7.5,
-    genres: ['Action', 'Thriller'],
-    labels: ['action', 'thriller'],
-    radarr: {
-      hasFile: true,
-      monitored: true,
-      status: 'released',
-      tmdbRating: 8.1,
-      tags: [1, 2, 3],
-    },
-  }
-
-  describe('evaluateRuleClient', () => {
-    describe('single condition evaluation', () => {
-      it('should match string equals condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'title',
-              operator: 'equals',
-              value: 'Test Movie',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match string contains condition (case-insensitive)', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'title',
-              operator: 'contains',
-              value: 'test',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match number equals condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'playCount',
-              operator: 'equals',
-              value: 5,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match number greaterThan condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'playCount',
-              operator: 'greaterThan',
-              value: 3,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match number between condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'rating',
-              operator: 'between',
-              value: [7, 8],
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match boolean equals condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'radarr.monitored',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match array contains condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'genres',
-              operator: 'contains',
-              value: 'Action',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match array containsAny condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'genres',
-              operator: 'containsAny',
-              value: ['Comedy', 'Action'],
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match enum equals condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'resolution',
-              operator: 'equals',
-              value: '1080',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-    })
-
-    describe('computed field - neverWatched', () => {
-      it('should return true when playCount is 0', () => {
-        const item = { ...baseItem, playCount: 0 }
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(item, criteria)).toBe(true)
-      })
-
-      it('should return false when playCount > 0', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(false)
-      })
-    })
-
-    describe('nested field access', () => {
-      it('should access radarr.hasFile', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'radarr.hasFile',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should access radarr.status', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'radarr.status',
-              operator: 'equals',
-              value: 'released',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should access radarr.tmdbRating', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'radarr.tmdbRating',
-              operator: 'greaterThan',
-              value: 8,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should access radarr.tags array', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'radarr.tags',
-              operator: 'contains',
-              value: 2,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-    })
-
-    describe('date comparisons', () => {
-      beforeEach(() => {
-        jest.useFakeTimers()
-        jest.setSystemTime(new Date('2024-06-01'))
-      })
-
-      afterEach(() => {
-        jest.useRealTimers()
-      })
-
-      it('should match olderThan condition', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'lastWatchedAt',
-              operator: 'olderThan',
-              value: 30,
-              valueUnit: 'days',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should match newerThan condition', () => {
-        const item = { ...baseItem, addedAt: new Date('2024-05-15').toISOString() }
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'addedAt',
-              operator: 'newerThan',
-              value: 30,
-              valueUnit: 'days',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(item, criteria)).toBe(true)
-      })
-
-      it('should treat null lastWatchedAt as old for olderThan', () => {
-        const item = { ...baseItem, lastWatchedAt: null }
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'lastWatchedAt',
-              operator: 'olderThan',
-              value: 30,
-              valueUnit: 'days',
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(item, criteria)).toBe(true)
-      })
-    })
-
-    describe('null/notNull operators', () => {
-      it('should match null operator when field is null', () => {
-        const item = { ...baseItem, rating: null }
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'rating',
-              operator: 'null',
-              value: null,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(item, criteria)).toBe(true)
-      })
-
-      it('should match notNull operator when field has value', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'rating',
-              operator: 'notNull',
-              value: null,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-    })
-
-    describe('AND operator', () => {
-      it('should match when all conditions are true', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'playCount',
-              operator: 'greaterThan',
-              value: 3,
-            },
-            {
-              type: 'condition',
-              id: 'c2',
-              field: 'rating',
-              operator: 'greaterThan',
-              value: 7,
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should not match when one condition is false', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'playCount',
-              operator: 'greaterThan',
-              value: 10, // false
-            },
-            {
-              type: 'condition',
-              id: 'c2',
-              field: 'rating',
-              operator: 'greaterThan',
-              value: 7, // true
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(false)
-      })
-    })
-
-    describe('OR operator', () => {
-      it('should match when at least one condition is true', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'OR',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'playCount',
-              operator: 'greaterThan',
-              value: 10, // false
-            },
-            {
-              type: 'condition',
-              id: 'c2',
-              field: 'rating',
-              operator: 'greaterThan',
-              value: 7, // true
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should not match when all conditions are false', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'OR',
-          conditions: [
-            {
-              type: 'condition',
-              id: 'c1',
-              field: 'playCount',
-              operator: 'greaterThan',
-              value: 10, // false
-            },
-            {
-              type: 'condition',
-              id: 'c2',
-              field: 'rating',
-              operator: 'greaterThan',
-              value: 9, // false
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(false)
-      })
-    })
-
-    describe('nested groups', () => {
-      it('should evaluate nested AND within OR', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'OR',
-          conditions: [
-            {
-              type: 'group',
-              id: 'g1',
-              operator: 'AND',
-              conditions: [
-                {
-                  type: 'condition',
-                  id: 'c1',
-                  field: 'playCount',
-                  operator: 'equals',
-                  value: 5, // true
-                },
-                {
-                  type: 'condition',
-                  id: 'c2',
-                  field: 'rating',
-                  operator: 'greaterThan',
-                  value: 7, // true
-                },
-              ],
-            },
-            {
-              type: 'condition',
-              id: 'c3',
-              field: 'year',
-              operator: 'equals',
-              value: 2021, // false
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-
-      it('should evaluate nested OR within AND', () => {
-        const criteria: RuleCriteria = {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'group',
-              id: 'g1',
-              operator: 'OR',
-              conditions: [
-                {
-                  type: 'condition',
-                  id: 'c1',
-                  field: 'playCount',
-                  operator: 'equals',
-                  value: 10, // false
-                },
-                {
-                  type: 'condition',
-                  id: 'c2',
-                  field: 'rating',
-                  operator: 'greaterThan',
-                  value: 7, // true
-                },
-              ],
-            },
-            {
-              type: 'condition',
-              id: 'c3',
-              field: 'year',
-              operator: 'equals',
-              value: 2020, // true
-            },
-          ],
-        }
-
-        expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-      })
-    })
-  })
-
-  describe('evaluateRuleWithDetails', () => {
-    it('should return condition results with actual and expected values', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'playCount',
-            operator: 'equals',
-            value: 5,
-          },
-          {
-            type: 'condition',
-            id: 'c2',
-            field: 'rating',
-            operator: 'greaterThan',
-            value: 9,
-          },
-        ],
-      }
-
-      const result = evaluateRuleWithDetails(baseItem, criteria)
-
-      expect(result.matches).toBe(false)
-      expect(result.conditionResults).toHaveLength(2)
-
-      expect(result.conditionResults[0]).toEqual({
-        conditionId: 'c1',
-        field: 'playCount',
-        fieldLabel: 'Play Count',
-        operator: 'equals',
-        expectedValue: 5,
-        actualValue: 5,
-        passed: true,
-      })
-
-      expect(result.conditionResults[1]).toEqual({
-        conditionId: 'c2',
-        field: 'rating',
-        fieldLabel: 'Rating (User)',
-        operator: 'greaterThan',
-        expectedValue: 9,
-        actualValue: 7.5,
-        passed: false,
-      })
-    })
-
-    it('should collect results from nested groups', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'group',
-            id: 'g1',
-            operator: 'OR',
-            conditions: [
-              {
-                type: 'condition',
-                id: 'c1',
-                field: 'playCount',
-                operator: 'equals',
-                value: 5,
-              },
-            ],
-          },
-          {
-            type: 'condition',
-            id: 'c2',
-            field: 'year',
-            operator: 'equals',
-            value: 2020,
-          },
-        ],
-      }
-
-      const result = evaluateRuleWithDetails(baseItem, criteria)
-
-      expect(result.matches).toBe(true)
-      expect(result.conditionResults).toHaveLength(2)
-      expect(result.conditionResults.every(r => r.passed)).toBe(true)
-    })
-  })
-
-  describe('evaluateMany', () => {
-    const items = [
-      { ...baseItem, plexRatingKey: '1', playCount: 0 },
-      { ...baseItem, plexRatingKey: '2', playCount: 3 },
-      { ...baseItem, plexRatingKey: '3', playCount: 0 },
-      { ...baseItem, plexRatingKey: '4', playCount: 10 },
-    ]
-
-    it('should separate matching and non-matching items', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'neverWatched',
-            operator: 'equals',
-            value: true,
-          },
-        ],
-      }
-
-      const result = evaluateMany(items, criteria)
-
-      expect(result.matches).toHaveLength(2)
-      expect(result.nonMatches).toHaveLength(2)
-      expect(result.matches.map(m => m.plexRatingKey)).toEqual(['1', '3'])
-      expect(result.nonMatches.map(m => m.plexRatingKey)).toEqual(['2', '4'])
-    })
-
-    it('should handle empty items array', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'playCount',
-            operator: 'equals',
-            value: 0,
-          },
-        ],
-      }
-
-      const result = evaluateMany([], criteria)
-
-      expect(result.matches).toHaveLength(0)
-      expect(result.nonMatches).toHaveLength(0)
-    })
-  })
-
-  describe('new Radarr/Sonarr fields', () => {
-    it('should match radarr.status field', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'radarr.status',
-            operator: 'equals',
-            value: 'released',
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-    })
-
-    it('should match radarr.tmdbRating field', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'radarr.tmdbRating',
-            operator: 'greaterThanOrEqual',
-            value: 8,
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-    })
-
-    it('should match radarr.tags array field', () => {
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'radarr.tags',
-            operator: 'containsAny',
-            value: [1, 5, 10],
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(baseItem, criteria)).toBe(true)
-    })
-
-    it('should handle sonarr fields', () => {
-      const tvItem = {
-        ...baseItem,
-        sonarr: {
-          monitored: true,
-          status: 'continuing',
-          seriesType: 'anime',
-          network: 'Netflix',
-          seasonCount: 3,
-          ended: false,
-          tags: [1, 2],
-        },
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'sonarr.seriesType',
-            operator: 'equals',
-            value: 'anime',
-          },
-          {
-            type: 'condition',
-            id: 'c2',
-            field: 'sonarr.seasonCount',
-            operator: 'greaterThanOrEqual',
-            value: 2,
-          },
-          {
-            type: 'condition',
-            id: 'c3',
-            field: 'sonarr.ended',
-            operator: 'equals',
-            value: false,
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(tvItem, criteria)).toBe(true)
-    })
-  })
-
-  describe('computed fields', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-    })
-
-    afterEach(() => {
-      jest.useRealTimers()
-    })
-
-    it('should compute daysSinceAdded correctly', () => {
-      const item = {
-        ...baseItem,
-        addedAt: new Date('2024-05-01').toISOString(), // 31 days ago
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'daysSinceAdded',
-            operator: 'greaterThan',
-            value: 30,
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(item, criteria)).toBe(true)
-    })
-
-    it('should compute daysSinceWatched correctly', () => {
-      const item = {
-        ...baseItem,
-        lastWatchedAt: new Date('2024-05-15').toISOString(), // 17 days ago
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'daysSinceWatched',
-            operator: 'lessThan',
-            value: 30,
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(item, criteria)).toBe(true)
-    })
-
-    it('should return null for daysSinceWatched when never watched', () => {
-      const item = {
-        ...baseItem,
-        lastWatchedAt: null,
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: 'c1',
-            field: 'daysSinceWatched',
-            operator: 'null',
-            value: true,
-          },
-        ],
-      }
-
-      expect(evaluateRuleClient(item, criteria)).toBe(true)
-    })
-  })
-})
diff --git a/lib/maintenance/__tests__/jsdoc-examples.test.ts b/lib/maintenance/__tests__/jsdoc-examples.test.ts
deleted file mode 100644
index 46e611cd..00000000
--- a/lib/maintenance/__tests__/jsdoc-examples.test.ts
+++ /dev/null
@@ -1,391 +0,0 @@
-/**
- * Tests for JSDoc documentation examples
- *
- * These tests verify that the code examples in JSDoc comments remain accurate
- * and continue to work as documented.
- */
-
-import { evaluateRule, calculateComplexity, type MediaItem } from '../rule-evaluator'
-import type { RuleCriteria } from '@/lib/validations/maintenance'
-
-describe('JSDoc Documentation Examples', () => {
-  describe('MediaItem interface example', () => {
-    /**
-     * Tests the MediaItem example from the interface documentation:
-     *
-     * ```ts
-     * const item: MediaItem = {
-     *   plexRatingKey: "12345",
-     *   title: "Example Movie",
-     *   year: 2020,
-     *   playCount: 0,
-     *   lastWatchedAt: null,
-     *   fileSize: BigInt(1500000000),
-     *   radarr: {
-     *     hasFile: true,
-     *     monitored: false
-     *   }
-     * }
-     * ```
-     */
-    it('should accept the documented MediaItem structure', () => {
-      const item: MediaItem = {
-        plexRatingKey: '12345',
-        title: 'Example Movie',
-        year: 2020,
-        playCount: 0,
-        lastWatchedAt: null,
-        fileSize: BigInt(1500000000),
-        radarr: {
-          hasFile: true,
-          monitored: false,
-        },
-      }
-
-      expect(item.plexRatingKey).toBe('12345')
-      expect(item.title).toBe('Example Movie')
-      expect(item.year).toBe(2020)
-      expect(item.playCount).toBe(0)
-      expect(item.lastWatchedAt).toBeNull()
-      expect(item.fileSize).toBe(BigInt(1500000000))
-      expect(item.radarr?.hasFile).toBe(true)
-      expect(item.radarr?.monitored).toBe(false)
-    })
-  })
-
-  describe('evaluateRule function example', () => {
-    /**
-     * Tests the evaluateRule example from the function documentation:
-     *
-     * ```ts
-     * const criteria: RuleCriteria = {
-     *   type: 'group',
-     *   operator: 'AND',
-     *   conditions: [
-     *     { type: 'condition', field: 'playCount', operator: 'equals', value: 0 },
-     *     { type: 'condition', field: 'addedAt', operator: 'olderThan', value: 365, valueUnit: 'days' }
-     *   ]
-     * }
-     *
-     * const matches = evaluateRule(mediaItem, criteria)
-     * if (matches) {
-     *   console.log('Item matches maintenance rule')
-     * }
-     * ```
-     */
-    it('should match item with the documented criteria structure', () => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-
-      const mediaItem: MediaItem = {
-        title: 'Test Movie',
-        playCount: 0,
-        addedAt: new Date('2023-01-01'), // More than 365 days ago
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'addedAt', operator: 'olderThan', value: 365, valueUnit: 'days' },
-        ],
-      }
-
-      const matches = evaluateRule(mediaItem, criteria)
-      expect(matches).toBe(true)
-
-      jest.useRealTimers()
-    })
-
-    it('should not match when criteria is not satisfied', () => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-
-      const mediaItem: MediaItem = {
-        title: 'Test Movie',
-        playCount: 5, // Not zero
-        addedAt: new Date('2023-01-01'),
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'addedAt', operator: 'olderThan', value: 365, valueUnit: 'days' },
-        ],
-      }
-
-      const matches = evaluateRule(mediaItem, criteria)
-      expect(matches).toBe(false)
-
-      jest.useRealTimers()
-    })
-  })
-
-  describe('calculateComplexity function example', () => {
-    /**
-     * Tests the calculateComplexity example from the function documentation:
-     *
-     * ```ts
-     * const complexity = calculateComplexity(ruleCriteria)
-     *
-     * // { conditionCount: 3, groupCount: 2, maxDepth: 1, complexity: 'simple' }
-     * console.log(complexity)
-     *
-     * // Use in UI
-     * <ComplexityBadge level={complexity.complexity} />
-     * ```
-     */
-    it('should return correct complexity metrics for simple rules', () => {
-      const ruleCriteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'rating', operator: 'lessThan', value: 5 },
-          {
-            type: 'group',
-            id: 'g1',
-            operator: 'OR',
-            conditions: [{ type: 'condition', id: 'c3', field: 'year', operator: 'lessThan', value: 2000 }],
-          },
-        ],
-      }
-
-      const complexity = calculateComplexity(ruleCriteria)
-
-      expect(complexity.conditionCount).toBe(3)
-      expect(complexity.groupCount).toBe(2)
-      expect(complexity.maxDepth).toBe(2)
-      expect(complexity.complexity).toBe('simple')
-    })
-
-    it('should categorize moderate complexity correctly', () => {
-      // More than 5 conditions = moderate
-      const conditions = Array.from({ length: 6 }, (_, i) => ({
-        type: 'condition' as const,
-        id: `c${i}`,
-        field: 'playCount',
-        operator: 'equals',
-        value: i,
-      }))
-
-      const ruleCriteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions,
-      }
-
-      const complexity = calculateComplexity(ruleCriteria)
-
-      expect(complexity.conditionCount).toBe(6)
-      expect(complexity.complexity).toBe('moderate')
-    })
-
-    it('should categorize complex rules correctly', () => {
-      // More than 10 conditions = complex
-      const conditions = Array.from({ length: 11 }, (_, i) => ({
-        type: 'condition' as const,
-        id: `c${i}`,
-        field: 'playCount',
-        operator: 'equals',
-        value: i,
-      }))
-
-      const ruleCriteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions,
-      }
-
-      const complexity = calculateComplexity(ruleCriteria)
-
-      expect(complexity.conditionCount).toBe(11)
-      expect(complexity.complexity).toBe('complex')
-    })
-  })
-
-  describe('calculateDateThreshold example', () => {
-    /**
-     * Tests the calculateDateThreshold example from the internal function documentation:
-     *
-     * ```ts
-     * // Get the date 90 days ago
-     * const threshold = calculateDateThreshold(90, 'days')
-     *
-     * // Check if a date is older than 90 days
-     * if (someDate < threshold) {
-     *   console.log('Date is older than 90 days')
-     * }
-     * ```
-     *
-     * Note: calculateDateThreshold is internal, so we test its behavior
-     * through evaluateRule with date conditions.
-     */
-    it('should correctly evaluate dates older than 90 days', () => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-
-      const oldItem: MediaItem = {
-        title: 'Old Movie',
-        lastWatchedAt: new Date('2024-02-01'), // ~120 days ago
-      }
-
-      const recentItem: MediaItem = {
-        title: 'Recent Movie',
-        lastWatchedAt: new Date('2024-05-01'), // ~31 days ago
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'lastWatchedAt', operator: 'olderThan', value: 90, valueUnit: 'days' },
-        ],
-      }
-
-      expect(evaluateRule(oldItem, criteria)).toBe(true)
-      expect(evaluateRule(recentItem, criteria)).toBe(false)
-
-      jest.useRealTimers()
-    })
-  })
-
-  describe('scanForCandidates example (documented pattern)', () => {
-    /**
-     * Tests the pattern documented in scanForCandidates:
-     *
-     * ```ts
-     * // Basic scan
-     * const result = await scanForCandidates(ruleId)
-     * if (result.status === 'COMPLETED') {
-     *   console.log(`Found ${result.itemsFlagged} candidates`)
-     * }
-     *
-     * // With progress callback
-     * const result = await scanForCandidates(ruleId, (percent) => {
-     *   updateProgressBar(percent)
-     * })
-     * ```
-     *
-     * Note: Since scanForCandidates requires database and Tautulli mocking,
-     * we test the pattern using evaluateRule which it calls internally.
-     */
-    it('should demonstrate the rule evaluation pattern used in scanning', () => {
-      // This simulates what scanForCandidates does internally
-      const mediaItems: MediaItem[] = [
-        { title: 'Movie 1', playCount: 0 },
-        { title: 'Movie 2', playCount: 5 },
-        { title: 'Movie 3', playCount: 0 },
-      ]
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [{ type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 }],
-      }
-
-      // Simulate the scanning loop
-      const matchedItems = mediaItems.filter((item) => evaluateRule(item, criteria))
-
-      expect(matchedItems.length).toBe(2)
-      expect(matchedItems[0].title).toBe('Movie 1')
-      expect(matchedItems[1].title).toBe('Movie 3')
-    })
-  })
-
-  describe('Hierarchical criteria tree example', () => {
-    /**
-     * Tests the tree structure documented in the module JSDoc:
-     *
-     * ```
-     *          GROUP (AND)
-     *         /    |     \
-     *    cond1  cond2   GROUP (OR)
-     *                   /        \
-     *               cond3      cond4
-     * ```
-     *
-     * For the above tree:
-     * - First, cond3 and cond4 are evaluated and combined with OR
-     * - Then cond1, cond2, and the OR result are combined with AND
-     */
-    it('should correctly evaluate nested AND/OR tree structure', () => {
-      const item: MediaItem = {
-        title: 'Test Movie',
-        playCount: 0, // cond1: true
-        rating: 5, // cond2: true
-        year: 2019, // cond3: false
-        resolution: '4K', // cond4: true
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'rating', operator: 'lessThanOrEqual', value: 7 },
-          {
-            type: 'group',
-            id: 'g1',
-            operator: 'OR',
-            conditions: [
-              { type: 'condition', id: 'c3', field: 'year', operator: 'lessThan', value: 2010 },
-              { type: 'condition', id: 'c4', field: 'resolution', operator: 'equals', value: '4K' },
-            ],
-          },
-        ],
-      }
-
-      // cond1: true (playCount = 0)
-      // cond2: true (rating 5 <= 7)
-      // cond3: false (year 2019 is not < 2010)
-      // cond4: true (resolution is '4K')
-      // OR group: true (cond3 OR cond4 = false OR true = true)
-      // AND result: true AND true AND true = true
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should fail when AND condition in nested tree fails', () => {
-      const item: MediaItem = {
-        title: 'Test Movie',
-        playCount: 5, // cond1: false (breaks AND)
-        rating: 5, // cond2: true
-        year: 2019, // cond3: false
-        resolution: '4K', // cond4: true
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'rating', operator: 'lessThanOrEqual', value: 7 },
-          {
-            type: 'group',
-            id: 'g1',
-            operator: 'OR',
-            conditions: [
-              { type: 'condition', id: 'c3', field: 'year', operator: 'lessThan', value: 2010 },
-              { type: 'condition', id: 'c4', field: 'resolution', operator: 'equals', value: '4K' },
-            ],
-          },
-        ],
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-})
diff --git a/lib/maintenance/__tests__/rule-evaluator.test.ts b/lib/maintenance/__tests__/rule-evaluator.test.ts
deleted file mode 100644
index abd07f0d..00000000
--- a/lib/maintenance/__tests__/rule-evaluator.test.ts
+++ /dev/null
@@ -1,1084 +0,0 @@
-import { evaluateRule } from '../rule-evaluator'
-import type { MediaItem } from '../rule-evaluator'
-import type { RuleCriteria } from '@/lib/validations/maintenance'
-
-describe('evaluateRule', () => {
-  const baseMediaItem: MediaItem = {
-    plexRatingKey: '12345',
-    title: 'Test Movie',
-    year: 2020,
-    libraryId: 'lib1',
-    playCount: 5,
-    lastWatchedAt: new Date('2024-01-15'),
-    addedAt: new Date('2023-06-01'),
-    fileSize: BigInt(5368709120), // 5GB in bytes
-    filePath: '/media/movies/test.mkv',
-    resolution: '1080p',
-    rating: 7.5,
-    labels: ['action', 'thriller'],
-  }
-
-  describe('neverWatched criteria', () => {
-    it('should match when neverWatched is true and playCount is 0', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 0 }
-      const criteria: RuleCriteria = { neverWatched: true, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when neverWatched is true and playCount is greater than 0', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 3 }
-      const criteria: RuleCriteria = { neverWatched: true, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when neverWatched is false and playCount is greater than 0', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 5 }
-      const criteria: RuleCriteria = { neverWatched: false, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when neverWatched is false and playCount is 0', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 0 }
-      const criteria: RuleCriteria = { neverWatched: false, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('lastWatchedBefore criteria', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-    })
-
-    afterEach(() => {
-      jest.useRealTimers()
-    })
-
-    it('should match when last watched before specified days', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2024-05-01'), // 31 days ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when last watched after specified days', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2024-05-28'), // 4 days ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when last watched before specified months', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2024-03-01'), // ~3 months ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 2, unit: 'months' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when last watched after specified months', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2024-05-15'), // ~0.5 months ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 2, unit: 'months' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when last watched before specified years', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2022-01-01'), // ~2.4 years ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 2, unit: 'years' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when last watched after specified years', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2023-12-01'), // ~0.5 years ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 2, unit: 'years' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when lastWatchedAt is null (never watched)', () => {
-      const item: MediaItem = { ...baseMediaItem, lastWatchedAt: null }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when lastWatchedAt is undefined (never watched)', () => {
-      const item: MediaItem = { ...baseMediaItem, lastWatchedAt: undefined }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-  })
-
-  describe('maxPlayCount criteria', () => {
-    it('should match when playCount is below max', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 3 }
-      const criteria: RuleCriteria = { maxPlayCount: 5, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when playCount equals max', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 5 }
-      const criteria: RuleCriteria = { maxPlayCount: 5, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when playCount exceeds max', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 10 }
-      const criteria: RuleCriteria = { maxPlayCount: 5, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when playCount is 0 and max is 0', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 0 }
-      const criteria: RuleCriteria = { maxPlayCount: 0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when playCount is 1 and max is 0', () => {
-      const item: MediaItem = { ...baseMediaItem, playCount: 1 }
-      const criteria: RuleCriteria = { maxPlayCount: 0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('addedBefore criteria', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-    })
-
-    afterEach(() => {
-      jest.useRealTimers()
-    })
-
-    it('should match when added before specified days', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        addedAt: new Date('2024-04-01'), // ~61 days ago
-      }
-      const criteria: RuleCriteria = {
-        addedBefore: { value: 60, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when added after specified days', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        addedAt: new Date('2024-05-25'), // ~7 days ago
-      }
-      const criteria: RuleCriteria = {
-        addedBefore: { value: 60, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when added before specified months', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        addedAt: new Date('2023-12-01'), // ~6 months ago
-      }
-      const criteria: RuleCriteria = {
-        addedBefore: { value: 3, unit: 'months' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when added before specified years', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        addedAt: new Date('2021-01-01'), // ~3.4 years ago
-      }
-      const criteria: RuleCriteria = {
-        addedBefore: { value: 2, unit: 'years' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when addedAt is null', () => {
-      const item: MediaItem = { ...baseMediaItem, addedAt: null }
-      const criteria: RuleCriteria = {
-        addedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when addedAt is undefined', () => {
-      const item: MediaItem = { ...baseMediaItem, addedAt: undefined }
-      const criteria: RuleCriteria = {
-        addedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('minFileSize criteria', () => {
-    it('should match when file size meets minimum in MB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 500), // 500MB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 400, unit: 'MB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when file size equals minimum in MB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 500), // 500MB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 500, unit: 'MB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when file size is below minimum in MB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 300), // 300MB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 500, unit: 'MB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when file size meets minimum in GB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 1024 * 10), // 10GB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 5, unit: 'GB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when file size is below minimum in GB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 1024 * 3), // 3GB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 5, unit: 'GB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when file size meets minimum in TB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024) * BigInt(1024) * BigInt(1024) * BigInt(1024) * BigInt(2), // 2TB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 1, unit: 'TB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when file size is below minimum in TB', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 1024 * 500), // 500GB
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 1, unit: 'TB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when fileSize is null', () => {
-      const item: MediaItem = { ...baseMediaItem, fileSize: null }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 1, unit: 'GB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when fileSize is undefined', () => {
-      const item: MediaItem = { ...baseMediaItem, fileSize: undefined }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 1, unit: 'GB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('maxQuality criteria', () => {
-    it('should match when quality is below max (alphabetically)', () => {
-      const item: MediaItem = { ...baseMediaItem, resolution: '1080p' }
-      const criteria: RuleCriteria = { maxQuality: '720p', operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when quality equals max', () => {
-      const item: MediaItem = { ...baseMediaItem, resolution: '1080p' }
-      const criteria: RuleCriteria = { maxQuality: '1080p', operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when quality exceeds max (alphabetically)', () => {
-      const item: MediaItem = { ...baseMediaItem, resolution: '720p' }
-      const criteria: RuleCriteria = { maxQuality: '1080p', operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when quality is null', () => {
-      const item: MediaItem = { ...baseMediaItem, resolution: null }
-      const criteria: RuleCriteria = { maxQuality: '1080p', operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when quality is undefined', () => {
-      const item: MediaItem = { ...baseMediaItem, resolution: undefined }
-      const criteria: RuleCriteria = { maxQuality: '1080p', operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('maxRating criteria', () => {
-    it('should match when rating is below max', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: 5.0 }
-      const criteria: RuleCriteria = { maxRating: 7.0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when rating equals max', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: 7.0 }
-      const criteria: RuleCriteria = { maxRating: 7.0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when rating exceeds max', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: 9.0 }
-      const criteria: RuleCriteria = { maxRating: 7.0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when rating is 0 and max is 0', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: 0 }
-      const criteria: RuleCriteria = { maxRating: 0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when rating is 10 and max is 10', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: 10 }
-      const criteria: RuleCriteria = { maxRating: 10, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when rating is null', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: null }
-      const criteria: RuleCriteria = { maxRating: 7.0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when rating is undefined', () => {
-      const item: MediaItem = { ...baseMediaItem, rating: undefined }
-      const criteria: RuleCriteria = { maxRating: 7.0, operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('libraryIds criteria', () => {
-    it('should match when item libraryId is in the list', () => {
-      const item: MediaItem = { ...baseMediaItem, libraryId: 'lib1' }
-      const criteria: RuleCriteria = {
-        libraryIds: ['lib1', 'lib2', 'lib3'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when item libraryId is not in the list', () => {
-      const item: MediaItem = { ...baseMediaItem, libraryId: 'lib5' }
-      const criteria: RuleCriteria = {
-        libraryIds: ['lib1', 'lib2', 'lib3'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when libraryId matches single-item list', () => {
-      const item: MediaItem = { ...baseMediaItem, libraryId: 'lib1' }
-      const criteria: RuleCriteria = {
-        libraryIds: ['lib1'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when libraryId is null', () => {
-      const item: MediaItem = { ...baseMediaItem, libraryId: undefined }
-      const criteria: RuleCriteria = {
-        libraryIds: ['lib1', 'lib2'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when libraryId is undefined', () => {
-      const item: MediaItem = { ...baseMediaItem, libraryId: undefined }
-      const criteria: RuleCriteria = {
-        libraryIds: ['lib1', 'lib2'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should handle empty libraryIds array by ignoring criteria', () => {
-      const item: MediaItem = { ...baseMediaItem, libraryId: 'lib1' }
-      const criteria: RuleCriteria = {
-        libraryIds: [],
-        operator: 'AND',
-      }
-
-      // Empty criteria array should result in no evaluation
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('tags criteria', () => {
-    it('should match when item has at least one matching tag', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        labels: ['action', 'thriller', 'drama'],
-      }
-      const criteria: RuleCriteria = {
-        tags: ['action', 'comedy'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when item has all matching tags', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        labels: ['action', 'thriller', 'drama'],
-      }
-      const criteria: RuleCriteria = {
-        tags: ['action', 'thriller'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when item has no matching tags', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        labels: ['action', 'thriller'],
-      }
-      const criteria: RuleCriteria = {
-        tags: ['comedy', 'romance'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when single tag matches', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        labels: ['action'],
-      }
-      const criteria: RuleCriteria = {
-        tags: ['action'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when item tags is null', () => {
-      const item: MediaItem = { ...baseMediaItem, labels: undefined }
-      const criteria: RuleCriteria = {
-        tags: ['action', 'thriller'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when item tags is empty array', () => {
-      const item: MediaItem = { ...baseMediaItem, labels: [] }
-      const criteria: RuleCriteria = {
-        tags: ['action', 'thriller'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should handle empty tags criteria by ignoring it', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        labels: ['action', 'thriller'],
-      }
-      const criteria: RuleCriteria = {
-        tags: [],
-        operator: 'AND',
-      }
-
-      // Empty criteria array should result in no evaluation
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-  })
-
-  describe('operator logic - AND', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-    })
-
-    afterEach(() => {
-      jest.useRealTimers()
-    })
-
-    it('should match when all criteria are satisfied with AND operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 2,
-        lastWatchedAt: new Date('2024-01-01'), // ~5 months ago
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when one criterion fails with AND operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 10, // Exceeds maxPlayCount
-        lastWatchedAt: new Date('2024-01-01'),
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should not match when multiple criteria fail with AND operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 10, // Exceeds maxPlayCount
-        lastWatchedAt: new Date('2024-05-20'), // Recent (fails lastWatchedBefore)
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should default to AND operator when not specified', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 2,
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        maxRating: 7.0,
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-  })
-
-  describe('operator logic - OR', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-    })
-
-    afterEach(() => {
-      jest.useRealTimers()
-    })
-
-    it('should match when all criteria are satisfied with OR operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 2,
-        lastWatchedAt: new Date('2024-01-01'), // ~5 months ago
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'OR',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match when at least one criterion is satisfied with OR operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 10, // Exceeds maxPlayCount
-        lastWatchedAt: new Date('2024-01-01'), // ~5 months ago (satisfies lastWatchedBefore)
-        rating: 9.0, // Exceeds maxRating
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'OR',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when no criteria are satisfied with OR operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 10, // Exceeds maxPlayCount
-        lastWatchedAt: new Date('2024-05-20'), // Recent (fails lastWatchedBefore)
-        rating: 9.0, // Exceeds maxRating
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'OR',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match when only first criterion is satisfied with OR operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 2, // Satisfies maxPlayCount
-        lastWatchedAt: new Date('2024-05-20'), // Recent
-        rating: 9.0, // Exceeds maxRating
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        lastWatchedBefore: { value: 3, unit: 'months' },
-        maxRating: 7.0,
-        operator: 'OR',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-  })
-
-  describe('multiple criteria combinations', () => {
-    beforeEach(() => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01'))
-    })
-
-    afterEach(() => {
-      jest.useRealTimers()
-    })
-
-    it('should match complex AND criteria for old unwatched content', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 0,
-        addedAt: new Date('2022-01-01'), // ~2.4 years ago
-        libraryId: 'movies',
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: true,
-        addedBefore: { value: 2, unit: 'years' },
-        libraryIds: ['movies', 'tv-shows'],
-        maxRating: 6.0,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should match complex OR criteria for quality or size', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt(1024 * 1024 * 1024 * 10), // 10GB
-        quality: '1080p',
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 5, unit: 'GB' },
-        maxQuality: '720p',
-        operator: 'OR',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should not match when complex AND criteria has one failure', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 0,
-        addedAt: new Date('2022-01-01'),
-        libraryId: 'music', // Not in allowed libraries
-        rating: 5.0,
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: true,
-        addedBefore: { value: 2, unit: 'years' },
-        libraryIds: ['movies', 'tv-shows'],
-        maxRating: 6.0,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should match criteria combining temporal and tag filters', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2023-01-01'), // ~1.4 years ago
-        labels: ['anime', 'action'],
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 1, unit: 'years' },
-        tags: ['anime'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle all criteria types together with AND', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 1,
-        lastWatchedAt: new Date('2023-01-01'),
-        addedAt: new Date('2022-01-01'),
-        fileSize: BigInt(1024 * 1024 * 1024 * 8),
-        resolution: '1080p',
-        rating: 6.0,
-        libraryId: 'movies',
-        labels: ['action'],
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: false,
-        maxPlayCount: 2,
-        lastWatchedBefore: { value: 1, unit: 'years' },
-        addedBefore: { value: 1, unit: 'years' },
-        minFileSize: { value: 5, unit: 'GB' },
-        maxQuality: '720p',
-        maxRating: 7.0,
-        libraryIds: ['movies'],
-        tags: ['action', 'drama'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle all criteria types together with OR', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 10, // Fails maxPlayCount
-        lastWatchedAt: new Date('2024-05-20'), // Fails lastWatchedBefore
-        addedAt: new Date('2024-05-01'), // Fails addedBefore
-        fileSize: BigInt(1024 * 1024 * 100), // Fails minFileSize
-        resolution: '720p', // Fails maxQuality (alphabetically > '1080p')
-        rating: 9.0, // Fails maxRating
-        libraryId: 'music', // Fails libraryIds
-        labels: ['action'], // Satisfies tags
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: true,
-        maxPlayCount: 2,
-        lastWatchedBefore: { value: 1, unit: 'years' },
-        addedBefore: { value: 1, unit: 'years' },
-        minFileSize: { value: 5, unit: 'GB' },
-        maxQuality: '1080p',
-        maxRating: 7.0,
-        libraryIds: ['movies'],
-        tags: ['action'],
-        operator: 'OR',
-      }
-
-      // Should match because tags criterion is satisfied
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-  })
-
-  describe('edge cases', () => {
-    it('should return false when no criteria are provided', () => {
-      const item: MediaItem = { ...baseMediaItem }
-      const criteria: RuleCriteria = { operator: 'AND' }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should handle item with all null optional fields', () => {
-      const item: MediaItem = {
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        playCount: 0,
-        lastWatchedAt: null,
-        addedAt: null,
-        fileSize: null,
-        quality: null,
-        rating: null,
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: true,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle item with all undefined optional fields', () => {
-      const item: MediaItem = {
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        playCount: 0,
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: true,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should fail safely when null values are checked against non-existence criteria', () => {
-      const item: MediaItem = {
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        playCount: 0,
-        fileSize: null,
-        quality: null,
-        rating: null,
-        libraryId: undefined,
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 1, unit: 'GB' },
-        maxQuality: '1080p',
-        maxRating: 7.0,
-        libraryIds: ['movies'],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should handle very large file sizes', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        fileSize: BigInt('999999999999999999'), // Very large number
-      }
-      const criteria: RuleCriteria = {
-        minFileSize: { value: 1, unit: 'TB' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle playCount of 0 with various criteria', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 0,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 0,
-        neverWatched: true,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle boundary values for rating', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        rating: 0,
-      }
-      const criteria: RuleCriteria = {
-        maxRating: 0,
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle dates at exact threshold boundary', () => {
-      jest.useFakeTimers()
-      jest.setSystemTime(new Date('2024-06-01T00:00:00Z'))
-
-      const item: MediaItem = {
-        ...baseMediaItem,
-        lastWatchedAt: new Date('2024-05-02T00:00:00Z'), // Exactly 30 days ago
-      }
-      const criteria: RuleCriteria = {
-        lastWatchedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-
-      jest.useRealTimers()
-    })
-
-    it('should handle empty tags array in both item and criteria', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        labels: [],
-      }
-      const criteria: RuleCriteria = {
-        tags: [],
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(false)
-    })
-
-    it('should handle single criterion with OR operator', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 3,
-      }
-      const criteria: RuleCriteria = {
-        maxPlayCount: 5,
-        operator: 'OR',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-
-    it('should handle neverWatched with null lastWatchedAt', () => {
-      const item: MediaItem = {
-        ...baseMediaItem,
-        playCount: 0,
-        lastWatchedAt: null,
-      }
-      const criteria: RuleCriteria = {
-        neverWatched: true,
-        lastWatchedBefore: { value: 30, unit: 'days' },
-        operator: 'AND',
-      }
-
-      expect(evaluateRule(item, criteria)).toBe(true)
-    })
-  })
-})
diff --git a/lib/maintenance/__tests__/scan-evaluate-flag-integration.test.ts b/lib/maintenance/__tests__/scan-evaluate-flag-integration.test.ts
deleted file mode 100644
index 07b92cc4..00000000
--- a/lib/maintenance/__tests__/scan-evaluate-flag-integration.test.ts
+++ /dev/null
@@ -1,631 +0,0 @@
-/**
- * Integration tests for the complete scan → evaluate → flag flow
- *
- * Tests the end-to-end maintenance scanning pipeline:
- * 1. Scanner fetches media from Tautulli
- * 2. Rule evaluator checks each item against criteria
- * 3. Matching items are flagged as maintenance candidates
- */
-
-import { scanForCandidates } from '../scanner'
-import { evaluateRule } from '../rule-evaluator'
-import type { MediaItem } from '../rule-evaluator'
-import { getTautulliLibraryMediaInfo } from '@/lib/connections/tautulli'
-import { prisma } from '@/lib/prisma'
-
-// Mock dependencies
-jest.mock('@/lib/prisma', () => ({
-  prisma: {
-    maintenanceRule: {
-      findUnique: jest.fn(),
-      update: jest.fn(),
-    },
-    maintenanceScan: {
-      create: jest.fn(),
-      update: jest.fn(),
-    },
-    maintenanceCandidate: {
-      create: jest.fn(),
-    },
-    tautulli: {
-      findFirst: jest.fn(),
-    },
-  },
-}))
-
-jest.mock('@/lib/connections/tautulli', () => ({
-  getTautulliLibraryMediaInfo: jest.fn(),
-}))
-
-jest.mock('@/lib/utils/logger', () => ({
-  createLogger: () => ({
-    info: jest.fn(),
-    debug: jest.fn(),
-    error: jest.fn(),
-    warn: jest.fn(),
-  }),
-}))
-
-describe('Scan → Evaluate → Flag Integration', () => {
-  const mockRuleId = 'rule-integration-test'
-  const mockScanId = 'scan-integration-test'
-
-  const mockTautulliServer = {
-    name: 'Tautulli',
-    url: 'http://localhost:8181',
-    apiKey: 'test-api-key',
-    publicUrl: null,
-    isActive: true,
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-    jest.useFakeTimers()
-    jest.setSystemTime(new Date('2024-06-01'))
-  })
-
-  afterEach(() => {
-    jest.useRealTimers()
-  })
-
-  describe('Rule evaluation integration with scanner', () => {
-    it('should correctly evaluate and flag items matching never watched + old criteria', async () => {
-      // Hierarchical criteria: never watched AND added more than 180 days ago
-      // Note: libraryIds must be at top level of criteria for scanner to find libraries
-      const criteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'addedAt', operator: 'olderThan', value: 180, valueUnit: 'days' },
-        ],
-        libraryIds: ['lib-1'], // Required at top level for scanner
-      }
-
-      const mockRule = {
-        id: mockRuleId,
-        name: 'Integration Test Rule',
-        description: 'Test never watched + old items',
-        enabled: true,
-        mediaType: 'MOVIE' as const,
-        criteria,
-        actionType: 'FLAG_FOR_REVIEW',
-      }
-
-      const mockScan = {
-        id: mockScanId,
-        ruleId: mockRuleId,
-        status: 'RUNNING',
-        startedAt: new Date(),
-      }
-
-      // Mock Tautulli response with various movies
-      const mockMovies = [
-        {
-          rating_key: '1',
-          title: 'Old Unwatched Movie',
-          year: 2020,
-          play_count: 0, // Never watched
-          last_played: null,
-          added_at: 1609459200, // 2021-01-01 (more than 180 days ago)
-          file_size: 1073741824,
-          file: '/movies/old-unwatched.mkv',
-          radarr_id: 100,
-          tmdb_id: 200,
-          thumb: '/poster1.jpg',
-        },
-        {
-          rating_key: '2',
-          title: 'Recently Added Unwatched',
-          year: 2024,
-          play_count: 0, // Never watched but recently added
-          last_played: null,
-          added_at: 1714521600, // 2024-05-01 (about 31 days ago)
-          file_size: 2147483648,
-          file: '/movies/recent-unwatched.mkv',
-          radarr_id: 101,
-          tmdb_id: 201,
-          thumb: '/poster2.jpg',
-        },
-        {
-          rating_key: '3',
-          title: 'Old Watched Movie',
-          year: 2020,
-          play_count: 5, // Watched
-          last_played: 1640995200,
-          added_at: 1609459200, // 2021-01-01
-          file_size: 3221225472,
-          file: '/movies/old-watched.mkv',
-          radarr_id: 102,
-          tmdb_id: 202,
-          thumb: '/poster3.jpg',
-        },
-      ]
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: { data: mockMovies },
-          },
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-
-      const createdCandidates: unknown[] = []
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) => {
-        createdCandidates.push(data.data)
-        return Promise.resolve({ id: `candidate-${createdCandidates.length}`, ...data.data })
-      })
-
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute the scan
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify results
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsScanned).toBe(3)
-      expect(result.itemsFlagged).toBe(1)
-
-      // Only the old unwatched movie should be flagged
-      expect(createdCandidates).toHaveLength(1)
-      expect(createdCandidates[0]).toMatchObject({
-        title: 'Old Unwatched Movie',
-        plexRatingKey: '1',
-        playCount: 0,
-        reviewStatus: 'PENDING',
-      })
-    })
-
-    it('should correctly handle OR conditions in hierarchical criteria', async () => {
-      // Hierarchical criteria: never watched OR year before 2015
-      // (using fields that scanner actually maps)
-      const criteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'OR',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          { type: 'condition', id: 'c2', field: 'year', operator: 'lessThan', value: 2015 },
-        ],
-        libraryIds: ['lib-1'], // Required at top level for scanner
-      }
-
-      const mockRule = {
-        id: mockRuleId,
-        name: 'OR Condition Test Rule',
-        enabled: true,
-        mediaType: 'MOVIE' as const,
-        criteria,
-        actionType: 'FLAG_FOR_REVIEW',
-      }
-
-      const mockMovies = [
-        {
-          rating_key: '1',
-          title: 'Unwatched New Movie',
-          year: 2023,
-          play_count: 0, // Matches: never watched
-          added_at: 1609459200,
-          file_size: 1073741824,
-          file: '/movies/1.mkv',
-        },
-        {
-          rating_key: '2',
-          title: 'Watched Old Movie',
-          year: 2010, // Matches: year < 2015
-          play_count: 3,
-          added_at: 1609459200,
-          file_size: 1073741824,
-          file: '/movies/2.mkv',
-        },
-        {
-          rating_key: '3',
-          title: 'Watched New Movie',
-          year: 2023, // Does not match: watched AND year >= 2015
-          play_count: 5,
-          added_at: 1609459200,
-          file_size: 1073741824,
-          file: '/movies/3.mkv',
-        },
-      ]
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: { data: mockMovies },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-
-      const createdCandidates: unknown[] = []
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) => {
-        createdCandidates.push(data.data)
-        return Promise.resolve({ id: `candidate-${createdCandidates.length}`, ...data.data })
-      })
-
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsFlagged).toBe(2) // Unwatched + Low rating
-
-      const flaggedTitles = createdCandidates.map((c: any) => c.title)
-      expect(flaggedTitles).toContain('Unwatched New Movie')
-      expect(flaggedTitles).toContain('Watched Old Movie')
-      expect(flaggedTitles).not.toContain('Watched New Movie')
-    })
-
-    it('should correctly handle nested AND/OR groups', async () => {
-      // Complex criteria: (never watched AND old) OR (low play count AND old year)
-      // Using fields that scanner actually maps
-      const criteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'OR',
-        conditions: [
-          {
-            type: 'group',
-            id: 'g1',
-            operator: 'AND',
-            conditions: [
-              { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-              { type: 'condition', id: 'c2', field: 'addedAt', operator: 'olderThan', value: 365, valueUnit: 'days' },
-            ],
-          },
-          {
-            type: 'group',
-            id: 'g2',
-            operator: 'AND',
-            conditions: [
-              { type: 'condition', id: 'c3', field: 'playCount', operator: 'lessThanOrEqual', value: 2 },
-              { type: 'condition', id: 'c4', field: 'year', operator: 'lessThan', value: 2010 },
-            ],
-          },
-        ],
-        libraryIds: ['lib-1'], // Required at top level for scanner
-      }
-
-      const mockRule = {
-        id: mockRuleId,
-        name: 'Nested Groups Test Rule',
-        enabled: true,
-        mediaType: 'MOVIE' as const,
-        criteria,
-        actionType: 'FLAG_FOR_REVIEW',
-      }
-
-      const mockMovies = [
-        {
-          rating_key: '1',
-          title: 'Old Unwatched',
-          year: 2020,
-          play_count: 0,
-          added_at: 1577836800, // 2020-01-01 (more than 365 days ago)
-          file_size: 1073741824,
-          file: '/movies/1.mkv',
-        },
-        {
-          rating_key: '2',
-          title: 'Low Plays Old Year',
-          year: 2005, // year < 2010
-          play_count: 1, // play_count <= 2
-          added_at: 1714521600, // Recent
-          file_size: 1073741824,
-          file: '/movies/2.mkv',
-        },
-        {
-          rating_key: '3',
-          title: 'Many Plays Old Year',
-          year: 2005,
-          play_count: 10, // Fails: too many plays for second group
-          added_at: 1714521600,
-          file_size: 1073741824,
-          file: '/movies/3.mkv',
-        },
-        {
-          rating_key: '4',
-          title: 'Low Plays New Year',
-          year: 2023, // Fails: year too new for second group
-          play_count: 1,
-          added_at: 1714521600,
-          file_size: 1073741824,
-          file: '/movies/4.mkv',
-        },
-        {
-          rating_key: '5',
-          title: 'Recent Unwatched',
-          year: 2023,
-          play_count: 0,
-          added_at: 1714521600, // Recent - fails first group (not old enough)
-          file_size: 1073741824,
-          file: '/movies/5.mkv',
-        },
-      ]
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: { data: mockMovies },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-
-      const createdCandidates: unknown[] = []
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) => {
-        createdCandidates.push(data.data)
-        return Promise.resolve({ id: `candidate-${createdCandidates.length}`, ...data.data })
-      })
-
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsFlagged).toBe(2)
-
-      const flaggedTitles = createdCandidates.map((c: any) => c.title)
-      expect(flaggedTitles).toContain('Old Unwatched') // Matches first group
-      expect(flaggedTitles).toContain('Low Plays Old Year') // Matches second group
-      expect(flaggedTitles).not.toContain('Many Plays Old Year') // Fails play count check
-      expect(flaggedTitles).not.toContain('Low Plays New Year') // Fails year check
-      expect(flaggedTitles).not.toContain('Recent Unwatched') // Fails old check
-    })
-  })
-
-  describe('TV series evaluation integration', () => {
-    it('should correctly evaluate TV series with never watched criteria', async () => {
-      const criteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-        ],
-        libraryIds: ['lib-tv-1'], // Required at top level for scanner
-      }
-
-      const mockRule = {
-        id: mockRuleId,
-        name: 'TV Series Test Rule',
-        enabled: true,
-        mediaType: 'TV_SERIES' as const,
-        criteria,
-        actionType: 'FLAG_FOR_REVIEW',
-      }
-
-      const mockSeries = [
-        {
-          rating_key: '10',
-          title: 'Unwatched Series',
-          year: 2020,
-          play_count: 0,
-          last_played: null,
-          added_at: 1609459200,
-          file_size: 10737418240,
-          file: '/tv/unwatched-series',
-          sonarr_id: 300,
-          tvdb_id: 400,
-          thumb: '/poster10.jpg',
-        },
-        {
-          rating_key: '11',
-          title: 'Watched Series',
-          year: 2021,
-          play_count: 20,
-          last_played: 1640995200,
-          added_at: 1609459200,
-          file_size: 21474836480,
-          file: '/tv/watched-series',
-          sonarr_id: 301,
-          tvdb_id: 401,
-          thumb: '/poster11.jpg',
-        },
-      ]
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: { data: mockSeries },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-
-      const createdCandidates: unknown[] = []
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) => {
-        createdCandidates.push(data.data)
-        return Promise.resolve({ id: `candidate-${createdCandidates.length}`, ...data.data })
-      })
-
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsFlagged).toBe(1)
-
-      expect(createdCandidates[0]).toMatchObject({
-        title: 'Unwatched Series',
-        mediaType: 'TV_SERIES',
-        sonarrId: 300,
-        tvdbId: 400,
-      })
-    })
-  })
-
-  describe('Progress callback integration', () => {
-    it('should report progress during scan with hierarchical criteria', async () => {
-      const criteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-        ],
-        libraryIds: ['lib-1'], // Required at top level for scanner
-      }
-
-      const mockRule = {
-        id: mockRuleId,
-        name: 'Progress Test Rule',
-        enabled: true,
-        mediaType: 'MOVIE' as const,
-        criteria,
-        actionType: 'FLAG_FOR_REVIEW',
-      }
-
-      // Create 25 mock movies to trigger multiple progress updates
-      const mockMovies = Array.from({ length: 25 }, (_, i) => ({
-        rating_key: String(i + 1),
-        title: `Movie ${i + 1}`,
-        play_count: i % 3, // Some watched, some not
-        added_at: 1609459200,
-        file_size: 1073741824,
-        file: `/movies/${i + 1}.mkv`,
-      }))
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: { data: mockMovies },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockResolvedValue({})
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      const progressUpdates: number[] = []
-      const onProgress = jest.fn((percent: number) => {
-        progressUpdates.push(percent)
-      })
-
-      await scanForCandidates(mockRuleId, onProgress)
-
-      // Should have progress updates every 10 items
-      expect(onProgress).toHaveBeenCalled()
-      expect(progressUpdates.length).toBeGreaterThan(0)
-
-      // Progress should be monotonically increasing
-      for (let i = 1; i < progressUpdates.length; i++) {
-        expect(progressUpdates[i]).toBeGreaterThanOrEqual(progressUpdates[i - 1])
-      }
-    })
-  })
-
-  describe('Direct rule evaluator integration', () => {
-    it('should correctly transform and evaluate Tautulli data format', () => {
-      // Simulate the data transformation that happens in scanner
-      const tautulliData = {
-        rating_key: '1',
-        title: 'Test Movie',
-        year: 2020,
-        play_count: 0,
-        last_played: null,
-        added_at: 1609459200, // Unix timestamp
-        file_size: 1073741824,
-        file: '/movies/test.mkv',
-      }
-
-      // Transform like scanner does
-      const mediaItem: MediaItem = {
-        plexRatingKey: String(tautulliData.rating_key),
-        title: tautulliData.title,
-        year: tautulliData.year,
-        playCount: Number(tautulliData.play_count || 0),
-        lastWatchedAt: tautulliData.last_played
-          ? new Date(Number(tautulliData.last_played) * 1000)
-          : null,
-        addedAt: tautulliData.added_at
-          ? new Date(Number(tautulliData.added_at) * 1000)
-          : null,
-        fileSize: tautulliData.file_size
-          ? BigInt(tautulliData.file_size)
-          : null,
-        filePath: tautulliData.file || null,
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-        ],
-      }
-
-      expect(evaluateRule(mediaItem, criteria)).toBe(true)
-    })
-
-    it('should handle null lastWatchedAt as never watched', () => {
-      jest.setSystemTime(new Date('2024-06-01'))
-
-      const mediaItem: MediaItem = {
-        title: 'Never Watched Movie',
-        playCount: 0,
-        lastWatchedAt: null, // Never watched
-      }
-
-      const criteria: RuleCriteria = {
-        type: 'group',
-        id: 'root',
-        operator: 'AND',
-        conditions: [
-          // olderThan should match null dates (never watched = infinitely old)
-          { type: 'condition', id: 'c1', field: 'lastWatchedAt', operator: 'olderThan', value: 30, valueUnit: 'days' },
-        ],
-      }
-
-      expect(evaluateRule(mediaItem, criteria)).toBe(true)
-    })
-  })
-})
diff --git a/lib/maintenance/__tests__/scanner-error-handling.test.ts b/lib/maintenance/__tests__/scanner-error-handling.test.ts
deleted file mode 100644
index ec8e86fe..00000000
--- a/lib/maintenance/__tests__/scanner-error-handling.test.ts
+++ /dev/null
@@ -1,589 +0,0 @@
-/**
- * Error handling tests for scanner.ts
- *
- * Tests error scenarios for:
- * - Tautulli connection failures
- * - Database errors
- * - Invalid data handling
- * - Graceful degradation
- */
-
-import { scanForCandidates } from '../scanner'
-import { getTautulliLibraryMediaInfo } from '@/lib/connections/tautulli'
-import { prisma } from '@/lib/prisma'
-
-// Mock dependencies
-jest.mock('@/lib/prisma', () => ({
-  prisma: {
-    maintenanceRule: {
-      findUnique: jest.fn(),
-      update: jest.fn(),
-    },
-    maintenanceScan: {
-      create: jest.fn(),
-      update: jest.fn(),
-    },
-    maintenanceCandidate: {
-      create: jest.fn(),
-    },
-    tautulli: {
-      findFirst: jest.fn(),
-    },
-  },
-}))
-
-jest.mock('@/lib/connections/tautulli', () => ({
-  getTautulliLibraryMediaInfo: jest.fn(),
-}))
-
-jest.mock('@/lib/utils/logger', () => ({
-  createLogger: () => ({
-    info: jest.fn(),
-    debug: jest.fn(),
-    error: jest.fn(),
-    warn: jest.fn(),
-  }),
-}))
-
-describe('Scanner Error Handling', () => {
-  const mockRuleId = 'rule-error-test'
-  const mockScanId = 'scan-error-test'
-
-  const mockTautulliServer = {
-    name: 'Tautulli',
-    url: 'http://localhost:8181',
-    apiKey: 'test-api-key',
-    publicUrl: null,
-    isActive: true,
-  }
-
-  const mockRule = {
-    id: mockRuleId,
-    name: 'Error Test Rule',
-    enabled: true,
-    mediaType: 'MOVIE' as const,
-    criteria: {
-      type: 'group',
-      id: 'root',
-      operator: 'AND',
-      conditions: [
-        { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-      ],
-      libraryIds: ['lib-1'],
-    },
-    actionType: 'FLAG_FOR_REVIEW',
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('Tautulli connection failures', () => {
-    it('should handle Tautulli server timeout gracefully', async () => {
-      const timeoutError = new Error('ETIMEDOUT: Connection timed out')
-      timeoutError.name = 'TimeoutError'
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockRejectedValue(timeoutError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('ETIMEDOUT')
-
-      // Verify scan was marked as failed
-      expect(prisma.maintenanceScan.update).toHaveBeenCalledWith({
-        where: { id: mockScanId },
-        data: expect.objectContaining({
-          status: 'FAILED',
-          error: expect.stringContaining('ETIMEDOUT'),
-        }),
-      })
-    })
-
-    it('should handle Tautulli server connection refused', async () => {
-      const connectionError = new Error('ECONNREFUSED: Connection refused')
-      connectionError.name = 'ConnectionError'
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockRejectedValue(connectionError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('ECONNREFUSED')
-    })
-
-    it('should handle Tautulli server returning HTTP 500', async () => {
-      const serverError = new Error('HTTP 500: Internal Server Error')
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockRejectedValue(serverError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('500')
-    })
-
-    it('should handle invalid Tautulli API key', async () => {
-      const authResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'error',
-            message: 'Invalid apikey',
-            data: null,
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(authResponse)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Invalid apikey')
-    })
-
-    it('should handle Tautulli returning malformed response', async () => {
-      const malformedResponse = {
-        success: true,
-        data: {
-          response: {
-            // Missing result field
-            data: null,
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(malformedResponse)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBeTruthy()
-    })
-  })
-
-  describe('Database errors', () => {
-    it('should handle database connection failure when finding rule', async () => {
-      const dbError = new Error('Database connection lost')
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockRejectedValue(dbError)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Database connection lost')
-      expect(result.scanId).toBe('')
-    })
-
-    it('should handle database error when creating scan record', async () => {
-      const dbError = new Error('Failed to insert scan record')
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockRejectedValue(dbError)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Failed to insert scan record')
-    })
-
-    it('should handle database error when creating candidate records', async () => {
-      const dbError = new Error('Candidate insert failed')
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: [
-                {
-                  rating_key: '1',
-                  title: 'Test Movie',
-                  play_count: 0,
-                  added_at: 1609459200,
-                  file_size: 1073741824,
-                  file: '/movies/test.mkv',
-                },
-              ],
-            },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockRejectedValue(dbError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Candidate insert failed')
-    })
-
-    it('should handle database error when updating scan status', async () => {
-      const dbError = new Error('Update failed')
-
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: { data: [] },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceScan.update as jest.Mock)
-        .mockRejectedValueOnce(dbError) // First update (completion) fails
-        .mockResolvedValue({ status: 'FAILED' }) // Second update (failure recording) succeeds
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-    })
-
-    it('should handle Tautulli config lookup failure', async () => {
-      const dbError = new Error('Config lookup failed')
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockRejectedValue(dbError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Config lookup failed')
-    })
-  })
-
-  describe('Invalid data handling', () => {
-    it('should handle missing rating_key in Tautulli data', async () => {
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: [
-                {
-                  // Missing rating_key
-                  title: 'Test Movie',
-                  play_count: 0,
-                },
-              ],
-            },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockResolvedValue({})
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Should not throw, should handle gracefully
-      const result = await scanForCandidates(mockRuleId)
-      expect(result.status).toBe('COMPLETED')
-    })
-
-    it('should handle null data array from Tautulli', async () => {
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: null, // Null instead of array
-            },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      // Should complete with 0 items scanned
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsScanned).toBe(0)
-    })
-
-    it('should handle invalid timestamp values', async () => {
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: [
-                {
-                  rating_key: '1',
-                  title: 'Test Movie',
-                  play_count: 0,
-                  added_at: 'invalid-timestamp', // Invalid timestamp
-                  last_played: NaN, // Invalid number
-                  file_size: 1073741824,
-                },
-              ],
-            },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockResolvedValue({})
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Should not throw
-      const result = await scanForCandidates(mockRuleId)
-      expect(result).toBeDefined()
-    })
-
-    it('should handle extremely large file size values', async () => {
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: [
-                {
-                  rating_key: '1',
-                  title: 'Test Movie',
-                  play_count: 0,
-                  added_at: 1609459200,
-                  file_size: '9999999999999999999', // Very large number as string
-                },
-              ],
-            },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockResolvedValue({})
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'COMPLETED' })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Should handle BigInt conversion
-      const result = await scanForCandidates(mockRuleId)
-      expect(result.status).toBe('COMPLETED')
-    })
-  })
-
-  describe('Graceful degradation', () => {
-    it('should continue scanning other libraries if one fails', async () => {
-      const multiLibraryRule = {
-        ...mockRule,
-        criteria: {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          ],
-          libraryIds: ['lib-1', 'lib-2'],
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(multiLibraryRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock)
-        .mockRejectedValueOnce(new Error('Library 1 unavailable')) // First library fails
-        .mockResolvedValueOnce({
-          success: true,
-          data: {
-            response: {
-              result: 'success',
-              message: null,
-              data: { data: [] },
-            },
-          },
-        }) // Second library succeeds
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      // Scanner stops on first error - this is current behavior
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Library 1 unavailable')
-    })
-
-    it('should complete scan even when no items match criteria', async () => {
-      // Test that scan completes when no items match (no candidates to create)
-      const mockTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: [
-                { rating_key: '1', title: 'Movie 1', play_count: 5, added_at: 1609459200, file_size: 1073741824 },
-                { rating_key: '2', title: 'Movie 2', play_count: 3, added_at: 1609459200, file_size: 1073741824 },
-              ],
-            },
-          },
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        id: mockScanId,
-        status: 'COMPLETED',
-        itemsScanned: 2,
-        itemsFlagged: 0,
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      // Scanner should complete with no flags when no items match criteria (playCount === 0)
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsFlagged).toBe(0)
-      // Verify no candidate create calls were made (no matches)
-      expect(prisma.maintenanceCandidate.create).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('Rule validation errors', () => {
-    it('should provide clear error for disabled rule', async () => {
-      const disabledRule = { ...mockRule, enabled: false }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(disabledRule)
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('disabled')
-      expect(result.error).toContain(mockRuleId)
-    })
-
-    it('should provide clear error for non-existent rule', async () => {
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(null)
-
-      const result = await scanForCandidates('non-existent-rule-id')
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('Rule not found')
-      expect(result.error).toContain('non-existent-rule-id')
-    })
-
-    it('should provide clear error for missing libraryIds', async () => {
-      const noLibraryRule = {
-        ...mockRule,
-        criteria: {
-          type: 'group',
-          id: 'root',
-          operator: 'AND',
-          conditions: [
-            { type: 'condition', id: 'c1', field: 'playCount', operator: 'equals', value: 0 },
-          ],
-          // No libraryIds
-        },
-      }
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(noLibraryRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('libraryIds')
-      expect(result.error).toContain(mockRule.name)
-    })
-  })
-
-  describe('Error recovery', () => {
-    it('should update scan status to FAILED when error occurs', async () => {
-      const testError = new Error('Test error for recovery')
-
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockRejectedValue(testError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      await scanForCandidates(mockRuleId)
-
-      // Verify scan was updated to FAILED with error message
-      expect(prisma.maintenanceScan.update).toHaveBeenCalledWith({
-        where: { id: mockScanId },
-        data: {
-          status: 'FAILED',
-          completedAt: expect.any(Date),
-          error: 'Test error for recovery',
-        },
-      })
-    })
-
-    it('should handle non-Error objects thrown as errors', async () => {
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue({ id: mockScanId, status: 'RUNNING' })
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockRejectedValue('String error') // Non-Error object
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({ status: 'FAILED' })
-
-      const result = await scanForCandidates(mockRuleId)
-
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Unknown error occurred')
-    })
-  })
-})
diff --git a/lib/maintenance/__tests__/scanner.test.ts b/lib/maintenance/__tests__/scanner.test.ts
deleted file mode 100644
index fc797d3a..00000000
--- a/lib/maintenance/__tests__/scanner.test.ts
+++ /dev/null
@@ -1,900 +0,0 @@
-import { scanForCandidates } from '../scanner'
-import { evaluateRule } from '../rule-evaluator'
-import { getTautulliLibraryMediaInfo } from '@/lib/connections/tautulli'
-import { prisma } from '@/lib/prisma'
-
-// Mock dependencies
-jest.mock('@/lib/prisma', () => ({
-  prisma: {
-    maintenanceRule: {
-      findUnique: jest.fn(),
-      update: jest.fn(),
-    },
-    maintenanceScan: {
-      create: jest.fn(),
-      update: jest.fn(),
-    },
-    maintenanceCandidate: {
-      create: jest.fn(),
-    },
-    tautulli: {
-      findFirst: jest.fn(),
-    },
-  },
-}))
-
-jest.mock('@/lib/connections/tautulli', () => ({
-  getTautulliLibraryMediaInfo: jest.fn(),
-}))
-
-jest.mock('../rule-evaluator', () => ({
-  evaluateRule: jest.fn(),
-}))
-
-// Mock logger to avoid console output in tests
-jest.mock('@/lib/utils/logger', () => ({
-  createLogger: () => ({
-    info: jest.fn(),
-    debug: jest.fn(),
-    error: jest.fn(),
-    warn: jest.fn(),
-  }),
-}))
-
-describe('scanForCandidates', () => {
-  const mockRuleId = 'rule-123'
-  const mockScanId = 'scan-456'
-
-  const mockRule = {
-    id: mockRuleId,
-    name: 'Test Rule',
-    description: 'Test rule description',
-    enabled: true,
-    mediaType: 'MOVIE' as const,
-    criteria: {
-      libraryIds: ['lib-1'],
-      neverWatched: true,
-    },
-    actionType: 'DELETE',
-    schedule: null,
-    lastRunAt: null,
-    nextRunAt: null,
-    createdAt: new Date('2024-01-01'),
-  }
-
-  const mockScan = {
-    id: mockScanId,
-    ruleId: mockRuleId,
-    status: 'RUNNING',
-    startedAt: new Date(),
-    completedAt: null,
-    error: null,
-    itemsScanned: 0,
-    itemsFlagged: 0,
-    createdAt: new Date(),
-  }
-
-  const mockTautulliConfig = {
-    name: 'Tautulli',
-    url: 'http://localhost:8181',
-    apiKey: 'test-api-key',
-    publicUrl: undefined,
-  }
-
-  const mockTautulliServer = {
-    name: 'Tautulli',
-    url: 'http://localhost:8181',
-    apiKey: 'test-api-key',
-    publicUrl: null,
-    isActive: true,
-  }
-
-  const mockMovieData = [
-    {
-      rating_key: '1',
-      title: 'Movie 1',
-      year: 2020,
-      play_count: 0,
-      last_played: null,
-      added_at: 1609459200, // 2021-01-01
-      file_size: 1073741824, // 1GB
-      file: '/path/to/movie1.mp4',
-      radarr_id: 100,
-      tmdb_id: 200,
-      thumb: '/poster1.jpg',
-    },
-    {
-      rating_key: '2',
-      title: 'Movie 2',
-      year: 2021,
-      play_count: 5,
-      last_played: 1640995200, // 2022-01-01
-      added_at: 1609459200,
-      file_size: 2147483648, // 2GB
-      file: '/path/to/movie2.mp4',
-      radarr_id: 101,
-      tmdb_id: 201,
-      thumb: '/poster2.jpg',
-    },
-  ]
-
-  const mockTVSeriesData = [
-    {
-      rating_key: '10',
-      title: 'TV Series 1',
-      year: 2020,
-      play_count: 0,
-      last_played: null,
-      added_at: 1609459200,
-      file_size: 5368709120, // 5GB
-      file: '/path/to/series1',
-      sonarr_id: 300,
-      tvdb_id: 400,
-      thumb: '/poster10.jpg',
-    },
-  ]
-
-  const mockTautulliResponse = {
-    success: true,
-    data: {
-      response: {
-        result: 'success',
-        message: null,
-        data: {
-          data: mockMovieData,
-        },
-      },
-    },
-  }
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-  })
-
-  describe('successful scan scenarios', () => {
-    it('should successfully scan and find matching items', async () => {
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockImplementation((item) => {
-        // Only match the first movie (never watched)
-        return item.plexRatingKey === '1'
-      })
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) =>
-        Promise.resolve({ id: 'candidate-1', ...data.data })
-      )
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-        completedAt: new Date(),
-        itemsScanned: 2,
-        itemsFlagged: 1,
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify rule lookup
-      expect(prisma.maintenanceRule.findUnique).toHaveBeenCalledWith({
-        where: { id: mockRuleId },
-      })
-
-      // Verify scan creation
-      expect(prisma.maintenanceScan.create).toHaveBeenCalledWith({
-        data: {
-          ruleId: mockRuleId,
-          status: 'RUNNING',
-          startedAt: expect.any(Date),
-        },
-      })
-
-      // Verify Tautulli config lookup
-      expect(prisma.tautulli.findFirst).toHaveBeenCalledWith({
-        where: { isActive: true },
-      })
-
-      // Verify Tautulli API call
-      expect(getTautulliLibraryMediaInfo).toHaveBeenCalledWith(
-        mockTautulliConfig,
-        'lib-1',
-        { length: 10000 }
-      )
-
-      // Verify rule evaluation for all items
-      expect(evaluateRule).toHaveBeenCalledTimes(2)
-
-      // Verify candidate creation for matched item
-      expect(prisma.maintenanceCandidate.create).toHaveBeenCalledTimes(1)
-      expect(prisma.maintenanceCandidate.create).toHaveBeenCalledWith({
-        data: {
-          scanId: mockScanId,
-          mediaType: 'MOVIE',
-          plexRatingKey: '1',
-          radarrId: 100,
-          sonarrId: null,
-          tmdbId: 200,
-          tvdbId: null,
-          title: 'Movie 1',
-          year: 2020,
-          poster: '/poster1.jpg',
-          filePath: '/path/to/movie1.mp4',
-          fileSize: BigInt(1073741824),
-          playCount: 0,
-          lastWatchedAt: null,
-          addedAt: new Date(1609459200 * 1000),
-          matchedRules: ['Test Rule'],
-          reviewStatus: 'PENDING',
-        },
-      })
-
-      // Verify scan completion
-      expect(prisma.maintenanceScan.update).toHaveBeenCalledWith({
-        where: { id: mockScanId },
-        data: {
-          status: 'COMPLETED',
-          completedAt: expect.any(Date),
-          itemsScanned: 2,
-          itemsFlagged: 1,
-        },
-      })
-
-      // Verify rule statistics update
-      expect(prisma.maintenanceRule.update).toHaveBeenCalledWith({
-        where: { id: mockRuleId },
-        data: {
-          lastRunAt: expect.any(Date),
-          nextRunAt: null,
-        },
-      })
-
-      // Verify result
-      expect(result).toEqual({
-        scanId: mockScanId,
-        status: 'COMPLETED',
-        itemsScanned: 2,
-        itemsFlagged: 1,
-      })
-    })
-
-    it('should successfully scan with no matches', async () => {
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(false) // No matches
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-        completedAt: new Date(),
-        itemsScanned: 2,
-        itemsFlagged: 0,
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify no candidates created
-      expect(prisma.maintenanceCandidate.create).not.toHaveBeenCalled()
-
-      // Verify scan completed with no flags
-      expect(prisma.maintenanceScan.update).toHaveBeenCalledWith({
-        where: { id: mockScanId },
-        data: {
-          status: 'COMPLETED',
-          completedAt: expect.any(Date),
-          itemsScanned: 2,
-          itemsFlagged: 0,
-        },
-      })
-
-      // Verify result
-      expect(result).toEqual({
-        scanId: mockScanId,
-        status: 'COMPLETED',
-        itemsScanned: 2,
-        itemsFlagged: 0,
-      })
-    })
-
-    it('should handle TV series scans', async () => {
-      const tvRule = {
-        ...mockRule,
-        mediaType: 'TV_SERIES' as const,
-        criteria: {
-          libraryIds: ['lib-tv-1'],
-          neverWatched: true,
-        },
-      }
-
-      const tvTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: mockTVSeriesData,
-            },
-          },
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(tvRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(tvTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(true) // Match the series
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) =>
-        Promise.resolve({ id: 'candidate-tv-1', ...data.data })
-      )
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-        completedAt: new Date(),
-        itemsScanned: 1,
-        itemsFlagged: 1,
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(tvRule)
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify candidate creation with TV series fields
-      expect(prisma.maintenanceCandidate.create).toHaveBeenCalledWith({
-        data: {
-          scanId: mockScanId,
-          mediaType: 'TV_SERIES',
-          plexRatingKey: '10',
-          radarrId: null,
-          sonarrId: 300,
-          tmdbId: null,
-          tvdbId: 400,
-          title: 'TV Series 1',
-          year: 2020,
-          poster: '/poster10.jpg',
-          filePath: '/path/to/series1',
-          fileSize: BigInt(5368709120),
-          playCount: 0,
-          lastWatchedAt: null,
-          addedAt: new Date(1609459200 * 1000),
-          matchedRules: ['Test Rule'],
-          reviewStatus: 'PENDING',
-        },
-      })
-
-      expect(result.status).toBe('COMPLETED')
-      expect(result.itemsFlagged).toBe(1)
-    })
-
-    it('should scan multiple libraries', async () => {
-      const multiLibraryRule = {
-        ...mockRule,
-        criteria: {
-          libraryIds: ['lib-1', 'lib-2'],
-          neverWatched: true,
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(multiLibraryRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(false)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-        completedAt: new Date(),
-        itemsScanned: 4,
-        itemsFlagged: 0,
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(multiLibraryRule)
-
-      // Execute
-      await scanForCandidates(mockRuleId)
-
-      // Verify Tautulli called for each library
-      expect(getTautulliLibraryMediaInfo).toHaveBeenCalledTimes(2)
-      expect(getTautulliLibraryMediaInfo).toHaveBeenCalledWith(
-        mockTautulliConfig,
-        'lib-1',
-        { length: 10000 }
-      )
-      expect(getTautulliLibraryMediaInfo).toHaveBeenCalledWith(
-        mockTautulliConfig,
-        'lib-2',
-        { length: 10000 }
-      )
-    })
-  })
-
-  describe('progress callback', () => {
-    it('should invoke progress callback during scan', async () => {
-      const onProgress = jest.fn()
-
-      // Create array of 25 items to ensure multiple progress updates
-      const manyMovies = Array.from({ length: 25 }, (_, i) => ({
-        rating_key: String(i + 1),
-        title: `Movie ${i + 1}`,
-        year: 2020,
-        play_count: i,
-        last_played: null,
-        added_at: 1609459200,
-        file_size: 1073741824,
-        file: `/path/to/movie${i + 1}.mp4`,
-        radarr_id: i + 100,
-        tmdb_id: i + 200,
-        thumb: `/poster${i + 1}.jpg`,
-      }))
-
-      const largeTautulliResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: manyMovies,
-            },
-          },
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(largeTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(false)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      await scanForCandidates(mockRuleId, onProgress)
-
-      // Verify progress callback was called (every 10 items)
-      // With 25 items, should be called at 10, 20 positions
-      expect(onProgress).toHaveBeenCalled()
-      expect(onProgress).toHaveBeenCalledWith(expect.any(Number))
-
-      // Check that percentages are reasonable
-      const calls = onProgress.mock.calls.map((call) => call[0])
-      calls.forEach((percent) => {
-        expect(percent).toBeGreaterThanOrEqual(0)
-        expect(percent).toBeLessThanOrEqual(100)
-      })
-    })
-  })
-
-  describe('error handling', () => {
-    it('should return error when rule not found', async () => {
-      // Setup mock
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(null)
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error result
-      expect(result).toEqual({
-        scanId: '',
-        status: 'FAILED',
-        itemsScanned: 0,
-        itemsFlagged: 0,
-        error: `Rule not found: ${mockRuleId}`,
-      })
-
-      // Verify no scan was created
-      expect(prisma.maintenanceScan.create).not.toHaveBeenCalled()
-    })
-
-    it('should return error when rule is disabled', async () => {
-      const disabledRule = { ...mockRule, enabled: false }
-
-      // Setup mock
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(disabledRule)
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error result
-      expect(result).toEqual({
-        scanId: '',
-        status: 'FAILED',
-        itemsScanned: 0,
-        itemsFlagged: 0,
-        error: `Rule is disabled: ${mockRuleId}`,
-      })
-
-      // Verify no scan was created
-      expect(prisma.maintenanceScan.create).not.toHaveBeenCalled()
-    })
-
-    it('should handle database errors during scan creation', async () => {
-      const dbError = new Error('Database connection failed')
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockRejectedValue(dbError)
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error result
-      expect(result).toEqual({
-        scanId: '',
-        status: 'FAILED',
-        itemsScanned: 0,
-        itemsFlagged: 0,
-        error: 'Database connection failed',
-      })
-    })
-
-    it('should update scan to FAILED status on error', async () => {
-      const tautulliError = new Error('Tautulli API error')
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockRejectedValue(tautulliError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify scan was updated to FAILED
-      expect(prisma.maintenanceScan.update).toHaveBeenCalledWith({
-        where: { id: mockScanId },
-        data: {
-          status: 'FAILED',
-          completedAt: expect.any(Date),
-          error: 'Tautulli API error',
-        },
-      })
-
-      // Verify error result
-      expect(result).toEqual({
-        scanId: '',
-        status: 'FAILED',
-        itemsScanned: 0,
-        itemsFlagged: 0,
-        error: 'Tautulli API error',
-      })
-    })
-
-    it('should handle error when no Tautulli server configured', async () => {
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(null)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('No active Tautulli server configured')
-
-      // Verify scan was updated to FAILED
-      expect(prisma.maintenanceScan.update).toHaveBeenCalledWith({
-        where: { id: mockScanId },
-        data: {
-          status: 'FAILED',
-          completedAt: expect.any(Date),
-          error: 'No active Tautulli server configured',
-        },
-      })
-    })
-
-    it('should handle Tautulli API error response', async () => {
-      const errorResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'error',
-            message: 'Invalid section ID',
-            data: null,
-          },
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(errorResponse)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Invalid section ID')
-    })
-
-    it('should handle missing libraryIds for movie rules', async () => {
-      const ruleWithoutLibraries = {
-        ...mockRule,
-        criteria: {
-          neverWatched: true,
-          // No libraryIds
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(ruleWithoutLibraries)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error includes rule context
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('MOVIE rules must specify libraryIds in criteria')
-      expect(result.error).toContain('Rule: "Test Rule"')
-      expect(result.error).toContain(mockRuleId)
-    })
-
-    it('should handle missing libraryIds for TV series rules', async () => {
-      const tvRuleWithoutLibraries = {
-        ...mockRule,
-        mediaType: 'TV_SERIES' as const,
-        criteria: {
-          neverWatched: true,
-          // No libraryIds
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(tvRuleWithoutLibraries)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error includes rule context
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('TV_SERIES rules must specify libraryIds in criteria')
-      expect(result.error).toContain('Rule: "Test Rule"')
-      expect(result.error).toContain(mockRuleId)
-    })
-
-    it('should handle unsupported media type', async () => {
-      const unsupportedRule = {
-        ...mockRule,
-        mediaType: 'MUSIC' as any,
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(unsupportedRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify error includes rule context and supported types
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toContain('Unsupported media type: MUSIC')
-      expect(result.error).toContain('Rule: "Test Rule"')
-      expect(result.error).toContain(mockRuleId)
-      expect(result.error).toContain('Supported types: MOVIE, TV_SERIES')
-    })
-
-    it('should handle error during candidate creation', async () => {
-      const candidateError = new Error('Failed to create candidate')
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(true) // Match all items
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockRejectedValue(candidateError)
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'FAILED',
-      })
-
-      // Execute
-      const result = await scanForCandidates(mockRuleId)
-
-      // Verify scan was marked as FAILED
-      expect(result.status).toBe('FAILED')
-      expect(result.error).toBe('Failed to create candidate')
-    })
-  })
-
-  describe('data transformation', () => {
-    it('should correctly transform movie data with all fields', async () => {
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(true)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) =>
-        Promise.resolve({ id: 'candidate-1', ...data.data })
-      )
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      await scanForCandidates(mockRuleId)
-
-      // Verify data transformation
-      expect(evaluateRule).toHaveBeenCalledWith(
-        {
-          plexRatingKey: '1',
-          title: 'Movie 1',
-          year: 2020,
-          libraryId: 'lib-1',
-          playCount: 0,
-          lastWatchedAt: null,
-          addedAt: new Date(1609459200 * 1000),
-          fileSize: BigInt(1073741824),
-          filePath: '/path/to/movie1.mp4',
-          radarrId: 100,
-          tmdbId: 200,
-          poster: '/poster1.jpg',
-        },
-        mockRule.criteria
-      )
-    })
-
-    it('should handle missing optional fields in Tautulli data', async () => {
-      const minimalMovieData = [
-        {
-          rating_key: '1',
-          title: 'Minimal Movie',
-          // All optional fields missing
-        },
-      ]
-
-      const minimalResponse = {
-        success: true,
-        data: {
-          response: {
-            result: 'success',
-            message: null,
-            data: {
-              data: minimalMovieData,
-            },
-          },
-        },
-      }
-
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(minimalResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(true)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) =>
-        Promise.resolve({ id: 'candidate-1', ...data.data })
-      )
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      await scanForCandidates(mockRuleId)
-
-      // Verify minimal data handling
-      expect(evaluateRule).toHaveBeenCalledWith(
-        {
-          plexRatingKey: '1',
-          title: 'Minimal Movie',
-          year: undefined,
-          libraryId: 'lib-1',
-          playCount: 0,
-          lastWatchedAt: null,
-          addedAt: null,
-          fileSize: null,
-          filePath: null,
-          radarrId: null,
-          tmdbId: null,
-          poster: null,
-        },
-        mockRule.criteria
-      )
-
-      expect(prisma.maintenanceCandidate.create).toHaveBeenCalledWith({
-        data: expect.objectContaining({
-          year: undefined,
-          radarrId: null,
-          tmdbId: null,
-          poster: null,
-          filePath: null,
-          fileSize: null,
-        }),
-      })
-    })
-
-    it('should correctly convert timestamps to dates', async () => {
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockImplementation((item) => {
-        // Verify timestamp conversion
-        if (item.plexRatingKey === '2') {
-          expect(item.lastWatchedAt).toEqual(new Date(1640995200 * 1000))
-          expect(item.addedAt).toEqual(new Date(1609459200 * 1000))
-        }
-        return false
-      })
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      await scanForCandidates(mockRuleId)
-
-      // Verification done in evaluateRule mock
-    })
-
-    it('should correctly convert BigInt file sizes', async () => {
-      // Setup mocks
-      ;(prisma.maintenanceRule.findUnique as jest.Mock).mockResolvedValue(mockRule)
-      ;(prisma.maintenanceScan.create as jest.Mock).mockResolvedValue(mockScan)
-      ;(prisma.tautulli.findFirst as jest.Mock).mockResolvedValue(mockTautulliServer)
-      ;(getTautulliLibraryMediaInfo as jest.Mock).mockResolvedValue(mockTautulliResponse)
-      ;(evaluateRule as jest.Mock).mockReturnValue(true)
-      ;(prisma.maintenanceCandidate.create as jest.Mock).mockImplementation((data) => {
-        // Verify BigInt conversion
-        expect(data.data.fileSize).toBeInstanceOf(BigInt)
-        return Promise.resolve({ id: 'candidate-1', ...data.data })
-      })
-      ;(prisma.maintenanceScan.update as jest.Mock).mockResolvedValue({
-        ...mockScan,
-        status: 'COMPLETED',
-      })
-      ;(prisma.maintenanceRule.update as jest.Mock).mockResolvedValue(mockRule)
-
-      // Execute
-      await scanForCandidates(mockRuleId)
-
-      // Verification done in create mock
-    })
-  })
-})
diff --git a/lib/maintenance/client-evaluator.ts b/lib/maintenance/client-evaluator.ts
deleted file mode 100644
index 0f82c6ed..00000000
--- a/lib/maintenance/client-evaluator.ts
+++ /dev/null
@@ -1,410 +0,0 @@
-/**
- * Client-Side Rule Evaluator
- *
- * Browser-safe version of the rule evaluator for real-time feedback
- * during rule building. This module has NO server-side dependencies
- * and can be safely imported in client components.
- *
- * @module lib/maintenance/client-evaluator
- */
-
-import type { RuleCriteria, Condition, ConditionGroup } from "@/lib/validations/maintenance"
-import {
-  FIELD_DEFINITIONS,
-  type StringOperator,
-  type NumberOperator,
-  type DateOperator,
-  type BooleanOperator,
-  type ArrayOperator,
-} from "./field-registry"
-
-// Re-export MediaItem type for client usage
-export type { MediaItem } from "./rule-evaluator"
-import type { MediaItem } from "./rule-evaluator"
-
-/**
- * Result of evaluating a single condition
- */
-export interface ConditionResult {
-  conditionId: string
-  field: string
-  fieldLabel: string
-  operator: string
-  expectedValue: unknown
-  actualValue: unknown
-  passed: boolean
-}
-
-/**
- * Detailed evaluation result with per-condition breakdown
- */
-export interface EvaluationResult {
-  matches: boolean
-  conditionResults: ConditionResult[]
-}
-
-/**
- * Evaluates a rule criteria against a media item (client-side).
- *
- * This is the main entry point for client-side evaluation.
- * Returns a boolean indicating if the item matches the rule.
- *
- * @param item - The media item to evaluate
- * @param criteria - The rule criteria (hierarchical format)
- * @returns true if the item matches the rule
- */
-export function evaluateRuleClient(
-  item: MediaItem,
-  criteria: RuleCriteria
-): boolean {
-  return evaluateNode(item, criteria)
-}
-
-/**
- * Evaluates a rule with detailed per-condition results.
- *
- * Use this for showing match/no-match indicators on each condition
- * during rule building.
- *
- * @param item - The media item to evaluate
- * @param criteria - The rule criteria
- * @returns Evaluation result with match status and condition breakdown
- */
-export function evaluateRuleWithDetails(
-  item: MediaItem,
-  criteria: RuleCriteria
-): EvaluationResult {
-  const conditionResults: ConditionResult[] = []
-
-  function collectConditions(node: Condition | ConditionGroup): void {
-    if (node.type === 'condition') {
-      const fieldDef = FIELD_DEFINITIONS.find(f => f.key === node.field)
-      const actualValue = getFieldValue(item, node.field)
-      const passed = evaluateCondition(item, node)
-
-      conditionResults.push({
-        conditionId: node.id,
-        field: node.field,
-        fieldLabel: fieldDef?.label || node.field,
-        operator: node.operator,
-        expectedValue: node.value,
-        actualValue,
-        passed,
-      })
-    } else if (node.conditions && Array.isArray(node.conditions)) {
-      node.conditions.forEach(child => collectConditions(child))
-    }
-  }
-
-  collectConditions(criteria)
-  const matches = evaluateNode(item, criteria)
-
-  return { matches, conditionResults }
-}
-
-/**
- * Batch evaluate multiple items against a rule.
- *
- * Use this for showing match counts in the media browser.
- *
- * @param items - Array of media items to evaluate
- * @param criteria - The rule criteria
- * @returns Object with matched and non-matched item arrays
- */
-export function evaluateMany(
-  items: MediaItem[],
-  criteria: RuleCriteria
-): { matches: MediaItem[]; nonMatches: MediaItem[] } {
-  const matches: MediaItem[] = []
-  const nonMatches: MediaItem[] = []
-
-  for (const item of items) {
-    if (evaluateRuleClient(item, criteria)) {
-      matches.push(item)
-    } else {
-      nonMatches.push(item)
-    }
-  }
-
-  return { matches, nonMatches }
-}
-
-// ─── Internal Evaluation Functions ───────────────────────────────────────────
-
-function evaluateNode(item: MediaItem, node: Condition | ConditionGroup): boolean {
-  if (node.type === 'condition') {
-    return evaluateCondition(item, node)
-  } else {
-    // Handle case where conditions might be undefined or empty
-    if (!node.conditions || !Array.isArray(node.conditions) || node.conditions.length === 0) {
-      // Empty group: AND returns true (no conditions to fail), OR returns false (no conditions to pass)
-      return node.operator === 'AND'
-    }
-
-    const results = node.conditions.map(child => evaluateNode(item, child))
-
-    if (node.operator === 'AND') {
-      return results.every(r => r === true)
-    } else {
-      return results.some(r => r === true)
-    }
-  }
-}
-
-function evaluateCondition(item: MediaItem, condition: Condition): boolean {
-  const fieldValue = getFieldValue(item, condition.field)
-  const conditionValue = condition.value
-
-  // Handle null checks first
-  if (condition.operator === 'null') {
-    return fieldValue === null || fieldValue === undefined
-  }
-  if (condition.operator === 'notNull') {
-    return fieldValue !== null && fieldValue !== undefined
-  }
-
-  // Get field definition for type-specific comparison
-  const fieldDef = FIELD_DEFINITIONS.find(f => f.key === condition.field)
-  if (!fieldDef) {
-    console.warn(`Unknown field in condition: ${condition.field}`)
-    return false
-  }
-
-  // Special handling for lastWatchedAt with olderThan - null means never watched = old
-  if (fieldDef.type === 'date' && condition.operator === 'olderThan' && condition.field === 'lastWatchedAt') {
-    if (fieldValue === null || fieldValue === undefined) {
-      return true
-    }
-  }
-
-  // If field value is null/undefined and not checking for null, fail safe
-  if (fieldValue === null || fieldValue === undefined) {
-    return false
-  }
-
-  // Type-specific comparisons
-  switch (fieldDef.type) {
-    case 'string':
-      return evaluateStringCondition(
-        fieldValue as string,
-        condition.operator as StringOperator,
-        conditionValue as string | string[]
-      )
-    case 'number':
-      return evaluateNumberCondition(
-        fieldValue as number,
-        condition.operator as NumberOperator,
-        conditionValue as number | number[]
-      )
-    case 'date':
-      return evaluateDateCondition(
-        fieldValue as Date | string,
-        condition.operator as DateOperator,
-        conditionValue,
-        condition.valueUnit
-      )
-    case 'boolean':
-      return evaluateBooleanCondition(
-        fieldValue as boolean,
-        condition.operator as BooleanOperator,
-        conditionValue as boolean
-      )
-    case 'array':
-      return evaluateArrayCondition(
-        fieldValue as (string | number)[],
-        condition.operator as ArrayOperator,
-        conditionValue as string | string[] | number | number[]
-      )
-    case 'enum':
-      return evaluateStringCondition(
-        fieldValue as string,
-        condition.operator as StringOperator,
-        conditionValue as string | string[]
-      )
-    default:
-      return false
-  }
-}
-
-function getFieldValue(item: MediaItem, fieldKey: string): unknown {
-  // Handle special computed fields
-  if (fieldKey === 'neverWatched') {
-    return (item.playCount as number) === 0
-  }
-
-  // Computed: Days since added
-  if (fieldKey === 'daysSinceAdded') {
-    const addedAt = item.addedAt as Date | string | null | undefined
-    if (!addedAt) return null
-    const addedDate = typeof addedAt === 'string' ? new Date(addedAt) : addedAt
-    const now = new Date()
-    return Math.floor((now.getTime() - addedDate.getTime()) / (24 * 60 * 60 * 1000))
-  }
-
-  // Computed: Days since last watched
-  if (fieldKey === 'daysSinceWatched') {
-    const lastWatchedAt = item.lastWatchedAt as Date | string | null | undefined
-    if (!lastWatchedAt) return null
-    const watchedDate = typeof lastWatchedAt === 'string' ? new Date(lastWatchedAt) : lastWatchedAt
-    const now = new Date()
-    return Math.floor((now.getTime() - watchedDate.getTime()) / (24 * 60 * 60 * 1000))
-  }
-
-  // Handle nested fields (e.g., "radarr.hasFile")
-  if (fieldKey.includes('.')) {
-    const parts = fieldKey.split('.')
-    let value: unknown = item
-    for (const part of parts) {
-      value = (value as Record<string, unknown>)?.[part]
-      if (value === undefined) return null
-    }
-    return value
-  }
-
-  // Direct field access
-  return (item as unknown as Record<string, unknown>)[fieldKey]
-}
-
-function evaluateStringCondition(
-  fieldValue: string,
-  operator: StringOperator,
-  conditionValue: string | string[]
-): boolean {
-  switch (operator) {
-    case 'equals':
-      return fieldValue === conditionValue
-    case 'notEquals':
-      return fieldValue !== conditionValue
-    case 'contains':
-      return fieldValue.toLowerCase().includes((conditionValue as string).toLowerCase())
-    case 'notContains':
-      return !fieldValue.toLowerCase().includes((conditionValue as string).toLowerCase())
-    case 'startsWith':
-      return fieldValue.toLowerCase().startsWith((conditionValue as string).toLowerCase())
-    case 'endsWith':
-      return fieldValue.toLowerCase().endsWith((conditionValue as string).toLowerCase())
-    case 'regex':
-      try {
-        const regex = new RegExp(conditionValue as string, 'i')
-        return regex.test(fieldValue)
-      } catch {
-        return false
-      }
-    case 'in':
-      return (conditionValue as string[]).includes(fieldValue)
-    case 'notIn':
-      return !(conditionValue as string[]).includes(fieldValue)
-    default:
-      return false
-  }
-}
-
-function evaluateNumberCondition(
-  fieldValue: number,
-  operator: NumberOperator,
-  conditionValue: number | number[]
-): boolean {
-  switch (operator) {
-    case 'equals':
-      return fieldValue === conditionValue
-    case 'notEquals':
-      return fieldValue !== conditionValue
-    case 'greaterThan':
-      return fieldValue > (conditionValue as number)
-    case 'greaterThanOrEqual':
-      return fieldValue >= (conditionValue as number)
-    case 'lessThan':
-      return fieldValue < (conditionValue as number)
-    case 'lessThanOrEqual':
-      return fieldValue <= (conditionValue as number)
-    case 'between': {
-      const [min, max] = conditionValue as number[]
-      return fieldValue >= min && fieldValue <= max
-    }
-    default:
-      return false
-  }
-}
-
-function evaluateDateCondition(
-  fieldValue: Date | string,
-  operator: DateOperator,
-  conditionValue: unknown,
-  unit?: string
-): boolean {
-  // Convert string dates to Date objects
-  const dateValue = typeof fieldValue === 'string' ? new Date(fieldValue) : fieldValue
-
-  switch (operator) {
-    case 'before':
-      return dateValue < new Date(conditionValue as string)
-    case 'after':
-      return dateValue > new Date(conditionValue as string)
-    case 'between': {
-      const [start, end] = conditionValue as string[]
-      return dateValue >= new Date(start) && dateValue <= new Date(end)
-    }
-    case 'olderThan': {
-      const threshold = calculateDateThreshold(conditionValue as number, unit as 'days' | 'months' | 'years')
-      return dateValue < threshold
-    }
-    case 'newerThan': {
-      const threshold = calculateDateThreshold(conditionValue as number, unit as 'days' | 'months' | 'years')
-      return dateValue > threshold
-    }
-    default:
-      return false
-  }
-}
-
-function calculateDateThreshold(value: number, unit: 'days' | 'months' | 'years'): Date {
-  const now = new Date()
-  switch (unit) {
-    case 'days':
-      return new Date(now.getTime() - value * 24 * 60 * 60 * 1000)
-    case 'months':
-      return new Date(now.getTime() - value * 30 * 24 * 60 * 60 * 1000)
-    case 'years':
-      return new Date(now.getTime() - value * 365 * 24 * 60 * 60 * 1000)
-    default:
-      return new Date(now.getTime() - value * 24 * 60 * 60 * 1000)
-  }
-}
-
-function evaluateBooleanCondition(
-  fieldValue: boolean,
-  operator: BooleanOperator,
-  conditionValue: boolean
-): boolean {
-  switch (operator) {
-    case 'equals':
-      return fieldValue === conditionValue
-    case 'notEquals':
-      return fieldValue !== conditionValue
-    default:
-      return false
-  }
-}
-
-function evaluateArrayCondition(
-  fieldValue: (string | number)[],
-  operator: ArrayOperator,
-  conditionValue: string | string[] | number | number[]
-): boolean {
-  switch (operator) {
-    case 'contains':
-      return fieldValue.includes(conditionValue as string | number)
-    case 'notContains':
-      return !fieldValue.includes(conditionValue as string | number)
-    case 'containsAny':
-      return (conditionValue as (string | number)[]).some(v => fieldValue.includes(v))
-    case 'containsAll':
-      return (conditionValue as (string | number)[]).every(v => fieldValue.includes(v))
-    case 'isEmpty':
-      return fieldValue.length === 0
-    case 'isNotEmpty':
-      return fieldValue.length > 0
-    default:
-      return false
-  }
-}
diff --git a/lib/maintenance/deleter.ts b/lib/maintenance/deleter.ts
deleted file mode 100644
index 8f913514..00000000
--- a/lib/maintenance/deleter.ts
+++ /dev/null
@@ -1,237 +0,0 @@
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import { deleteRadarrMovie } from "@/lib/connections/radarr"
-import { deleteSonarrSeries } from "@/lib/connections/sonarr"
-
-const logger = createLogger("MAINTENANCE_DELETER")
-
-interface DeletionResult {
-  success: number
-  failed: number
-  errors: string[]
-}
-
-/**
- * Execute deletions for approved maintenance candidates
- */
-export async function executeDeletions(
-  candidateIds: string[],
-  deleteFiles: boolean,
-  userId: string,
-  onProgress?: (percent: number) => void
-): Promise<DeletionResult> {
-  const startTime = Date.now()
-  logger.info("Starting deletion execution", {
-    candidateCount: candidateIds.length,
-    deleteFiles,
-    userId,
-  })
-
-  const result: DeletionResult = {
-    success: 0,
-    failed: 0,
-    errors: [],
-  }
-
-  try {
-    // Fetch approved candidates
-    const candidates = await prisma.maintenanceCandidate.findMany({
-      where: {
-        id: { in: candidateIds },
-        reviewStatus: "APPROVED",
-      },
-      include: {
-        scan: {
-          include: {
-            rule: true,
-          },
-        },
-      },
-    })
-
-    if (candidates.length === 0) {
-      logger.warn("No approved candidates found for deletion", {
-        requestedIds: candidateIds.length,
-      })
-      return result
-    }
-
-    logger.debug("Found approved candidates", { count: candidates.length })
-
-    // Process each candidate
-    for (let i = 0; i < candidates.length; i++) {
-      const candidate = candidates[i]
-
-      try {
-        logger.debug("Processing deletion", {
-          candidateId: candidate.id,
-          title: candidate.title,
-          mediaType: candidate.mediaType,
-        })
-
-        // Delete based on media type
-        if (candidate.mediaType === "MOVIE") {
-          if (!candidate.radarrId) {
-            throw new Error(
-              `Movie candidate ${candidate.id} does not have a Radarr ID`
-            )
-          }
-
-          // Get Radarr config from database
-          const radarrServer = await prisma.radarr.findFirst({
-            where: { isActive: true },
-          })
-
-          if (!radarrServer) {
-            throw new Error("No active Radarr server configured")
-          }
-
-          const radarrConfig = {
-            name: radarrServer.name,
-            url: radarrServer.url,
-            apiKey: radarrServer.apiKey,
-            publicUrl: radarrServer.publicUrl || undefined,
-          }
-
-          // Delete from Radarr
-          const deleteResult = await deleteRadarrMovie(
-            radarrConfig,
-            candidate.radarrId,
-            deleteFiles,
-            false // Don't add exclusion
-          )
-
-          if (!deleteResult.success) {
-            throw new Error(
-              deleteResult.error || "Failed to delete movie from Radarr"
-            )
-          }
-
-          logger.debug("Deleted movie from Radarr", {
-            radarrId: candidate.radarrId,
-            title: candidate.title,
-          })
-        } else if (candidate.mediaType === "TV_SERIES") {
-          if (!candidate.sonarrId) {
-            throw new Error(
-              `TV series candidate ${candidate.id} does not have a Sonarr ID`
-            )
-          }
-
-          // Get Sonarr config from database
-          const sonarrServer = await prisma.sonarr.findFirst({
-            where: { isActive: true },
-          })
-
-          if (!sonarrServer) {
-            throw new Error("No active Sonarr server configured")
-          }
-
-          const sonarrConfig = {
-            name: sonarrServer.name,
-            url: sonarrServer.url,
-            apiKey: sonarrServer.apiKey,
-            publicUrl: sonarrServer.publicUrl || undefined,
-          }
-
-          // Delete from Sonarr
-          const deleteResult = await deleteSonarrSeries(
-            sonarrConfig,
-            candidate.sonarrId,
-            deleteFiles,
-            false // Don't add import exclusion
-          )
-
-          if (!deleteResult.success) {
-            throw new Error(
-              deleteResult.error || "Failed to delete series from Sonarr"
-            )
-          }
-
-          logger.debug("Deleted TV series from Sonarr", {
-            sonarrId: candidate.sonarrId,
-            title: candidate.title,
-          })
-        } else {
-          throw new Error(`Unsupported media type: ${candidate.mediaType}`)
-        }
-
-        // Update candidate status
-        await prisma.maintenanceCandidate.update({
-          where: { id: candidate.id },
-          data: {
-            reviewStatus: "DELETED",
-            deletedAt: new Date(),
-          },
-        })
-
-        // Create deletion log entry
-        await prisma.maintenanceDeletionLog.create({
-          data: {
-            candidateId: candidate.id,
-            mediaType: candidate.mediaType,
-            title: candidate.title,
-            year: candidate.year,
-            fileSize: candidate.fileSize,
-            deletedBy: userId,
-            deletedFrom:
-              candidate.mediaType === "MOVIE" ? "Radarr" : "Sonarr",
-            filesDeleted: deleteFiles,
-            ruleNames: [candidate.scan.rule.name],
-          },
-        })
-
-        result.success++
-
-        logger.info("Successfully deleted media", {
-          candidateId: candidate.id,
-          title: candidate.title,
-          mediaType: candidate.mediaType,
-        })
-      } catch (error) {
-        result.failed++
-
-        const errorMessage =
-          error instanceof Error ? error.message : "Unknown error occurred"
-        result.errors.push(`${candidate.title}: ${errorMessage}`)
-
-        // Update candidate with error
-        await prisma.maintenanceCandidate.update({
-          where: { id: candidate.id },
-          data: {
-            deletionError: errorMessage,
-          },
-        })
-
-        logger.error("Failed to delete media", error, {
-          candidateId: candidate.id,
-          title: candidate.title,
-          mediaType: candidate.mediaType,
-        })
-      }
-
-      // Report progress
-      if (onProgress) {
-        const percent = Math.floor(((i + 1) / candidates.length) * 100)
-        onProgress(percent)
-      }
-    }
-
-    const duration = Date.now() - startTime
-    logger.info("Deletion execution completed", {
-      success: result.success,
-      failed: result.failed,
-      duration,
-    })
-
-    return result
-  } catch (error) {
-    const duration = Date.now() - startTime
-    logger.error("Deletion execution failed", error, { duration, userId })
-
-    result.errors.push(
-      error instanceof Error ? error.message : "Unknown error occurred"
-    )
-    return result
-  }
-}
diff --git a/lib/maintenance/field-registry.ts b/lib/maintenance/field-registry.ts
deleted file mode 100644
index 6db259c8..00000000
--- a/lib/maintenance/field-registry.ts
+++ /dev/null
@@ -1,1030 +0,0 @@
-/**
- * Field Registry for Maintenance Rules
- *
- * Centralized definition of all available fields from multiple data sources
- * with metadata for UI generation, validation, and evaluation.
- *
- * **Data Sources:**
- * - Tautulli: Playback statistics, watch history, file metadata, and media information
- *   (API: get_library_media_info endpoint)
- * - Plex: Media metadata via Tautulli (ratings, genres, library organization)
- * - Radarr: Movie monitoring status, quality profiles, file availability
- *   (API: /api/v3/movie endpoint)
- * - Sonarr: Series monitoring status, episode counts, series status
- *   (API: /api/v3/series endpoint)
- *
- * **Field Naming Convention:**
- * - Direct fields: `fieldName` (e.g., `playCount`, `title`)
- * - Nested fields: `service.field` (e.g., `radarr.monitored`, `sonarr.status`)
- *
- * **Adding New Fields:**
- * 1. Add to FIELD_DEFINITIONS array with required properties
- * 2. Document source API endpoint and field mapping in comments
- * 3. Update scanner to fetch this data (lib/maintenance/scanner.ts)
- * 4. Update MediaItem interface in rule-evaluator.ts if needed
- * 5. Add validation schema if applicable
- *
- * **Data Refresh:**
- * - Tautulli data: Fetched on-demand during maintenance scans
- * - Radarr/Sonarr data: Fetched if integration is configured, otherwise null
- * - All data cached per scan execution
- */
-
-import { MediaType } from "@/lib/validations/maintenance"
-
-// Field type definitions
-export type FieldType = 'string' | 'number' | 'date' | 'boolean' | 'array' | 'enum'
-export type DataSource = 'plex' | 'tautulli' | 'radarr' | 'sonarr' | 'overseerr'
-
-// Comparison operators by field type
-export type StringOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'regex' | 'in' | 'notIn'
-export type NumberOperator = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'between'
-export type DateOperator = 'before' | 'after' | 'between' | 'olderThan' | 'newerThan' | 'null' | 'notNull'
-export type BooleanOperator = 'equals' | 'notEquals'
-export type ArrayOperator = 'contains' | 'notContains' | 'containsAny' | 'containsAll' | 'isEmpty' | 'isNotEmpty'
-
-export type ComparisonOperator = StringOperator | NumberOperator | DateOperator | BooleanOperator | ArrayOperator
-
-// Field metadata for UI generation and validation
-export interface FieldDefinition {
-  key: string
-  label: string
-  description?: string
-  type: FieldType
-  dataSource: DataSource
-  mediaTypes: MediaType[] // MOVIE, TV_SERIES, EPISODE
-  allowedOperators: ComparisonOperator[]
-  enumValues?: Array<{ value: string; label: string }> // For enum types
-  unit?: 'bytes' | 'seconds' | 'minutes' | 'hours' | 'days' | 'kbps' // For display/conversion
-  category: 'metadata' | 'playback' | 'file' | 'quality' | 'external' // For UI grouping
-  min?: number // Minimum value for number fields
-  max?: number // Maximum value for number fields
-}
-
-// Comprehensive field registry
-export const FIELD_DEFINITIONS: FieldDefinition[] = [
-  // === METADATA CATEGORY ===
-  // Source: Tautulli get_library_media_info endpoint
-  // These fields come from Plex metadata accessed via Tautulli
-
-  // Source API: Tautulli get_library_media_info → item.title
-  // Field mapping: Direct string from Plex metadata
-  {
-    key: 'title',
-    label: 'Title',
-    type: 'string',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'contains', 'notContains', 'startsWith', 'regex'],
-    category: 'metadata',
-  },
-  // Source API: Tautulli get_library_media_info → item.year
-  // Field mapping: Release year from Plex metadata
-  {
-    key: 'year',
-    label: 'Year',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    category: 'metadata',
-    min: 1900,
-    max: 2100,
-  },
-
-  // Source API: Tautulli get_library_media_info → item.rating
-  // Field mapping: User-set rating in Plex (0-10 scale), may be null
-  {
-    key: 'rating',
-    label: 'Rating (User)',
-    description: 'Plex user rating (0-10)',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between', 'null', 'notNull'],
-    category: 'metadata',
-    min: 0,
-    max: 10,
-  },
-
-  // Source API: Tautulli get_library_media_info → item.audience_rating
-  // Field mapping: TMDB/IMDB public rating, may be null
-  {
-    key: 'audienceRating',
-    label: 'Audience Rating',
-    description: 'TMDB/IMDB audience rating',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between', 'null', 'notNull'],
-    category: 'metadata',
-    min: 0,
-    max: 10,
-  },
-
-  // Source API: Tautulli get_library_media_info → item.content_rating
-  // Field mapping: Age rating string (e.g., "PG", "PG-13", "R", "TV-MA")
-  {
-    key: 'contentRating',
-    label: 'Content Rating',
-    description: 'Age rating (PG, PG-13, R, etc.)',
-    type: 'string',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    category: 'metadata',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.genres
-  // Field mapping: Array of genre strings from Plex metadata
-  {
-    key: 'genres',
-    label: 'Genres',
-    type: 'array',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['contains', 'notContains', 'containsAny', 'containsAll', 'isEmpty'],
-    category: 'metadata',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.labels
-  // Field mapping: Array of user-applied labels/tags from Plex
-  {
-    key: 'labels',
-    label: 'Labels/Tags',
-    type: 'array',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['contains', 'notContains', 'containsAny', 'containsAll', 'isEmpty'],
-    category: 'metadata',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.section_id
-  // Field mapping: Plex library section ID (string)
-  {
-    key: 'libraryId',
-    label: 'Library',
-    type: 'string',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    category: 'metadata',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.studio
-  // Field mapping: Production studio name
-  {
-    key: 'studio',
-    label: 'Studio',
-    description: 'Production studio',
-    type: 'string',
-    dataSource: 'plex',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'contains', 'notContains', 'in', 'notIn', 'null', 'notNull'],
-    category: 'metadata',
-  },
-
-  // Source API: Plex library metadata → item.Collection
-  // Field mapping: Array of Plex collection names
-  {
-    key: 'collections',
-    label: 'Collections',
-    description: 'Plex collections the media belongs to',
-    type: 'array',
-    dataSource: 'plex',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['contains', 'notContains', 'containsAny', 'containsAll', 'isEmpty', 'isNotEmpty'],
-    category: 'metadata',
-  },
-
-  // Source API: Plex /playlists endpoint
-  // Field mapping: Array of Plex playlist names containing this media
-  {
-    key: 'plex.playlists',
-    label: 'Playlists',
-    description: 'Plex playlists this media belongs to',
-    type: 'array',
-    dataSource: 'plex',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['contains', 'notContains', 'containsAny', 'containsAll', 'isEmpty', 'isNotEmpty'],
-    category: 'metadata',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.originally_available_at
-  // Field mapping: Original release date
-  {
-    key: 'originallyAvailableAt',
-    label: 'Original Release Date',
-    description: 'Original release/premiere date',
-    type: 'date',
-    dataSource: 'plex',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan', 'null', 'notNull'],
-    unit: 'days',
-    category: 'metadata',
-  },
-
-  // === PLAYBACK CATEGORY ===
-  // Source: Tautulli get_library_media_info endpoint
-  // These fields track viewing history and activity
-
-  // Source API: Tautulli get_library_media_info → item.play_count
-  // Field mapping: Number of times media has been fully watched
-  {
-    key: 'playCount',
-    label: 'Play Count',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    category: 'playback',
-    min: 0,
-  },
-
-  // Source API: Computed from Tautulli data
-  // Field mapping: Derived field (true if play_count === 0 or null)
-  {
-    key: 'neverWatched',
-    label: 'Never Watched',
-    description: 'Media that has never been played',
-    type: 'boolean',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals'],
-    category: 'playback',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.last_played
-  // Field mapping: Unix timestamp of most recent playback, may be null
-  // Data refresh: Updated when media is watched
-  {
-    key: 'lastWatchedAt',
-    label: 'Last Watched Date',
-    type: 'date',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan', 'null', 'notNull'],
-    unit: 'days',
-    category: 'playback',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.added_at
-  // Field mapping: Unix timestamp when media was added to library
-  // Data refresh: Set once when media added, rarely changes
-  {
-    key: 'addedAt',
-    label: 'Date Added',
-    type: 'date',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan'],
-    unit: 'days',
-    category: 'playback',
-  },
-
-  // Computed field: Days since added
-  // Field mapping: Computed from addedAt - current time in days
-  {
-    key: 'daysSinceAdded',
-    label: 'Days Since Added',
-    description: 'Number of days since media was added to library',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'days',
-    category: 'playback',
-    min: 0,
-  },
-
-  // Computed field: Days since last watched
-  // Field mapping: Computed from lastWatchedAt - current time in days (null if never watched)
-  {
-    key: 'daysSinceWatched',
-    label: 'Days Since Watched',
-    description: 'Number of days since last playback (null if never watched)',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between', 'null', 'notNull'],
-    unit: 'days',
-    category: 'playback',
-    min: 0,
-  },
-
-  // === FILE CATEGORY ===
-  // Source: Tautulli get_library_media_info endpoint
-  // These fields describe the physical media file properties
-
-  // Source API: Tautulli get_library_media_info → item.file_size
-  // Field mapping: File size in bytes (for movies) or total series size (for TV)
-  {
-    key: 'fileSize',
-    label: 'File Size',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'bytes',
-    category: 'file',
-    min: 0,
-  },
-
-  // Source API: Tautulli get_library_media_info → item.duration
-  // Field mapping: Runtime in milliseconds, converted to minutes for display
-  {
-    key: 'duration',
-    label: 'Duration',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'minutes',
-    category: 'file',
-    min: 0,
-  },
-
-  // Source API: Tautulli get_library_media_info → item.file
-  // Field mapping: Full filesystem path to media file
-  // Note: This is an advanced field - too specific for most maintenance rules
-  {
-    key: 'filePath',
-    label: 'File Path (Advanced)',
-    description: 'Full filesystem path - use for specific folder-based rules only',
-    type: 'string',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['contains', 'notContains', 'startsWith', 'regex'],
-    category: 'file',
-  },
-
-  // === QUALITY CATEGORY ===
-  // Source: Tautulli get_library_media_info endpoint
-  // These fields describe video/audio quality and encoding
-
-  // Source API: Tautulli get_library_media_info → item.video_resolution
-  // Field mapping: Normalized resolution value (e.g., "1080", "720", "4k", "sd")
-  {
-    key: 'resolution',
-    label: 'Resolution',
-    type: 'enum',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: '4k', label: '4K' },
-      { value: '1080', label: '1080p' },
-      { value: '720', label: '720p' },
-      { value: 'sd', label: 'SD' },
-    ],
-    category: 'quality',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.video_codec
-  // Field mapping: Video codec identifier (e.g., "h264", "hevc", "av1")
-  {
-    key: 'videoCodec',
-    label: 'Video Codec',
-    type: 'enum',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'h264', label: 'H.264' },
-      { value: 'hevc', label: 'HEVC/H.265' },
-      { value: 'av1', label: 'AV1' },
-      { value: 'mpeg4', label: 'MPEG-4' },
-      { value: 'mpeg2video', label: 'MPEG-2' },
-    ],
-    category: 'quality',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.audio_codec
-  // Field mapping: Audio codec identifier (e.g., "aac", "ac3", "dts")
-  {
-    key: 'audioCodec',
-    label: 'Audio Codec',
-    type: 'enum',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'aac', label: 'AAC' },
-      { value: 'ac3', label: 'AC3' },
-      { value: 'eac3', label: 'E-AC3' },
-      { value: 'dts', label: 'DTS' },
-      { value: 'truehd', label: 'TrueHD' },
-      { value: 'flac', label: 'FLAC' },
-      { value: 'mp3', label: 'MP3' },
-    ],
-    category: 'quality',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.container
-  // Field mapping: Container format (e.g., "mkv", "mp4", "avi")
-  {
-    key: 'container',
-    label: 'Container Format',
-    type: 'enum',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'mkv', label: 'MKV' },
-      { value: 'mp4', label: 'MP4' },
-      { value: 'avi', label: 'AVI' },
-      { value: 'mov', label: 'MOV' },
-      { value: 'wmv', label: 'WMV' },
-    ],
-    category: 'quality',
-  },
-
-  // Source API: Tautulli get_library_media_info → item.bitrate
-  // Field mapping: Overall bitrate in kbps
-  {
-    key: 'bitrate',
-    label: 'Bitrate',
-    type: 'number',
-    dataSource: 'tautulli',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'kbps',
-    category: 'quality',
-    min: 0,
-  },
-
-  // === RADARR FIELDS (Movies only) ===
-  // Source: Radarr /api/v3/movie endpoint
-  // Requires: Radarr integration must be configured
-  // Data refresh: Fetched on-demand during maintenance scans
-  // Note: Returns null if Radarr integration not configured or movie not found
-
-  // Source API: Radarr /api/v3/movie → movie.hasFile
-  // Field mapping: Boolean indicating if movie file exists in Radarr
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.hasFile',
-    label: 'Has File (Radarr)',
-    type: 'boolean',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals'],
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.monitored
-  // Field mapping: Boolean indicating if movie is monitored for new releases
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.monitored',
-    label: 'Monitored (Radarr)',
-    type: 'boolean',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals'],
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.qualityProfileId
-  // Field mapping: Integer ID of quality profile (match with /api/v3/qualityprofile)
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.qualityProfileId',
-    label: 'Quality Profile (Radarr)',
-    type: 'number',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    category: 'external',
-    min: 1,
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.minimumAvailability
-  // Field mapping: Enum value for minimum availability setting
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.minimumAvailability',
-    label: 'Minimum Availability (Radarr)',
-    type: 'enum',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'announced', label: 'Announced' },
-      { value: 'inCinemas', label: 'In Cinemas' },
-      { value: 'released', label: 'Released' },
-      { value: 'preDB', label: 'PreDB' },
-    ],
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.status
-  // Field mapping: Movie download/availability status
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.status',
-    label: 'Status (Radarr)',
-    description: 'Movie status in Radarr',
-    type: 'enum',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'announced', label: 'Announced' },
-      { value: 'inCinemas', label: 'In Cinemas' },
-      { value: 'released', label: 'Released' },
-      { value: 'deleted', label: 'Deleted' },
-    ],
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.ratings.tmdb.value
-  // Field mapping: TMDB community rating (0-10)
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.tmdbRating',
-    label: 'TMDB Rating (Radarr)',
-    description: 'TMDB community rating (0-10)',
-    type: 'number',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between', 'null', 'notNull'],
-    category: 'external',
-    min: 0,
-    max: 10,
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.digitalRelease
-  // Field mapping: Digital release date
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.digitalRelease',
-    label: 'Digital Release Date (Radarr)',
-    description: 'When movie was released digitally',
-    type: 'date',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan', 'null', 'notNull'],
-    unit: 'days',
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.inCinemas
-  // Field mapping: Theatrical release date
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.inCinemas',
-    label: 'In Cinemas Date (Radarr)',
-    description: 'Theatrical release date',
-    type: 'date',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan', 'null', 'notNull'],
-    unit: 'days',
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.runtime
-  // Field mapping: Movie runtime in minutes
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.runtime',
-    label: 'Runtime (Radarr)',
-    description: 'Movie runtime in minutes',
-    type: 'number',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'minutes',
-    category: 'external',
-    min: 0,
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.tags
-  // Field mapping: Array of tag IDs assigned to movie
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.tags',
-    label: 'Tags (Radarr)',
-    description: 'Tag IDs assigned in Radarr',
-    type: 'array',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['contains', 'notContains', 'containsAny', 'containsAll', 'isEmpty', 'isNotEmpty'],
-    category: 'external',
-  },
-
-  // Source API: Radarr /api/v3/movie → movie.sizeOnDisk
-  // Field mapping: Actual file size on disk in bytes
-  // Requirements: Radarr integration configured, movie matched by TMDB ID
-  {
-    key: 'radarr.sizeOnDisk',
-    label: 'Size on Disk (Radarr)',
-    description: 'Actual file size in Radarr',
-    type: 'number',
-    dataSource: 'radarr',
-    mediaTypes: ['MOVIE'],
-    allowedOperators: ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'bytes',
-    category: 'external',
-    min: 0,
-  },
-
-  // === SONARR FIELDS (TV only) ===
-  // Source: Sonarr /api/v3/series endpoint
-  // Requires: Sonarr integration must be configured
-  // Data refresh: Fetched on-demand during maintenance scans
-  // Note: Returns null if Sonarr integration not configured or series not found
-
-  // Source API: Sonarr /api/v3/series → series.monitored
-  // Field mapping: Boolean indicating if series is monitored for new episodes
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.monitored',
-    label: 'Monitored (Sonarr)',
-    type: 'boolean',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals'],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.status
-  // Field mapping: Enum value for series status ("continuing" or "ended")
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.status',
-    label: 'Series Status (Sonarr)',
-    type: 'enum',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'continuing', label: 'Continuing' },
-      { value: 'ended', label: 'Ended' },
-    ],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.episodeFileCount
-  // Field mapping: Number of episode files downloaded/available
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.episodeFileCount',
-    label: 'Episode File Count (Sonarr)',
-    description: 'Number of episode files available',
-    type: 'number',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual'],
-    category: 'external',
-    min: 0,
-  },
-
-  // Source API: Sonarr /api/v3/series → series.percentOfEpisodes
-  // Field mapping: Calculated percentage (episodeFileCount / episodeCount * 100)
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.percentOfEpisodes',
-    label: 'Percent Complete (Sonarr)',
-    description: 'Percentage of episodes available',
-    type: 'number',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual'],
-    category: 'external',
-    min: 0,
-    max: 100,
-  },
-
-  // Source API: Sonarr /api/v3/series → series.seriesType
-  // Field mapping: Type of series (standard, daily, anime)
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.seriesType',
-    label: 'Series Type (Sonarr)',
-    description: 'Standard, daily, or anime series',
-    type: 'enum',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'standard', label: 'Standard' },
-      { value: 'daily', label: 'Daily' },
-      { value: 'anime', label: 'Anime' },
-    ],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.network
-  // Field mapping: Original broadcast network
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.network',
-    label: 'Network (Sonarr)',
-    description: 'Original broadcast network',
-    type: 'string',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'contains', 'notContains', 'in', 'notIn'],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.statistics.seasonCount
-  // Field mapping: Total number of seasons
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.seasonCount',
-    label: 'Season Count (Sonarr)',
-    description: 'Total number of seasons',
-    type: 'number',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    category: 'external',
-    min: 0,
-  },
-
-  // Source API: Sonarr /api/v3/series → series.statistics.totalEpisodeCount
-  // Field mapping: Total episodes in the series
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.totalEpisodeCount',
-    label: 'Total Episodes (Sonarr)',
-    description: 'Total episodes in the series',
-    type: 'number',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    category: 'external',
-    min: 0,
-  },
-
-  // Source API: Sonarr /api/v3/series → series.firstAired
-  // Field mapping: First episode air date
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.firstAired',
-    label: 'First Aired (Sonarr)',
-    description: 'First episode air date',
-    type: 'date',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan', 'null', 'notNull'],
-    unit: 'days',
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.ended
-  // Field mapping: Whether the series has ended
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.ended',
-    label: 'Ended (Sonarr)',
-    description: 'Whether the series has finished airing',
-    type: 'boolean',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals'],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.tags
-  // Field mapping: Array of tag IDs assigned to series
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.tags',
-    label: 'Tags (Sonarr)',
-    description: 'Tag IDs assigned in Sonarr',
-    type: 'array',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['contains', 'notContains', 'containsAny', 'containsAll', 'isEmpty', 'isNotEmpty'],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.statistics.sizeOnDisk
-  // Field mapping: Total size on disk in bytes
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.sizeOnDisk',
-    label: 'Size on Disk (Sonarr)',
-    description: 'Total series size on disk',
-    type: 'number',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual', 'between'],
-    unit: 'bytes',
-    category: 'external',
-    min: 0,
-  },
-
-  // Source API: Sonarr /api/v3/series → series.certification
-  // Field mapping: Content rating (TV-MA, TV-14, etc.)
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.certification',
-    label: 'Certification (Sonarr)',
-    description: 'TV content rating (TV-MA, TV-14, etc.)',
-    type: 'string',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    category: 'external',
-  },
-
-  // Source API: Sonarr /api/v3/series → series.qualityProfileId
-  // Field mapping: Quality profile ID
-  // Requirements: Sonarr integration configured, series matched by TVDB ID
-  {
-    key: 'sonarr.qualityProfileId',
-    label: 'Quality Profile (Sonarr)',
-    description: 'Quality profile ID in Sonarr',
-    type: 'number',
-    dataSource: 'sonarr',
-    mediaTypes: ['TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    category: 'external',
-    min: 1,
-  },
-
-  // === OVERSEERR FIELDS ===
-  // Source: Overseerr /api/v1/media and /api/v1/request endpoints
-  // Requires: Overseerr integration must be configured
-  // Data refresh: Fetched on-demand during maintenance scans
-  // Note: Returns null if Overseerr integration not configured or media not found
-
-  // Source API: Overseerr /api/v1/media/{tmdbId} → mediaInfo.status
-  // Field mapping: Boolean indicating if there's an active request
-  // Requirements: Overseerr integration configured, media matched by TMDB ID
-  {
-    key: 'overseerr.isRequested',
-    label: 'Is Requested (Overseerr)',
-    description: 'Whether media has an active request',
-    type: 'boolean',
-    dataSource: 'overseerr',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals'],
-    category: 'external',
-  },
-
-  // Source API: Overseerr /api/v1/media/{tmdbId} → mediaInfo.status
-  // Field mapping: Media request/availability status
-  // Requirements: Overseerr integration configured, media matched by TMDB ID
-  {
-    key: 'overseerr.status',
-    label: 'Request Status (Overseerr)',
-    description: 'Media request status in Overseerr',
-    type: 'enum',
-    dataSource: 'overseerr',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'in', 'notIn'],
-    enumValues: [
-      { value: 'unknown', label: 'Unknown' },
-      { value: 'pending', label: 'Pending' },
-      { value: 'processing', label: 'Processing' },
-      { value: 'partially_available', label: 'Partially Available' },
-      { value: 'available', label: 'Available' },
-    ],
-    category: 'external',
-  },
-
-  // Source API: Overseerr /api/v1/request → request.requestedBy.displayName
-  // Field mapping: Username who requested the media
-  // Requirements: Overseerr integration configured, media has active request
-  {
-    key: 'overseerr.requestedBy',
-    label: 'Requested By (Overseerr)',
-    description: 'User who requested the media',
-    type: 'string',
-    dataSource: 'overseerr',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'contains', 'notContains', 'in', 'notIn', 'null', 'notNull'],
-    category: 'external',
-  },
-
-  // Source API: Overseerr /api/v1/request → request.createdAt
-  // Field mapping: When the request was created
-  // Requirements: Overseerr integration configured, media has active request
-  {
-    key: 'overseerr.requestedAt',
-    label: 'Requested Date (Overseerr)',
-    description: 'When the media was requested',
-    type: 'date',
-    dataSource: 'overseerr',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['before', 'after', 'between', 'olderThan', 'newerThan', 'null', 'notNull'],
-    unit: 'days',
-    category: 'external',
-  },
-
-  // Source API: Overseerr /api/v1/request → requests.length
-  // Field mapping: Total number of requests for this media
-  // Requirements: Overseerr integration configured
-  {
-    key: 'overseerr.requestCount',
-    label: 'Request Count (Overseerr)',
-    description: 'Number of times this media has been requested',
-    type: 'number',
-    dataSource: 'overseerr',
-    mediaTypes: ['MOVIE', 'TV_SERIES'],
-    allowedOperators: ['equals', 'notEquals', 'greaterThan', 'greaterThanOrEqual', 'lessThan', 'lessThanOrEqual'],
-    category: 'external',
-    min: 0,
-  },
-]
-
-/**
- * Get fields filtered by media type
- */
-export function getFieldsForMediaType(mediaType: MediaType): FieldDefinition[] {
-  return FIELD_DEFINITIONS.filter(f => f.mediaTypes.includes(mediaType))
-}
-
-/**
- * Get fields grouped by category
- */
-export function getFieldsByCategory(mediaType: MediaType): Record<string, FieldDefinition[]> {
-  const fields = getFieldsForMediaType(mediaType)
-  const grouped: Record<string, FieldDefinition[]> = {
-    metadata: [],
-    playback: [],
-    file: [],
-    quality: [],
-    external: [],
-  }
-
-  fields.forEach(field => {
-    grouped[field.category].push(field)
-  })
-
-  return grouped
-}
-
-/**
- * Get fields grouped by data source (recommended for UI organization)
- */
-export function getFieldsByDataSource(mediaType: MediaType): Record<string, FieldDefinition[]> {
-  const fields = getFieldsForMediaType(mediaType)
-  const grouped: Record<string, FieldDefinition[]> = {
-    plex: [],
-    tautulli: [],
-    radarr: [],
-    sonarr: [],
-    overseerr: [],
-  }
-
-  fields.forEach(field => {
-    grouped[field.dataSource].push(field)
-  })
-
-  return grouped
-}
-
-/**
- * Get field definition by key
- */
-export function getFieldDefinition(key: string): FieldDefinition | undefined {
-  return FIELD_DEFINITIONS.find(f => f.key === key)
-}
-
-/**
- * Format operator label for UI display
- */
-export function formatOperatorLabel(operator: ComparisonOperator): string {
-  const labels: Record<string, string> = {
-    equals: 'equals',
-    notEquals: 'not equals',
-    contains: 'contains',
-    notContains: 'does not contain',
-    startsWith: 'starts with',
-    endsWith: 'ends with',
-    regex: 'matches regex',
-    in: 'is one of',
-    notIn: 'is not one of',
-    greaterThan: 'greater than',
-    greaterThanOrEqual: 'greater than or equal to',
-    lessThan: 'less than',
-    lessThanOrEqual: 'less than or equal to',
-    between: 'between',
-    before: 'before',
-    after: 'after',
-    olderThan: 'older than',
-    newerThan: 'newer than',
-    null: 'is empty',
-    notNull: 'is not empty',
-    containsAny: 'contains any of',
-    containsAll: 'contains all of',
-    isEmpty: 'is empty',
-    isNotEmpty: 'is not empty',
-  }
-
-  return labels[operator] || operator
-}
-
-/**
- * Generate unique ID for condition/group
- */
-export function generateId(): string {
-  return Math.random().toString(36).substring(2, 11)
-}
diff --git a/lib/maintenance/rule-evaluator.ts b/lib/maintenance/rule-evaluator.ts
deleted file mode 100644
index 858190dd..00000000
--- a/lib/maintenance/rule-evaluator.ts
+++ /dev/null
@@ -1,875 +0,0 @@
-/**
- * Enhanced Rule Evaluator with Hierarchical Support
- *
- * Evaluates maintenance rules against media items using a recursive tree-based approach.
- * Supports nested AND/OR groups and comprehensive field comparisons.
- *
- * ## Evaluation Algorithm
- *
- * The evaluator uses a recursive tree traversal approach:
- *
- * 1. **Node Type Check**: Each node is either a `condition` or a `group`
- * 2. **Condition Evaluation**: Single conditions compare field values using operators
- * 3. **Group Evaluation**: Groups recursively evaluate children and combine with AND/OR
- *
- * ```
- *          GROUP (AND)
- *         /    |     \
- *    cond1  cond2   GROUP (OR)
- *                   /        \
- *               cond3      cond4
- * ```
- *
- * For the above tree:
- * - First, cond3 and cond4 are evaluated and combined with OR
- * - Then cond1, cond2, and the OR result are combined with AND
- *
- * ## Type-Specific Comparisons
- *
- * Different field types support different operators:
- * - **String**: equals, contains, startsWith, endsWith, regex, in/notIn
- * - **Number**: equals, greaterThan, lessThan, between
- * - **Date**: before, after, olderThan, newerThan, between
- * - **Boolean**: equals, notEquals
- * - **Array**: contains, containsAny, containsAll, isEmpty
- *
- * ## Special Cases
- *
- * - **Null handling**: `null` and `notNull` operators check for presence
- * - **Never watched**: `lastWatchedAt` with `olderThan` returns true for null (never watched)
- * - **Legacy format**: Auto-migrates old flat criteria format to hierarchical
- *
- * @module lib/maintenance/rule-evaluator
- */
-
-import {
-  migrateLegacyRuleCriteria,
-  type RuleCriteria,
-  type Condition,
-  type ConditionGroup,
-} from "@/lib/validations/maintenance"
-
-import type {
-  StringOperator,
-  NumberOperator,
-  DateOperator,
-  BooleanOperator,
-  ArrayOperator,
-} from "./field-registry"
-import { FIELD_DEFINITIONS } from "./field-registry"
-
-/**
- * Extended media item interface for rule evaluation.
- *
- * Combines data from multiple sources (Plex, Tautulli, Radarr, Sonarr) into
- * a unified interface for rule evaluation. All fields are optional except
- * for the core identification and playback fields.
- *
- * ## Field Sources
- *
- * - **Plex**: Core metadata (title, year, rating, genres)
- * - **Tautulli**: Playback statistics (playCount, lastWatchedAt)
- * - **Radarr**: Movie management data (hasFile, monitored, quality)
- * - **Sonarr**: TV series management data (status, episodeFileCount)
- *
- * @example
- * ```ts
- * const item: MediaItem = {
- *   plexRatingKey: "12345",
- *   title: "Example Movie",
- *   year: 2020,
- *   playCount: 0,
- *   lastWatchedAt: null,
- *   fileSize: BigInt(1500000000),
- *   radarr: {
- *     hasFile: true,
- *     monitored: false
- *   }
- * }
- * ```
- */
-export interface MediaItem {
-  // ─── Core Identification ───────────────────────────────────────────────
-
-  /** Internal ID (from Radarr/Sonarr) */
-  id?: string
-  /** Unique Plex rating key identifying this media item */
-  plexRatingKey?: string | null
-  /** Display title of the media */
-  title: string
-  /** Release year */
-  year?: number
-  /** Media type (MOVIE, TV_SERIES, EPISODE) */
-  mediaType?: 'MOVIE' | 'TV_SERIES' | 'EPISODE'
-  /** ID of the Plex library containing this item */
-  libraryId?: string
-
-  // ─── Playback Statistics ───────────────────────────────────────────────
-
-  /** Total number of times this item has been played */
-  playCount?: number
-  /** Date/time of last playback, null if never watched */
-  lastWatchedAt?: Date | null
-  /** Date/time when item was added to library */
-  addedAt?: Date | null
-
-  // ─── File Information ──────────────────────────────────────────────────
-
-  /** Total file size in bytes */
-  fileSize?: number | bigint | null
-  /** Full path to the media file on disk */
-  filePath?: string | null
-  /** Duration in seconds */
-  duration?: number | null
-
-  // ─── Quality/Technical ─────────────────────────────────────────────────
-
-  /** Video resolution (e.g., "1080p", "4K") */
-  resolution?: string | null
-  /** Video codec (e.g., "h264", "hevc") */
-  videoCodec?: string | null
-  /** Primary audio codec (e.g., "aac", "ac3") */
-  audioCodec?: string | null
-  /** Container format (e.g., "mkv", "mp4") */
-  container?: string | null
-  /** Video bitrate in kbps */
-  bitrate?: number | null
-
-  // ─── Metadata ──────────────────────────────────────────────────────────
-
-  /** Plex/TMDB rating (0-10 scale) */
-  rating?: number | null
-  /** Audience rating (0-10 scale) */
-  audienceRating?: number | null
-  /** Content rating (e.g., "PG-13", "TV-MA") */
-  contentRating?: string | null
-  /** Genre tags */
-  genres?: string[]
-  /** User-assigned labels */
-  labels?: string[]
-  /** Production studio */
-  studio?: string | null
-  /** Plex collections this media belongs to */
-  collections?: string[]
-  /** Original release/premiere date */
-  originallyAvailableAt?: Date | null
-
-  // ─── External Service Data ─────────────────────────────────────────────
-
-  /** Tautulli integration data (Plex playback, file info, quality) */
-  tautulli?: {
-    /** Plex rating key */
-    plexRatingKey?: string
-    /** Play count from Tautulli */
-    playCount?: number
-    /** Last watched date from Tautulli */
-    lastWatchedAt?: Date | null
-    /** Date added to Plex */
-    addedAt?: Date | null
-    /** File size in bytes */
-    fileSize?: number | null
-    /** Full file path */
-    filePath?: string | null
-    /** Duration in minutes */
-    duration?: number | null
-    /** Video codec (h264, hevc, etc.) */
-    videoCodec?: string | null
-    /** Audio codec (aac, ac3, etc.) */
-    audioCodec?: string | null
-    /** Video resolution (1080, 4k, etc.) */
-    resolution?: string | null
-    /** Video bitrate in kbps */
-    bitrate?: number | null
-    /** Container format (mkv, mp4, etc.) */
-    container?: string | null
-  } | null
-
-  /** Radarr integration data for movies */
-  radarr?: {
-    /** Whether Radarr has a file for this movie */
-    hasFile?: boolean
-    /** Whether the movie is being monitored for upgrades */
-    monitored?: boolean
-    /** Quality profile ID in Radarr */
-    qualityProfileId?: number
-    /** Minimum availability setting */
-    minimumAvailability?: string
-    /** Movie status (announced, inCinemas, released, deleted) */
-    status?: string
-    /** TMDB rating (0-10) */
-    tmdbRating?: number | null
-    /** Digital release date */
-    digitalRelease?: Date | null
-    /** Theatrical release date */
-    inCinemas?: Date | null
-    /** Runtime in minutes */
-    runtime?: number | null
-    /** Tag IDs assigned in Radarr */
-    tags?: number[]
-    /** Size on disk in bytes */
-    sizeOnDisk?: number
-    /** Date added to Radarr */
-    addedAt?: Date | null
-  }
-
-  /** Sonarr integration data for TV series */
-  sonarr?: {
-    /** Whether the series is being monitored */
-    monitored?: boolean
-    /** Series status (continuing, ended, etc.) */
-    status?: string
-    /** Number of episode files on disk */
-    episodeFileCount?: number
-    /** Percentage of episodes with files */
-    percentOfEpisodes?: number | null
-    /** Series type (standard, daily, anime) */
-    seriesType?: string
-    /** Original broadcast network */
-    network?: string | null
-    /** Total number of seasons */
-    seasonCount?: number
-    /** Total episodes in the series */
-    totalEpisodeCount?: number
-    /** First episode air date */
-    firstAired?: Date | null
-    /** Whether the series has ended */
-    ended?: boolean
-    /** Tag IDs assigned in Sonarr */
-    tags?: number[]
-    /** Total size on disk in bytes */
-    sizeOnDisk?: number
-    /** Content rating (TV-MA, TV-14, etc.) */
-    certification?: string | null
-    /** Quality profile ID in Sonarr */
-    qualityProfileId?: number
-    /** Date added to Sonarr */
-    addedAt?: Date | null
-  }
-
-  /** Plex integration data (direct from Plex server) */
-  plex?: {
-    /** Plex rating key */
-    ratingKey?: string
-    /** View count from Plex */
-    viewCount?: number
-    /** Last viewed timestamp */
-    lastViewedAt?: Date | null
-    /** Date added to Plex library */
-    addedAt?: Date | null
-    /** Poster/thumb URL */
-    thumb?: string | null
-    /** Audience rating (0-10) */
-    audienceRating?: number | null
-    /** Content rating (PG-13, R, etc.) */
-    contentRating?: string | null
-    /** Production studio */
-    studio?: string | null
-    /** Duration in milliseconds */
-    duration?: number | null
-    /** GUID for external matching */
-    guid?: string | null
-    /** Plex playlists containing this media */
-    playlists?: string[]
-  } | null
-
-  /** Overseerr integration data for request status */
-  overseerr?: {
-    /** Whether media has an active request */
-    isRequested?: boolean
-    /** Request status (unknown, pending, processing, partially_available, available) */
-    status?: string
-    /** Media status in Overseerr (UNKNOWN, PENDING, PROCESSING, PARTIALLY_AVAILABLE, AVAILABLE) */
-    mediaStatus?: number
-    /** Username who requested the media */
-    requestedBy?: string
-    /** When the request was created */
-    requestedAt?: Date | null
-    /** TMDB ID */
-    tmdbId?: number
-    /** Whether there are any open requests */
-    hasRequest?: boolean
-    /** Total number of requests for this media */
-    requestCount?: number
-  } | null
-}
-
-/**
- * Main entry point for rule evaluation.
- *
- * Evaluates hierarchical rule criteria against a media item to determine
- * if the item matches the rule. Supports both the new hierarchical format
- * and legacy flat format (auto-migrates on first use).
- *
- * ## Evaluation Flow
- *
- * 1. Check for legacy format and migrate if needed
- * 2. Recursively evaluate the criteria tree via `evaluateNode`
- * 3. Return final boolean result
- *
- * ## Legacy Format Detection
- *
- * Legacy format is detected by checking for `type` property. New format
- * always has `type: 'group'` at the root. Legacy format had flat properties
- * like `neverWatched`, `maxPlayCount`, etc.
- *
- * @param item - The media item to evaluate against the rule
- * @param criteria - The rule criteria (hierarchical or legacy format)
- * @returns `true` if the item matches all criteria, `false` otherwise
- *
- * @example
- * ```ts
- * const criteria: RuleCriteria = {
- *   type: 'group',
- *   operator: 'AND',
- *   conditions: [
- *     { type: 'condition', field: 'playCount', operator: 'equals', value: 0 },
- *     { type: 'condition', field: 'addedAt', operator: 'olderThan', value: 365, valueUnit: 'days' }
- *   ]
- * }
- *
- * const matches = evaluateRule(mediaItem, criteria)
- * if (matches) {
- *   console.log('Item matches maintenance rule')
- * }
- * ```
- */
-export function evaluateRule(item: MediaItem, criteria: RuleCriteria | any): boolean {
-  // Check if this is legacy format (has properties like neverWatched, maxPlayCount, etc.)
-  if (criteria && typeof criteria === 'object' && !criteria.type) {
-    // Legacy format detected - migrate it
-    criteria = migrateLegacyRuleCriteria(criteria)
-  }
-
-  return evaluateNode(item, criteria)
-}
-
-/**
- * Recursively evaluates a node in the criteria tree.
- *
- * Handles both leaf nodes (conditions) and branch nodes (groups):
- * - **Conditions**: Evaluated directly via `evaluateCondition`
- * - **Groups**: Recursively evaluate all children and combine with AND/OR
- *
- * @param item - The media item being evaluated
- * @param node - The current node to evaluate (condition or group)
- * @returns `true` if the node evaluates to true, `false` otherwise
- *
- * @internal
- */
-function evaluateNode(item: MediaItem, node: Condition | ConditionGroup): boolean {
-  if (node.type === 'condition') {
-    return evaluateCondition(item, node)
-  } else {
-    // Evaluate group
-    const results = node.conditions.map(child => evaluateNode(item, child))
-
-    if (node.operator === 'AND') {
-      return results.every(r => r === true)
-    } else {
-      return results.some(r => r === true)
-    }
-  }
-}
-
-/**
- * Evaluates a single condition against a media item.
- *
- * Performs type-aware comparison based on the field definition:
- *
- * ## Evaluation Steps
- *
- * 1. Extract field value from item using `getFieldValue`
- * 2. Handle null/notNull operators first (special case)
- * 3. Look up field definition for type information
- * 4. Apply special handling for `lastWatchedAt` with `olderThan` (null = old)
- * 5. Fail if field is null (except for handled special cases)
- * 6. Delegate to type-specific comparison function
- *
- * ## Null Value Handling
- *
- * - `null` operator: Returns true if field is null/undefined
- * - `notNull` operator: Returns true if field has a value
- * - Other operators: Null field values return false (fail safe)
- * - **Exception**: `lastWatchedAt` with `olderThan` treats null as "old"
- *
- * @param item - The media item to evaluate
- * @param condition - The condition to check
- * @returns `true` if the condition is satisfied, `false` otherwise
- *
- * @internal
- */
-function evaluateCondition(item: MediaItem, condition: Condition): boolean {
-  const fieldValue = getFieldValue(item, condition.field)
-  const conditionValue = condition.value
-
-  // Handle null checks first
-  if (condition.operator === 'null') {
-    return fieldValue === null || fieldValue === undefined
-  }
-  if (condition.operator === 'notNull') {
-    return fieldValue !== null && fieldValue !== undefined
-  }
-
-  // Get field definition for type-specific comparison
-  const fieldDef = FIELD_DEFINITIONS.find(f => f.key === condition.field)
-  if (!fieldDef) {
-    console.warn(`Unknown field in condition: ${condition.field}`)
-    return false
-  }
-
-  // Special handling for lastWatchedAt with olderThan operator - null/undefined should match (never watched = old)
-  if (fieldDef.type === 'date' && condition.operator === 'olderThan' && condition.field === 'lastWatchedAt') {
-    if (fieldValue === null || fieldValue === undefined) {
-      return true // Never watched = old
-    }
-  }
-
-  // If field value is null/undefined and not checking for null, fail safe (except for olderThan dates)
-  if (fieldValue === null || fieldValue === undefined) {
-    return false
-  }
-
-  // Type-specific comparisons
-  switch (fieldDef.type) {
-    case 'string':
-      return evaluateStringCondition(
-        fieldValue as string,
-        condition.operator as StringOperator,
-        conditionValue as string | string[]
-      )
-    case 'number':
-      return evaluateNumberCondition(
-        fieldValue as number,
-        condition.operator as NumberOperator,
-        conditionValue as number | number[]
-      )
-    case 'date':
-      return evaluateDateCondition(
-        fieldValue as Date,
-        condition.operator as DateOperator,
-        conditionValue,
-        condition.valueUnit
-      )
-    case 'boolean':
-      return evaluateBooleanCondition(
-        fieldValue as boolean,
-        condition.operator as BooleanOperator,
-        conditionValue as boolean
-      )
-    case 'array':
-      return evaluateArrayCondition(
-        fieldValue as string[],
-        condition.operator as ArrayOperator,
-        conditionValue as string | string[]
-      )
-    case 'enum':
-      // For enum types, if using comparison operators, treat as string comparison
-      if (condition.operator === 'lessThanOrEqual' || condition.operator === 'lessThan' ||
-          condition.operator === 'greaterThanOrEqual' || condition.operator === 'greaterThan') {
-        // Use string comparison for enum values
-        const fieldStr = String(fieldValue)
-        const conditionStr = String(conditionValue)
-        switch (condition.operator) {
-          case 'lessThanOrEqual':
-            return fieldStr <= conditionStr
-          case 'lessThan':
-            return fieldStr < conditionStr
-          case 'greaterThanOrEqual':
-            return fieldStr >= conditionStr
-          case 'greaterThan':
-            return fieldStr > conditionStr
-          default:
-            return false
-        }
-      }
-      return evaluateStringCondition(
-        fieldValue as string,
-        condition.operator as StringOperator,
-        conditionValue as string | string[]
-      )
-    default:
-      return false
-  }
-}
-
-/**
- * Extracts a field value from a media item by key.
- *
- * Supports both direct field access and nested field paths using dot notation.
- *
- * ## Supported Patterns
- *
- * - **Direct fields**: `"title"`, `"playCount"`, `"year"`
- * - **Nested fields**: `"radarr.hasFile"`, `"sonarr.monitored"`
- * - **Computed fields**: `"neverWatched"` (computed from playCount)
- *
- * ## Field Validation
- *
- * Only fields defined in `FIELD_DEFINITIONS` are allowed. Unknown field keys
- * will log a warning and return null.
- *
- * @param item - The media item to extract from
- * @param fieldKey - The field key (e.g., "title", "radarr.monitored")
- * @returns The field value, or null if not found or undefined
- *
- * @internal
- */
-function getFieldValue(item: MediaItem, fieldKey: string): unknown {
-  // Validate field key exists in FIELD_DEFINITIONS
-  const fieldDef = FIELD_DEFINITIONS.find(f => f.key === fieldKey)
-  if (!fieldDef) {
-    console.warn(`Unknown field key: ${fieldKey}`)
-    return null
-  }
-
-  // Handle special cases
-  if (fieldKey === 'neverWatched') {
-    return item.playCount === 0
-  }
-
-  // Handle nested fields (e.g., "radarr.hasFile")
-  if (fieldKey.includes('.')) {
-    const parts = fieldKey.split('.')
-    let value: unknown = item
-    for (const part of parts) {
-      value = (value as Record<string, unknown>)?.[part]
-      if (value === undefined) return null
-    }
-    return value
-  }
-
-  // Direct field access
-  return (item as unknown as Record<string, unknown>)[fieldKey]
-}
-
-/**
- * Evaluates string comparison operations.
- *
- * Supports equality, pattern matching, and set membership operations.
- * All string comparisons are case-insensitive for user-friendly matching.
- *
- * ## Operators
- *
- * - `equals` / `notEquals`: Exact string match
- * - `contains` / `notContains`: Substring search (case-insensitive)
- * - `startsWith` / `endsWith`: Prefix/suffix match (case-insensitive)
- * - `regex`: Regular expression match (case-insensitive)
- * - `in` / `notIn`: Set membership (exact match)
- *
- * @param fieldValue - The string value from the media item
- * @param operator - The comparison operator
- * @param conditionValue - The value(s) to compare against
- * @returns `true` if the comparison succeeds
- *
- * @internal
- */
-function evaluateStringCondition(
-  fieldValue: string,
-  operator: StringOperator,
-  conditionValue: string | string[]
-): boolean {
-  switch (operator) {
-    case 'equals':
-      return fieldValue === conditionValue
-    case 'notEquals':
-      return fieldValue !== conditionValue
-    case 'contains':
-      return fieldValue.toLowerCase().includes((conditionValue as string).toLowerCase())
-    case 'notContains':
-      return !fieldValue.toLowerCase().includes((conditionValue as string).toLowerCase())
-    case 'startsWith':
-      return fieldValue.toLowerCase().startsWith((conditionValue as string).toLowerCase())
-    case 'endsWith':
-      return fieldValue.toLowerCase().endsWith((conditionValue as string).toLowerCase())
-    case 'regex':
-      try {
-        const regex = new RegExp(conditionValue as string, 'i')
-        return regex.test(fieldValue)
-      } catch {
-        return false
-      }
-    case 'in':
-      return (conditionValue as string[]).includes(fieldValue)
-    case 'notIn':
-      return !(conditionValue as string[]).includes(fieldValue)
-    default:
-      return false
-  }
-}
-
-/**
- * Evaluates number comparison operations.
- *
- * Supports equality, relational, and range comparisons.
- *
- * ## Operators
- *
- * - `equals` / `notEquals`: Exact numeric match
- * - `greaterThan` / `greaterThanOrEqual`: Greater than comparison
- * - `lessThan` / `lessThanOrEqual`: Less than comparison
- * - `between`: Inclusive range check `[min, max]`
- *
- * @param fieldValue - The numeric value from the media item
- * @param operator - The comparison operator
- * @param conditionValue - The value(s) to compare against
- * @returns `true` if the comparison succeeds
- *
- * @internal
- */
-function evaluateNumberCondition(
-  fieldValue: number,
-  operator: NumberOperator,
-  conditionValue: number | number[]
-): boolean {
-  switch (operator) {
-    case 'equals':
-      return fieldValue === conditionValue
-    case 'notEquals':
-      return fieldValue !== conditionValue
-    case 'greaterThan':
-      return fieldValue > (conditionValue as number)
-    case 'greaterThanOrEqual':
-      return fieldValue >= (conditionValue as number)
-    case 'lessThan':
-      return fieldValue < (conditionValue as number)
-    case 'lessThanOrEqual':
-      return fieldValue <= (conditionValue as number)
-    case 'between': {
-      const [min, max] = conditionValue as number[]
-      return fieldValue >= min && fieldValue <= max
-    }
-    default:
-      return false
-  }
-}
-
-/**
- * Evaluates date comparison operations.
- *
- * Supports both absolute date comparisons and relative time checks.
- *
- * ## Operators
- *
- * - `before` / `after`: Compare against absolute date
- * - `between`: Inclusive date range check
- * - `olderThan`: Relative comparison (e.g., "older than 365 days")
- * - `newerThan`: Relative comparison (e.g., "newer than 30 days")
- *
- * ## Relative Time Units
- *
- * For `olderThan` and `newerThan`, the `unit` parameter specifies:
- * - `days`: Value is number of days
- * - `months`: Value is number of months (30-day approximation)
- * - `years`: Value is number of years (365-day approximation)
- *
- * @param fieldValue - The date value from the media item
- * @param operator - The comparison operator
- * @param conditionValue - The date or number to compare against
- * @param unit - Time unit for relative comparisons ('days' | 'months' | 'years')
- * @returns `true` if the comparison succeeds
- *
- * @internal
- */
-function evaluateDateCondition(
-  fieldValue: Date,
-  operator: DateOperator,
-  conditionValue: any,
-  unit?: string
-): boolean {
-  switch (operator) {
-    case 'before':
-      return fieldValue < new Date(conditionValue)
-    case 'after':
-      return fieldValue > new Date(conditionValue)
-    case 'between': {
-      const [start, end] = conditionValue as string[]
-      return fieldValue >= new Date(start) && fieldValue <= new Date(end)
-    }
-    case 'olderThan': {
-      const threshold = calculateDateThreshold(conditionValue, unit as 'days' | 'months' | 'years')
-      return fieldValue < threshold
-    }
-    case 'newerThan': {
-      const threshold2 = calculateDateThreshold(conditionValue, unit as 'days' | 'months' | 'years')
-      return fieldValue > threshold2
-    }
-    default:
-      return false
-  }
-}
-
-/**
- * Calculates the threshold date for relative date comparisons.
- *
- * Subtracts the specified amount of time from the current date.
- *
- * ## Approximations
- *
- * - **months**: Approximated as 30 days
- * - **years**: Approximated as 365 days (no leap year handling)
- *
- * @param value - The number of time units to subtract
- * @param unit - The time unit ('days', 'months', or 'years')
- * @returns A Date object representing the calculated threshold
- *
- * @example
- * ```ts
- * // Get the date 90 days ago
- * const threshold = calculateDateThreshold(90, 'days')
- *
- * // Check if a date is older than 90 days
- * if (someDate < threshold) {
- *   console.log('Date is older than 90 days')
- * }
- * ```
- *
- * @internal
- */
-function calculateDateThreshold(value: number, unit: 'days' | 'months' | 'years'): Date {
-  const now = new Date()
-  switch (unit) {
-    case 'days':
-      return new Date(now.getTime() - value * 24 * 60 * 60 * 1000)
-    case 'months':
-      return new Date(now.getTime() - value * 30 * 24 * 60 * 60 * 1000)
-    case 'years':
-      return new Date(now.getTime() - value * 365 * 24 * 60 * 60 * 1000)
-  }
-}
-
-/**
- * Evaluates boolean comparison operations.
- *
- * Simple equality check for boolean field values.
- *
- * ## Operators
- *
- * - `equals`: True if values match
- * - `notEquals`: True if values differ
- *
- * @param fieldValue - The boolean value from the media item
- * @param operator - The comparison operator
- * @param conditionValue - The expected boolean value
- * @returns `true` if the comparison succeeds
- *
- * @internal
- */
-function evaluateBooleanCondition(
-  fieldValue: boolean,
-  operator: BooleanOperator,
-  conditionValue: boolean
-): boolean {
-  switch (operator) {
-    case 'equals':
-      return fieldValue === conditionValue
-    case 'notEquals':
-      return fieldValue !== conditionValue
-    default:
-      return false
-  }
-}
-
-/**
- * Evaluates array comparison operations.
- *
- * Used for array fields like `genres` and `labels`.
- *
- * ## Operators
- *
- * - `contains`: Array includes the specified value
- * - `notContains`: Array does not include the specified value
- * - `containsAny`: Array includes at least one of the specified values
- * - `containsAll`: Array includes all of the specified values
- * - `isEmpty`: Array has no elements
- * - `isNotEmpty`: Array has at least one element
- *
- * @param fieldValue - The array value from the media item
- * @param operator - The comparison operator
- * @param conditionValue - The value(s) to check for
- * @returns `true` if the comparison succeeds
- *
- * @internal
- */
-function evaluateArrayCondition(
-  fieldValue: string[],
-  operator: ArrayOperator,
-  conditionValue: string | string[]
-): boolean {
-  switch (operator) {
-    case 'contains':
-      return fieldValue.includes(conditionValue as string)
-    case 'notContains':
-      return !fieldValue.includes(conditionValue as string)
-    case 'containsAny':
-      return (conditionValue as string[]).some(v => fieldValue.includes(v))
-    case 'containsAll':
-      return (conditionValue as string[]).every(v => fieldValue.includes(v))
-    case 'isEmpty':
-      return fieldValue.length === 0
-    case 'isNotEmpty':
-      return fieldValue.length > 0
-    default:
-      return false
-  }
-}
-
-/**
- * Calculates complexity metrics for a rule criteria tree.
- *
- * Used by the UI to display a complexity indicator to the user.
- *
- * ## Complexity Levels
- *
- * - **simple**: ≤5 conditions and ≤2 depth
- * - **moderate**: >5 conditions OR >2 depth (but ≤10 conditions and ≤3 depth)
- * - **complex**: >10 conditions OR >3 depth
- *
- * ## Metrics Calculated
- *
- * - `conditionCount`: Total number of leaf conditions in the tree
- * - `groupCount`: Total number of groups (including root)
- * - `maxDepth`: Maximum nesting level (root = 0)
- *
- * @param criteria - The rule criteria tree to analyze
- * @returns An object containing complexity metrics and level
- *
- * @example
- * ```ts
- * const complexity = calculateComplexity(ruleCriteria)
- *
- * // { conditionCount: 3, groupCount: 2, maxDepth: 1, complexity: 'simple' }
- * console.log(complexity)
- *
- * // Use in UI
- * <ComplexityBadge level={complexity.complexity} />
- * ```
- */
-export function calculateComplexity(criteria: RuleCriteria): {
-  conditionCount: number
-  groupCount: number
-  maxDepth: number
-  complexity: 'simple' | 'moderate' | 'complex'
-} {
-  let conditionCount = 0
-  let groupCount = 0
-  let maxDepth = 0
-
-  function traverse(node: Condition | ConditionGroup, depth: number) {
-    maxDepth = Math.max(maxDepth, depth)
-
-    if (node.type === 'condition') {
-      conditionCount++
-    } else {
-      groupCount++
-      node.conditions.forEach(child => traverse(child, depth + 1))
-    }
-  }
-
-  traverse(criteria, 0)
-
-  let complexity: 'simple' | 'moderate' | 'complex' = 'simple'
-  if (conditionCount > 5 || maxDepth > 2) complexity = 'moderate'
-  if (conditionCount > 10 || maxDepth > 3) complexity = 'complex'
-
-  return { conditionCount, groupCount, maxDepth, complexity }
-}
diff --git a/lib/maintenance/scanner.ts b/lib/maintenance/scanner.ts
deleted file mode 100644
index a2e5cdaa..00000000
--- a/lib/maintenance/scanner.ts
+++ /dev/null
@@ -1,597 +0,0 @@
-/**
- * Maintenance Scanner Module
- *
- * Scans media libraries to identify items matching maintenance rule criteria.
- * Integrates with Tautulli for library data and the rule evaluator for matching.
- *
- * ## Scanning Process Flow
- *
- * 1. **Initialization**: Fetch rule from database, validate it's enabled
- * 2. **Scan Record**: Create a `MaintenanceScan` record with RUNNING status
- * 3. **Data Fetching**: Retrieve media data from Tautulli based on media type
- * 4. **Evaluation**: Test each item against the rule criteria
- * 5. **Candidate Creation**: Create `MaintenanceCandidate` records for matches
- * 6. **Completion**: Update scan status and rule statistics
- *
- * ## Progress Reporting
- *
- * Progress is reported via an optional callback every N items (configurable).
- * This enables UI updates during long-running scans.
- *
- * ## Error Handling Strategy
- *
- * - **Database errors**: Logged and re-thrown, scan marked as FAILED
- * - **Tautulli errors**: Logged with context, scan marked as FAILED
- * - **Rule not found**: Returns error result immediately
- * - **Rule disabled**: Returns error result immediately
- *
- * ## Data Sources
- *
- * - **Movies**: Fetched from Tautulli via `get_library_media_info`
- * - **TV Series**: Fetched from Tautulli via `get_library_media_info`
- *
- * @module lib/maintenance/scanner
- */
-
-import { prisma } from "@/lib/prisma"
-import { evaluateRule, type MediaItem } from "./rule-evaluator"
-import { createLogger } from "@/lib/utils/logger"
-import { getTautulliLibraryMediaInfo } from "@/lib/connections/tautulli"
-
-const logger = createLogger("MAINTENANCE_SCANNER")
-
-/**
- * Maximum number of items to fetch from Tautulli in a single request.
- * Tautulli supports up to 10,000 items per page.
- */
-const MAX_LIBRARY_ITEMS = 10000
-
-/**
- * Report scan progress every N items processed.
- * Lower values = more frequent updates but higher callback overhead.
- */
-const PROGRESS_REPORT_INTERVAL = 10
-
-/**
- * Result of a maintenance scan operation.
- */
-interface ScanResult {
-  /** Unique identifier for this scan (empty string if failed before creation) */
-  scanId: string
-  /** Final status of the scan */
-  status: "COMPLETED" | "FAILED"
-  /** Total number of media items evaluated */
-  itemsScanned: number
-  /** Number of items that matched the rule criteria */
-  itemsFlagged: number
-  /** Error message if the scan failed */
-  error?: string
-}
-
-/**
- * Movie data structure fetched from Tautulli.
- *
- * Extends the base media fields with movie-specific identifiers.
- */
-interface MovieData {
-  /** Plex rating key (unique identifier) */
-  plexRatingKey: string
-  /** Movie title */
-  title: string
-  /** Release year */
-  year?: number
-  /** Plex library section ID */
-  libraryId?: string
-  /** Total play count */
-  playCount: number
-  /** Last watched timestamp */
-  lastWatchedAt?: Date | null
-  /** Date added to library */
-  addedAt?: Date | null
-  /** Total file size in bytes */
-  fileSize?: bigint | null
-  /** Path to the media file */
-  filePath?: string | null
-  /** Radarr database ID (if linked) */
-  radarrId?: number | null
-  /** TMDB ID for external lookups */
-  tmdbId?: number | null
-  /** Poster image URL/path */
-  poster?: string | null
-}
-
-/**
- * TV series data structure fetched from Tautulli.
- *
- * Extends the base media fields with TV series-specific identifiers.
- */
-interface TVSeriesData {
-  /** Plex rating key (unique identifier) */
-  plexRatingKey: string
-  /** Series title */
-  title: string
-  /** First aired year */
-  year?: number
-  /** Plex library section ID */
-  libraryId?: string
-  /** Total play count across all episodes */
-  playCount: number
-  /** Last watched timestamp (any episode) */
-  lastWatchedAt?: Date | null
-  /** Date added to library */
-  addedAt?: Date | null
-  /** Total file size for all episodes in bytes */
-  fileSize?: bigint | null
-  /** Path to series folder */
-  filePath?: string | null
-  /** Sonarr database ID (if linked) */
-  sonarrId?: number | null
-  /** TVDB ID for external lookups */
-  tvdbId?: number | null
-  /** Poster image URL/path */
-  poster?: string | null
-}
-
-/**
- * Fetches movie data from Tautulli for a specific library section.
- *
- * Retrieves playback statistics and metadata for all movies in the library.
- * Data is fetched in a single request (up to MAX_LIBRARY_ITEMS).
- *
- * ## Data Transformation
- *
- * - Tautulli timestamps (epoch seconds) → JavaScript Date objects
- * - File size strings → BigInt for precision
- * - Null/undefined handling for optional fields
- *
- * @param sectionId - The Plex library section ID to fetch movies from
- * @returns Array of MovieData objects with standardized fields
- * @throws Error if no active Tautulli server is configured
- * @throws Error if Tautulli API returns an error response
- *
- * @internal
- */
-async function fetchMovieData(sectionId: string): Promise<MovieData[]> {
-  const startTime = Date.now()
-  logger.debug("Fetching movie data from Tautulli", { sectionId })
-
-  try {
-    // Get Tautulli config from database
-    const tautulliServer = await prisma.tautulli.findFirst({
-      where: { isActive: true },
-    })
-
-    if (!tautulliServer) {
-      throw new Error("No active Tautulli server configured")
-    }
-
-    const config = {
-      name: tautulliServer.name,
-      url: tautulliServer.url,
-      apiKey: tautulliServer.apiKey,
-      publicUrl: tautulliServer.publicUrl || undefined,
-    }
-
-    // Get library media info from Tautulli
-    const result = await getTautulliLibraryMediaInfo(config, sectionId, {
-      length: MAX_LIBRARY_ITEMS,
-    })
-
-    if (!result.success) {
-      throw new Error(result.error)
-    }
-
-    const response = result.data as any
-    if (response.response?.result !== "success") {
-      throw new Error(
-        response.response?.message || "Failed to fetch library data"
-      )
-    }
-
-    const data = response.response?.data?.data || []
-    const movies: MovieData[] = []
-
-    for (const item of data) {
-      movies.push({
-        plexRatingKey: String(item.rating_key || ""),
-        title: item.title || "",
-        year: item.year ? Number(item.year) : undefined,
-        libraryId: sectionId,
-        playCount: Number(item.play_count || 0),
-        lastWatchedAt: item.last_played
-          ? new Date(Number(item.last_played) * 1000)
-          : null,
-        addedAt: item.added_at ? new Date(Number(item.added_at) * 1000) : null,
-        fileSize: item.file_size ? BigInt(item.file_size) : null,
-        filePath: item.file || null,
-        radarrId: item.radarr_id ? Number(item.radarr_id) : null,
-        tmdbId: item.tmdb_id ? Number(item.tmdb_id) : null,
-        poster: item.thumb || null,
-      })
-    }
-
-    const duration = Date.now() - startTime
-    logger.info("Fetched movie data from Tautulli", {
-      sectionId,
-      count: movies.length,
-      duration,
-    })
-
-    return movies
-  } catch (error) {
-    const duration = Date.now() - startTime
-    logger.error("Failed to fetch movie data", error, { sectionId, duration })
-    throw error
-  }
-}
-
-/**
- * Fetches TV series data from Tautulli for a specific library section.
- *
- * Retrieves playback statistics and metadata for all TV series in the library.
- * Data is fetched in a single request (up to MAX_LIBRARY_ITEMS).
- *
- * ## Data Transformation
- *
- * - Tautulli timestamps (epoch seconds) → JavaScript Date objects
- * - File size strings → BigInt for precision
- * - Null/undefined handling for optional fields
- *
- * @param sectionId - The Plex library section ID to fetch TV series from
- * @returns Array of TVSeriesData objects with standardized fields
- * @throws Error if no active Tautulli server is configured
- * @throws Error if Tautulli API returns an error response
- *
- * @internal
- */
-async function fetchTVSeriesData(sectionId: string): Promise<TVSeriesData[]> {
-  const startTime = Date.now()
-  logger.debug("Fetching TV series data from Tautulli", { sectionId })
-
-  try {
-    // Get Tautulli config from database
-    const tautulliServer = await prisma.tautulli.findFirst({
-      where: { isActive: true },
-    })
-
-    if (!tautulliServer) {
-      throw new Error("No active Tautulli server configured")
-    }
-
-    const config = {
-      name: tautulliServer.name,
-      url: tautulliServer.url,
-      apiKey: tautulliServer.apiKey,
-      publicUrl: tautulliServer.publicUrl || undefined,
-    }
-
-    // Get library media info from Tautulli
-    const result = await getTautulliLibraryMediaInfo(config, sectionId, {
-      length: MAX_LIBRARY_ITEMS,
-    })
-
-    if (!result.success) {
-      throw new Error(result.error)
-    }
-
-    const response = result.data as any
-    if (response.response?.result !== "success") {
-      throw new Error(
-        response.response?.message || "Failed to fetch library data"
-      )
-    }
-
-    const data = response.response?.data?.data || []
-    const series: TVSeriesData[] = []
-
-    for (const item of data) {
-      series.push({
-        plexRatingKey: String(item.rating_key || ""),
-        title: item.title || "",
-        year: item.year ? Number(item.year) : undefined,
-        libraryId: sectionId,
-        playCount: Number(item.play_count || 0),
-        lastWatchedAt: item.last_played
-          ? new Date(Number(item.last_played) * 1000)
-          : null,
-        addedAt: item.added_at ? new Date(Number(item.added_at) * 1000) : null,
-        fileSize: item.file_size ? BigInt(item.file_size) : null,
-        filePath: item.file || null,
-        sonarrId: item.sonarr_id ? Number(item.sonarr_id) : null,
-        tvdbId: item.tvdb_id ? Number(item.tvdb_id) : null,
-        poster: item.thumb || null,
-      })
-    }
-
-    const duration = Date.now() - startTime
-    logger.info("Fetched TV series data from Tautulli", {
-      sectionId,
-      count: series.length,
-      duration,
-    })
-
-    return series
-  } catch (error) {
-    const duration = Date.now() - startTime
-    logger.error("Failed to fetch TV series data", error, {
-      sectionId,
-      duration,
-    })
-    throw error
-  }
-}
-
-/**
- * Scans media libraries for candidates matching a maintenance rule.
- *
- * This is the main entry point for running a maintenance scan. It orchestrates
- * the entire scanning process from fetching data to creating candidate records.
- *
- * ## Process Flow
- *
- * 1. **Validation**: Fetch and validate the rule (exists, enabled)
- * 2. **Scan Record**: Create a RUNNING scan record for tracking
- * 3. **Data Fetch**: Get media items from Tautulli for specified libraries
- * 4. **Evaluation**: Test each item against rule criteria
- * 5. **Candidate Creation**: Store matches as MaintenanceCandidate records
- * 6. **Cleanup**: Update scan status and rule statistics
- *
- * ## Progress Reporting
- *
- * The optional `onProgress` callback is invoked every `PROGRESS_REPORT_INTERVAL`
- * items with the current percentage (0-100). This enables UI progress indicators.
- *
- * ## Error Handling
- *
- * - Errors during scanning update the scan record to FAILED status
- * - The error message is stored in the scan record for debugging
- * - Returns a ScanResult with status="FAILED" and error message
- *
- * @param ruleId - The ID of the maintenance rule to scan with
- * @param onProgress - Optional callback for progress updates (0-100 percent)
- * @returns ScanResult with scan ID, status, and counts
- *
- * @example
- * ```ts
- * // Basic scan
- * const result = await scanForCandidates(ruleId)
- * if (result.status === 'COMPLETED') {
- *   console.log(`Found ${result.itemsFlagged} candidates`)
- * }
- *
- * // With progress callback
- * const result = await scanForCandidates(ruleId, (percent) => {
- *   updateProgressBar(percent)
- * })
- * ```
- */
-export async function scanForCandidates(
-  ruleId: string,
-  onProgress?: (percent: number) => void
-): Promise<ScanResult> {
-  const scanStartTime = Date.now()
-  logger.info("Starting maintenance scan", { ruleId })
-
-  try {
-    // Fetch the rule
-    const rule = await prisma.maintenanceRule.findUnique({
-      where: { id: ruleId },
-    })
-
-    if (!rule) {
-      throw new Error(`Rule not found: ${ruleId}`)
-    }
-
-    if (!rule.enabled) {
-      throw new Error(`Rule is disabled: ${ruleId}`)
-    }
-
-    // Create scan record
-    const scan = await prisma.maintenanceScan.create({
-      data: {
-        ruleId,
-        status: "RUNNING",
-        startedAt: new Date(),
-      },
-    })
-
-    logger.debug("Created scan record", { scanId: scan.id, ruleId })
-
-    try {
-      // Parse criteria
-      const criteria = rule.criteria as Record<string, unknown>
-
-      // Fetch media data based on media type
-      let mediaItems: MediaItem[] = []
-
-      if (rule.mediaType === "MOVIE") {
-        // Fetch from all movie libraries or specific libraries
-        const libraryIds = (criteria.libraryIds as string[]) || []
-
-        if (libraryIds.length > 0) {
-          for (const libId of libraryIds) {
-            const movies = await fetchMovieData(libId)
-            mediaItems.push(...movies)
-          }
-        } else {
-          // If no specific libraries, we need to get all movie libraries
-          // For now, throw an error requiring library IDs
-          logger.error("Rule validation failed", undefined, {
-            ruleId,
-            ruleName: rule.name,
-            mediaType: rule.mediaType,
-            error: "Missing libraryIds in criteria",
-          })
-          throw new Error(
-            `${rule.mediaType} rules must specify libraryIds in criteria. ` +
-              `Rule: "${rule.name}" (${ruleId})`
-          )
-        }
-      } else if (rule.mediaType === "TV_SERIES") {
-        // Fetch from all TV libraries or specific libraries
-        const libraryIds = (criteria.libraryIds as string[]) || []
-
-        if (libraryIds.length > 0) {
-          for (const libId of libraryIds) {
-            const series = await fetchTVSeriesData(libId)
-            mediaItems.push(...series)
-          }
-        } else {
-          // If no specific libraries, we need to get all TV libraries
-          // For now, throw an error requiring library IDs
-          logger.error("Rule validation failed", undefined, {
-            ruleId,
-            ruleName: rule.name,
-            mediaType: rule.mediaType,
-            error: "Missing libraryIds in criteria",
-          })
-          throw new Error(
-            `${rule.mediaType} rules must specify libraryIds in criteria. ` +
-              `Rule: "${rule.name}" (${ruleId})`
-          )
-        }
-      } else {
-        logger.error("Rule validation failed", undefined, {
-          ruleId,
-          ruleName: rule.name,
-          mediaType: rule.mediaType,
-          error: "Unsupported media type",
-        })
-        throw new Error(
-          `Unsupported media type: ${rule.mediaType}. ` +
-            `Rule: "${rule.name}" (${ruleId}). ` +
-            `Supported types: MOVIE, TV_SERIES`
-        )
-      }
-
-      logger.debug("Fetched media items", {
-        scanId: scan.id,
-        count: mediaItems.length,
-      })
-
-      // Evaluate each item against the rule
-      const matchedItems: MediaItem[] = []
-      let itemsScanned = 0
-
-      for (const item of mediaItems) {
-        itemsScanned++
-
-        // Report progress
-        if (onProgress && itemsScanned % PROGRESS_REPORT_INTERVAL === 0) {
-          const percent = Math.floor((itemsScanned / mediaItems.length) * 100)
-          onProgress(percent)
-        }
-
-        if (evaluateRule(item, criteria)) {
-          matchedItems.push(item)
-        }
-      }
-
-      logger.debug("Evaluated items", {
-        scanId: scan.id,
-        scanned: itemsScanned,
-        matched: matchedItems.length,
-      })
-
-      // Create candidate records for matched items
-      const candidates = await Promise.all(
-        matchedItems.map(async (item) => {
-          const itemData = item as MovieData | TVSeriesData
-
-          // Generate a plexRatingKey fallback if not available
-          const plexRatingKey = item.plexRatingKey
-            ?? (item.id ? `${rule.mediaType === 'MOVIE' ? 'radarr' : 'sonarr'}_${item.id}` : `unknown_${Date.now()}_${Math.random().toString(36).slice(2)}`)
-
-          return prisma.maintenanceCandidate.create({
-            data: {
-              scanId: scan.id,
-              mediaType: rule.mediaType,
-              plexRatingKey,
-              radarrId: "radarrId" in itemData ? itemData.radarrId : null,
-              sonarrId: "sonarrId" in itemData ? itemData.sonarrId : null,
-              tmdbId: "tmdbId" in itemData ? itemData.tmdbId : null,
-              tvdbId: "tvdbId" in itemData ? itemData.tvdbId : null,
-              title: item.title,
-              year: item.year,
-              poster: "poster" in itemData ? itemData.poster : null,
-              filePath: item.filePath,
-              fileSize: item.fileSize,
-              playCount: item.playCount,
-              lastWatchedAt: item.lastWatchedAt,
-              addedAt: item.addedAt,
-              matchedRules: [rule.name],
-              reviewStatus: "PENDING",
-            },
-          })
-        })
-      )
-
-      logger.debug("Created candidate records", {
-        scanId: scan.id,
-        count: candidates.length,
-      })
-
-      // Update scan status
-      await prisma.maintenanceScan.update({
-        where: { id: scan.id },
-        data: {
-          status: "COMPLETED",
-          completedAt: new Date(),
-          itemsScanned,
-          itemsFlagged: matchedItems.length,
-        },
-      })
-
-      // Update rule statistics
-      await prisma.maintenanceRule.update({
-        where: { id: ruleId },
-        data: {
-          lastRunAt: new Date(),
-          // Calculate next run based on schedule (if cron is configured)
-          // For now, just set it to null
-          nextRunAt: null,
-        },
-      })
-
-      const duration = Date.now() - scanStartTime
-      logger.info("Scan completed successfully", {
-        scanId: scan.id,
-        ruleId,
-        itemsScanned,
-        itemsFlagged: matchedItems.length,
-        duration,
-      })
-
-      return {
-        scanId: scan.id,
-        status: "COMPLETED",
-        itemsScanned,
-        itemsFlagged: matchedItems.length,
-      }
-    } catch (error) {
-      // Update scan status to failed
-      await prisma.maintenanceScan.update({
-        where: { id: scan.id },
-        data: {
-          status: "FAILED",
-          completedAt: new Date(),
-          error:
-            error instanceof Error ? error.message : "Unknown error occurred",
-        },
-      })
-
-      throw error
-    }
-  } catch (error) {
-    const duration = Date.now() - scanStartTime
-    logger.error("Scan failed", error, { ruleId, duration })
-
-    return {
-      scanId: "",
-      status: "FAILED",
-      itemsScanned: 0,
-      itemsFlagged: 0,
-      error: error instanceof Error ? error.message : "Unknown error occurred",
-    }
-  }
-}
diff --git a/lib/maintenance/services/index.ts b/lib/maintenance/services/index.ts
deleted file mode 100644
index 13eeafe8..00000000
--- a/lib/maintenance/services/index.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-/**
- * Maintenance media services
- *
- * Provides functions for fetching media data from various services
- * for use in maintenance rule evaluation.
- */
-
-export * from "./types"
-export * from "./tautulli-media"
-export * from "./plex-media"
-export * from "./overseerr-media"
-export * from "./media-matching"
diff --git a/lib/maintenance/services/media-matching.ts b/lib/maintenance/services/media-matching.ts
deleted file mode 100644
index e8239e11..00000000
--- a/lib/maintenance/services/media-matching.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-/**
- * Media matching utilities for maintenance rules
- *
- * Provides title normalization and matching logic between
- * different media services (Radarr, Sonarr, Tautulli, Plex).
- */
-
-import type { TautulliMediaItem, PlexMediaItem, RadarrMovie, SonarrSeries } from "./types"
-
-// Matching configuration constants
-export const YEAR_TOLERANCE = 1 // Allow ±1 year difference for matching
-export const TITLE_SUBSTRING_LENGTH = 10 // Characters to use for fuzzy matching
-
-/**
- * Normalize title for matching between services
- * Removes punctuation and normalizes whitespace for consistent comparison
- */
-export function normalizeTitle(title: string): string {
-  return title
-    .toLowerCase()
-    .replace(/[^\w\s]/g, "") // Remove punctuation
-    .replace(/\s+/g, " ")    // Normalize whitespace
-    .trim()
-}
-
-/**
- * Check if two years match within tolerance
- */
-export function yearsMatch(year1: number | undefined, year2: number | undefined): boolean {
-  if (year1 === undefined || year2 === undefined) {
-    return false
-  }
-  return Math.abs(year1 - year2) <= YEAR_TOLERANCE
-}
-
-/**
- * Find matching Tautulli item for a movie
- */
-export function findTautulliMatch(
-  movie: RadarrMovie | SonarrSeries,
-  tautulliData: TautulliMediaItem[]
-): TautulliMediaItem | undefined {
-  const normalizedTitle = normalizeTitle(movie.title)
-
-  return tautulliData.find((t) => {
-    const normalizedTautulliTitle = normalizeTitle(t.title)
-    const titleMatch = normalizedTautulliTitle === normalizedTitle
-    const yearMatch = yearsMatch(t.year, movie.year)
-    return titleMatch && yearMatch
-  })
-}
-
-/**
- * Find matching Plex item for a movie
- */
-export function findPlexMatch(
-  movie: RadarrMovie | SonarrSeries,
-  plexData: PlexMediaItem[]
-): PlexMediaItem | undefined {
-  const normalizedTitle = normalizeTitle(movie.title)
-
-  return plexData.find((p) => {
-    const normalizedPlexTitle = normalizeTitle(p.title)
-    const titleMatch = normalizedPlexTitle === normalizedTitle
-    const yearMatch = yearsMatch(p.year, movie.year)
-    return titleMatch && yearMatch
-  })
-}
-
-/**
- * Find close matches for debugging unmatched items
- * Uses substring matching to find potential matches
- */
-export function findCloseMatches(
-  title: string,
-  tautulliData: TautulliMediaItem[],
-  maxMatches: number = 3
-): TautulliMediaItem[] {
-  const normalizedTitle = normalizeTitle(title)
-  const titlePrefix = normalizedTitle.slice(0, TITLE_SUBSTRING_LENGTH)
-
-  return tautulliData
-    .filter((t) => {
-      const normalizedTautulliTitle = normalizeTitle(t.title)
-      const tautulliPrefix = normalizedTautulliTitle.slice(0, TITLE_SUBSTRING_LENGTH)
-      return (
-        normalizedTautulliTitle.includes(titlePrefix) ||
-        normalizedTitle.includes(tautulliPrefix)
-      )
-    })
-    .slice(0, maxMatches)
-}
diff --git a/lib/maintenance/services/overseerr-media.ts b/lib/maintenance/services/overseerr-media.ts
deleted file mode 100644
index 4b68fd7d..00000000
--- a/lib/maintenance/services/overseerr-media.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-/**
- * Overseerr media fetching service for maintenance rules
- */
-
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import { batchGetOverseerrMediaStatus } from "@/lib/connections/overseerr"
-import type { OverseerrParsed } from "@/lib/validations/overseerr"
-import type { OverseerrMediaStatus } from "./types"
-
-const logger = createLogger("overseerr-media")
-
-/**
- * Fetch Overseerr status for movies by TMDB IDs
- */
-export async function fetchOverseerrMovieData(
-  tmdbIds: number[]
-): Promise<Map<string, OverseerrMediaStatus>> {
-  return fetchOverseerrMediaByType(tmdbIds, "movie")
-}
-
-/**
- * Fetch Overseerr status for TV series by TMDB IDs
- */
-export async function fetchOverseerrSeriesData(
-  tmdbIds: number[]
-): Promise<Map<string, OverseerrMediaStatus>> {
-  return fetchOverseerrMediaByType(tmdbIds, "tv")
-}
-
-/**
- * Fetch Overseerr status for media by TMDB IDs and type
- */
-async function fetchOverseerrMediaByType(
-  tmdbIds: number[],
-  mediaType: "movie" | "tv"
-): Promise<Map<string, OverseerrMediaStatus>> {
-  try {
-    if (tmdbIds.length === 0) {
-      return new Map()
-    }
-
-    const overseerr = await prisma.overseerr.findFirst({
-      where: { isActive: true },
-    })
-
-    if (!overseerr) {
-      logger.debug("No active Overseerr server configured")
-      return new Map()
-    }
-
-    const overseerrConfig: OverseerrParsed = {
-      url: overseerr.url,
-      apiKey: overseerr.apiKey,
-      name: overseerr.name,
-    }
-
-    const items = tmdbIds.map((tmdbId) => ({ tmdbId, mediaType }))
-    const result = await batchGetOverseerrMediaStatus(overseerrConfig, items)
-
-    logger.debug(`Fetched Overseerr status for ${result.size} ${mediaType} items`)
-    return result
-  } catch (error) {
-    logger.error(`Failed to fetch ${mediaType} data from Overseerr`, { error })
-    return new Map()
-  }
-}
diff --git a/lib/maintenance/services/plex-media.ts b/lib/maintenance/services/plex-media.ts
deleted file mode 100644
index e4370d9d..00000000
--- a/lib/maintenance/services/plex-media.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-/**
- * Plex media fetching service for maintenance rules
- */
-
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import { getPlexLibrarySections, getPlexLibraryItems, getPlexPlaylists, getPlexPlaylistItems } from "@/lib/connections/plex"
-import type { PlexMediaItem } from "./types"
-
-const logger = createLogger("plex-media")
-
-interface PlexSection {
-  key: string
-  title: string
-  type: string
-}
-
-interface PlexPlaylist {
-  ratingKey: string
-  title: string
-  playlistType: string
-}
-
-interface PlexPlaylistItem {
-  ratingKey: string
-}
-
-/**
- * Fetch movie data from Plex directly
- */
-export async function fetchPlexMovieData(): Promise<PlexMediaItem[]> {
-  return fetchPlexMediaByType("movie", 1)
-}
-
-/**
- * Fetch TV series data from Plex directly
- */
-export async function fetchPlexSeriesData(): Promise<PlexMediaItem[]> {
-  return fetchPlexMediaByType("show", 2)
-}
-
-/**
- * Fetch media data from Plex by library type
- */
-async function fetchPlexMediaByType(sectionType: string, mediaType: number): Promise<PlexMediaItem[]> {
-  try {
-    const plex = await prisma.plexServer.findFirst({
-      where: { isActive: true },
-    })
-
-    if (!plex) {
-      logger.debug("No active Plex server configured")
-      return []
-    }
-
-    const plexConfig = {
-      url: plex.url,
-      token: plex.token,
-    }
-
-    const sectionsResult = await getPlexLibrarySections(plexConfig)
-    if (!sectionsResult.success || !sectionsResult.data) {
-      logger.debug("Failed to get library sections", { error: sectionsResult.error })
-      return []
-    }
-
-    const sections: PlexSection[] = sectionsResult.data?.MediaContainer?.Directory || []
-    const filteredSections = sections.filter((s) => s.type === sectionType)
-
-    if (filteredSections.length === 0) {
-      logger.debug(`No ${sectionType} libraries found`)
-      return []
-    }
-
-    const allMedia: PlexMediaItem[] = []
-
-    for (const section of filteredSections) {
-      const itemsResult = await getPlexLibraryItems(plexConfig, section.key, mediaType)
-      if (itemsResult.success && itemsResult.data) {
-        const items: PlexMediaItem[] = itemsResult.data?.MediaContainer?.Metadata || []
-        allMedia.push(...items)
-      }
-    }
-
-    logger.debug(`Fetched ${allMedia.length} ${sectionType} items from Plex`)
-    return allMedia
-  } catch (error) {
-    logger.error(`Failed to fetch ${sectionType} data from Plex`, { error })
-    return []
-  }
-}
-
-/**
- * Fetch Plex playlists and build a map of ratingKey -> playlist names
- * This allows us to know which playlists each media item belongs to
- *
- * Note: This makes sequential API calls for each playlist. For servers with
- * many playlists, this could be slow. Consider caching if performance is an issue.
- */
-export async function fetchPlexPlaylistMap(): Promise<Map<string, string[]>> {
-  const playlistMap = new Map<string, string[]>()
-
-  try {
-    const plex = await prisma.plexServer.findFirst({
-      where: { isActive: true },
-    })
-
-    if (!plex) {
-      return playlistMap
-    }
-
-    const plexConfig = {
-      url: plex.url,
-      token: plex.token,
-    }
-
-    const playlistsResult = await getPlexPlaylists(plexConfig)
-    if (!playlistsResult.success || !playlistsResult.data) {
-      return playlistMap
-    }
-
-    const playlists: PlexPlaylist[] = playlistsResult.data?.MediaContainer?.Metadata || []
-    logger.debug(`Found ${playlists.length} playlists`)
-
-    // For each video playlist, get items and map ratingKeys to playlist names
-    for (const playlist of playlists) {
-      if (playlist.playlistType !== "video") {
-        continue
-      }
-
-      const itemsResult = await getPlexPlaylistItems(plexConfig, playlist.ratingKey)
-      if (!itemsResult.success || !itemsResult.data) {
-        continue
-      }
-
-      const items: PlexPlaylistItem[] = itemsResult.data?.MediaContainer?.Metadata || []
-      for (const item of items) {
-        if (item.ratingKey) {
-          const existing = playlistMap.get(item.ratingKey) || []
-          if (!existing.includes(playlist.title)) {
-            existing.push(playlist.title)
-            playlistMap.set(item.ratingKey, existing)
-          }
-        }
-      }
-    }
-
-    logger.debug(`Built playlist map with ${playlistMap.size} media items`)
-    return playlistMap
-  } catch (error) {
-    logger.error("Failed to fetch playlist data from Plex", { error })
-    return playlistMap
-  }
-}
diff --git a/lib/maintenance/services/tautulli-media.ts b/lib/maintenance/services/tautulli-media.ts
deleted file mode 100644
index 665c2653..00000000
--- a/lib/maintenance/services/tautulli-media.ts
+++ /dev/null
@@ -1,91 +0,0 @@
-/**
- * Tautulli media fetching service for maintenance rules
- */
-
-import { prisma } from "@/lib/prisma"
-import { createLogger } from "@/lib/utils/logger"
-import { getTautulliLibraryMediaInfo, getTautulliLibraryNames } from "@/lib/connections/tautulli"
-import type { TautulliParsed } from "@/lib/validations/tautulli"
-import type { TautulliMediaItem } from "./types"
-
-const logger = createLogger("tautulli-media")
-
-interface TautulliLibrary {
-  section_name: string
-  section_type: string
-  section_id: string
-}
-
-/**
- * Fetch movie data from Tautulli for playback/file/quality info
- */
-export async function fetchTautulliMovieData(): Promise<TautulliMediaItem[]> {
-  return fetchTautulliMediaByType("movie")
-}
-
-/**
- * Fetch TV series data from Tautulli for playback info
- */
-export async function fetchTautulliSeriesData(): Promise<TautulliMediaItem[]> {
-  return fetchTautulliMediaByType("show")
-}
-
-/**
- * Fetch media data from Tautulli by library type
- */
-async function fetchTautulliMediaByType(libraryType: "movie" | "show"): Promise<TautulliMediaItem[]> {
-  try {
-    const tautulli = await prisma.tautulli.findFirst({
-      where: { isActive: true },
-    })
-
-    if (!tautulli) {
-      logger.debug("No active Tautulli server configured")
-      return []
-    }
-
-    const tautulliConfig: TautulliParsed = {
-      url: tautulli.url,
-      apiKey: tautulli.apiKey,
-      name: tautulli.name,
-    }
-
-    const librariesResult = await getTautulliLibraryNames(tautulliConfig)
-    if (!librariesResult.success) {
-      logger.debug("Failed to get library names", { error: librariesResult.error })
-      return []
-    }
-    if (!librariesResult.data) {
-      logger.debug("No library data returned")
-      return []
-    }
-
-    const libraries = (librariesResult.data as { response?: { data?: TautulliLibrary[] } })?.response?.data || []
-    const filteredLibraries = libraries.filter((lib) => lib.section_type === libraryType)
-
-    if (filteredLibraries.length === 0) {
-      logger.debug(`No ${libraryType} libraries found`)
-      return []
-    }
-
-    const allMedia: TautulliMediaItem[] = []
-
-    for (const library of filteredLibraries) {
-      const mediaResult = await getTautulliLibraryMediaInfo(tautulliConfig, library.section_id, {
-        length: 10000,
-      })
-
-      if (mediaResult.success && mediaResult.data) {
-        const responseData = (mediaResult.data as { response?: { data?: { data?: TautulliMediaItem[] } } })?.response?.data
-        const items = responseData?.data || []
-        allMedia.push(...items)
-      }
-    }
-
-    logger.debug(`Fetched ${allMedia.length} ${libraryType} items from Tautulli`)
-    return allMedia
-  } catch (error) {
-    logger.error(`Failed to fetch ${libraryType} data from Tautulli`, { error })
-    return []
-  }
-}
diff --git a/lib/maintenance/services/types.ts b/lib/maintenance/services/types.ts
deleted file mode 100644
index 6a3bfe53..00000000
--- a/lib/maintenance/services/types.ts
+++ /dev/null
@@ -1,112 +0,0 @@
-/**
- * Shared types for maintenance media services
- */
-
-// Tautulli library media info response types
-export interface TautulliMediaItem {
-  rating_key: string
-  title: string
-  year: number
-  play_count: number | null
-  last_played: number | null  // Unix timestamp
-  added_at: number | null     // Unix timestamp
-  file_size: number | null
-  file: string | null
-  duration: number | null     // milliseconds
-  video_codec: string | null
-  audio_codec: string | null
-  video_resolution: string | null
-  bitrate: number | null
-  container: string | null
-  video_full_resolution: string | null
-  media_type: string
-  grandparent_title?: string  // For episodes, this is the series title
-}
-
-export interface RadarrMovie {
-  id: number
-  title: string
-  year: number
-  tmdbId?: number
-  imdbId?: string
-  hasFile: boolean
-  monitored: boolean
-  qualityProfileId: number
-  minimumAvailability: string
-  status: string
-  added: string
-  ratings?: {
-    tmdb?: {
-      value: number
-    }
-  }
-  digitalRelease?: string
-  inCinemas?: string
-  runtime?: number
-  tags?: number[]
-  sizeOnDisk?: number
-  certification?: string
-  genres?: string[]
-}
-
-export interface SonarrSeries {
-  id: number
-  title: string
-  year: number
-  tvdbId?: number
-  imdbId?: string
-  monitored: boolean
-  status: string
-  added: string
-  seriesType: string
-  network?: string
-  firstAired?: string
-  ended: boolean
-  tags?: number[]
-  statistics?: {
-    seasonCount?: number
-    totalEpisodeCount?: number
-    episodeFileCount?: number
-    episodeCount?: number
-    sizeOnDisk?: number
-    percentOfEpisodes?: number
-  }
-  certification?: string
-  qualityProfileId: number
-  genres?: string[]
-}
-
-// Plex library item from /library/sections/{id}/all
-export interface PlexMediaItem {
-  ratingKey: string
-  title: string
-  year?: number
-  type: string // 'movie' or 'show'
-  viewCount?: number
-  lastViewedAt?: number // Unix timestamp
-  addedAt?: number // Unix timestamp
-  thumb?: string
-  audienceRating?: number
-  contentRating?: string
-  studio?: string
-  duration?: number // milliseconds
-  guid?: string // Plex GUID for external matching
-  Guid?: Array<{ id: string }> // External GUIDs (tmdb://, imdb://, tvdb://)
-}
-
-export interface OverseerrMediaStatus {
-  status: number
-  hasRequest: boolean
-  requestedBy?: string
-  requestedAt?: Date
-  requestCount: number
-}
-
-// Overseerr status labels
-export const OVERSEERR_STATUS_LABELS: Record<number, string> = {
-  1: 'unknown',
-  2: 'pending',
-  3: 'processing',
-  4: 'partially_available',
-  5: 'available',
-}
diff --git a/lib/validations/__tests__/maintenance.test.ts b/lib/validations/__tests__/maintenance.test.ts
deleted file mode 100644
index cb506752..00000000
--- a/lib/validations/__tests__/maintenance.test.ts
+++ /dev/null
@@ -1,1730 +0,0 @@
-import {
-  MediaTypeEnum,
-  MarkTypeEnum,
-  IntentTypeEnum,
-  ScanStatusEnum,
-  ReviewStatusEnum,
-  ActionTypeEnum,
-  RuleCriteriaSchema,
-  LegacyRuleCriteriaSchema,
-  CreateMaintenanceRuleSchema,
-  UpdateMaintenanceRuleSchema,
-  CreateUserMediaMarkSchema,
-  CreateUserWatchIntentSchema,
-} from '../maintenance'
-import { generateId } from '@/lib/maintenance/field-registry'
-
-describe('Maintenance Validation Schemas', () => {
-  describe('MediaTypeEnum', () => {
-    it('should accept valid media types', () => {
-      expect(MediaTypeEnum.safeParse('MOVIE').success).toBe(true)
-      expect(MediaTypeEnum.safeParse('TV_SERIES').success).toBe(true)
-      expect(MediaTypeEnum.safeParse('EPISODE').success).toBe(true)
-    })
-
-    it('should reject invalid media types', () => {
-      const result = MediaTypeEnum.safeParse('INVALID')
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toContain("Invalid")
-      }
-    })
-  })
-
-  describe('MarkTypeEnum', () => {
-    it('should accept all valid mark types', () => {
-      const validTypes = [
-        'FINISHED_WATCHING',
-        'NOT_INTERESTED',
-        'KEEP_FOREVER',
-        'REWATCH_CANDIDATE',
-        'POOR_QUALITY',
-        'WRONG_VERSION',
-      ]
-
-      validTypes.forEach((type) => {
-        expect(MarkTypeEnum.safeParse(type).success).toBe(true)
-      })
-    })
-
-    it('should reject invalid mark types', () => {
-      const result = MarkTypeEnum.safeParse('INVALID_MARK')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('IntentTypeEnum', () => {
-    it('should accept all valid intent types', () => {
-      const validTypes = [
-        'PLAN_TO_WATCH',
-        'WATCHING',
-        'COMPLETED',
-        'DROPPED',
-        'ON_HOLD',
-      ]
-
-      validTypes.forEach((type) => {
-        expect(IntentTypeEnum.safeParse(type).success).toBe(true)
-      })
-    })
-
-    it('should reject invalid intent types', () => {
-      const result = IntentTypeEnum.safeParse('WANT_TO_WATCH')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('ScanStatusEnum', () => {
-    it('should accept all valid scan statuses', () => {
-      const validStatuses = ['PENDING', 'RUNNING', 'COMPLETED', 'FAILED']
-
-      validStatuses.forEach((status) => {
-        expect(ScanStatusEnum.safeParse(status).success).toBe(true)
-      })
-    })
-
-    it('should reject invalid scan statuses', () => {
-      const result = ScanStatusEnum.safeParse('IN_PROGRESS')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('ReviewStatusEnum', () => {
-    it('should accept all valid review statuses', () => {
-      const validStatuses = ['PENDING', 'APPROVED', 'REJECTED', 'DELETED']
-
-      validStatuses.forEach((status) => {
-        expect(ReviewStatusEnum.safeParse(status).success).toBe(true)
-      })
-    })
-
-    it('should reject invalid review statuses', () => {
-      const result = ReviewStatusEnum.safeParse('ACCEPTED')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('ActionTypeEnum', () => {
-    it('should accept valid action types', () => {
-      expect(ActionTypeEnum.safeParse('FLAG_FOR_REVIEW').success).toBe(true)
-      expect(ActionTypeEnum.safeParse('AUTO_DELETE').success).toBe(true)
-    })
-
-    it('should reject invalid action types', () => {
-      const result = ActionTypeEnum.safeParse('MANUAL_DELETE')
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('RuleCriteriaSchema', () => {
-    it('should accept empty criteria with default operator', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [],
-      })
-      expect(result.success).toBe(false) // Empty conditions should fail
-    })
-
-    it('should accept valid neverWatched criteria', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'neverWatched',
-            operator: 'equals',
-            value: true,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid lastWatchedBefore with days', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'lastWatchedAt',
-            operator: 'olderThan',
-            value: 30,
-            valueUnit: 'days',
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid lastWatchedBefore with months', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'lastWatchedAt',
-            operator: 'olderThan',
-            value: 6,
-            valueUnit: 'months',
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid lastWatchedBefore with years', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'lastWatchedAt',
-            operator: 'olderThan',
-            value: 2,
-            valueUnit: 'years',
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject lastWatchedBefore with value less than 1', () => {
-      // This validation is now handled at the condition level, not schema level
-      // The schema will accept it, but validation should catch it
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'lastWatchedAt',
-            operator: 'olderThan',
-            value: 0,
-            valueUnit: 'days',
-          },
-        ],
-      })
-      // Schema accepts it, but runtime validation should catch invalid values
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject lastWatchedBefore with invalid unit', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        lastWatchedBefore: {
-          value: 5,
-          unit: 'weeks',
-        },
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should accept valid maxPlayCount', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'playCount',
-            operator: 'lessThanOrEqual',
-            value: 5,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept maxPlayCount of 0', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'playCount',
-            operator: 'lessThanOrEqual',
-            value: 0,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject negative maxPlayCount', () => {
-      // Schema accepts negative numbers, validation happens at runtime
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'playCount',
-            operator: 'lessThanOrEqual',
-            value: -1,
-          },
-        ],
-      })
-      // Schema accepts it, but runtime validation should catch invalid values
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid addedBefore criteria', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'addedAt',
-            operator: 'olderThan',
-            value: 90,
-            valueUnit: 'days',
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject addedBefore with negative value', () => {
-      // Schema accepts negative numbers, validation happens at runtime
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'addedAt',
-            operator: 'olderThan',
-            value: -5,
-            valueUnit: 'months',
-          },
-        ],
-      })
-      // Schema accepts it, but runtime validation should catch invalid values
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid minFileSize with MB', () => {
-      // minFileSize is converted to bytes in the hierarchical format
-      const bytes = 500 * 1024 * 1024 // 500MB in bytes
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'fileSize',
-            operator: 'greaterThanOrEqual',
-            value: bytes,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid minFileSize with GB', () => {
-      const bytes = 2 * 1024 * 1024 * 1024 // 2GB in bytes
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'fileSize',
-            operator: 'greaterThanOrEqual',
-            value: bytes,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid minFileSize with TB', () => {
-      const bytes = BigInt(1024) * BigInt(1024) * BigInt(1024) * BigInt(1024) // 1TB in bytes
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'fileSize',
-            operator: 'greaterThanOrEqual',
-            value: Number(bytes),
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept minFileSize of 0', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'fileSize',
-            operator: 'greaterThanOrEqual',
-            value: 0,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject minFileSize with negative value', () => {
-      // Schema accepts negative numbers, validation happens at runtime
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'fileSize',
-            operator: 'greaterThanOrEqual',
-            value: -10,
-          },
-        ],
-      })
-      // Schema accepts it, but runtime validation should catch invalid values
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject minFileSize with invalid unit', () => {
-      // Unit validation is not at schema level in hierarchical format
-      // Intentionally using invalid value to test validation - use string cast to bypass type checking
-      const invalidUnit = 'KB' as 'days' | 'months' | 'years' | 'MB' | 'GB' | 'TB'
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'fileSize',
-            operator: 'greaterThanOrEqual',
-            value: 100,
-            valueUnit: invalidUnit,
-          },
-        ],
-      })
-      // Schema will reject invalid valueUnit enum
-      expect(result.success).toBe(false)
-    })
-
-    it('should accept valid maxQuality', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'resolution',
-            operator: 'lessThanOrEqual',
-            value: '720p',
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid maxRating', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'rating',
-            operator: 'lessThanOrEqual',
-            value: 5.5,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept maxRating of 0', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'rating',
-            operator: 'lessThanOrEqual',
-            value: 0,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept maxRating of 10', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'rating',
-            operator: 'lessThanOrEqual',
-            value: 10,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject maxRating less than 0', () => {
-      // Schema accepts negative numbers, validation happens at runtime
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'rating',
-            operator: 'lessThanOrEqual',
-            value: -1,
-          },
-        ],
-      })
-      // Schema accepts it, but runtime validation should catch invalid values
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject maxRating greater than 10', () => {
-      // Schema accepts numbers > 10, validation happens at runtime
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'rating',
-            operator: 'lessThanOrEqual',
-            value: 11,
-          },
-        ],
-      })
-      // Schema accepts it, but runtime validation should catch invalid values
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid libraryIds array', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'libraryId',
-            operator: 'in',
-            value: ['lib1', 'lib2', 'lib3'],
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept empty libraryIds array', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'libraryId',
-            operator: 'in',
-            value: [],
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept valid tags array', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'labels',
-            operator: 'containsAny',
-            value: ['action', 'thriller'],
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept empty tags array', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'labels',
-            operator: 'containsAny',
-            value: [],
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept OR operator', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'OR',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'neverWatched',
-            operator: 'equals',
-            value: true,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.operator).toBe('OR')
-      }
-    })
-
-    it('should accept AND operator', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'neverWatched',
-            operator: 'equals',
-            value: true,
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.operator).toBe('AND')
-      }
-    })
-
-    it('should reject invalid operator', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        operator: 'NOT',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should accept complex criteria with multiple fields', () => {
-      const result = RuleCriteriaSchema.safeParse({
-        type: 'group',
-        id: generateId(),
-        operator: 'AND',
-        conditions: [
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'neverWatched',
-            operator: 'equals',
-            value: false,
-          },
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'lastWatchedAt',
-            operator: 'olderThan',
-            value: 6,
-            valueUnit: 'months',
-          },
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'playCount',
-            operator: 'lessThanOrEqual',
-            value: 2,
-          },
-          {
-            type: 'condition',
-            id: generateId(),
-            field: 'addedAt',
-            operator: 'olderThan',
-            value: 1,
-            valueUnit: 'years',
-          },
-        ],
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept complex criteria with multiple fields (legacy format test)', () => {
-      // This test uses LegacyRuleCriteriaSchema which should still work
-      const result = LegacyRuleCriteriaSchema.safeParse({
-        neverWatched: false,
-        lastWatchedBefore: {
-          value: 6,
-          unit: 'months',
-        },
-        maxPlayCount: 2,
-        addedBefore: {
-          value: 1,
-          unit: 'years',
-        },
-        minFileSize: {
-          value: 5,
-          unit: 'GB',
-        },
-        maxQuality: '1080p',
-        maxRating: 6.5,
-        libraryIds: ['movies', 'tv'],
-        tags: ['unwatched', 'old'],
-        operator: 'AND',
-      })
-      expect(result.success).toBe(true)
-    })
-  })
-
-  describe('CreateMaintenanceRuleSchema', () => {
-    it('should accept valid rule with minimal required fields', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Delete old movies',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.enabled).toBe(true) // Default value
-      }
-    })
-
-    it('should reject rule without name', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject rule with empty name', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: '',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('Rule name is required')
-      }
-    })
-
-    it('should reject rule without mediaType', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject rule without criteria', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject rule with empty criteria', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false) // Empty conditions should fail
-    })
-
-    it('should reject rule without actionType', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should accept rule with description', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        description: 'This is a test rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.description).toBe('This is a test rule')
-      }
-    })
-
-    it('should accept rule with enabled set to false', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-        enabled: false,
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.enabled).toBe(false)
-      }
-    })
-
-    it('should accept rule with schedule', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-        schedule: '0 0 * * *',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.schedule).toBe('0 0 * * *')
-      }
-    })
-
-    it('should accept rule with TV_SERIES mediaType', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'TV Series Rule',
-        mediaType: 'TV_SERIES',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'AUTO_DELETE',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept rule with EPISODE mediaType', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Episode Rule',
-        mediaType: 'EPISODE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept rule with complex criteria', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Complex Rule',
-        description: 'A complex maintenance rule',
-        enabled: true,
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'lastWatchedAt',
-              operator: 'olderThan',
-              value: 12,
-              valueUnit: 'months',
-            },
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'rating',
-              operator: 'lessThanOrEqual',
-              value: 5,
-            },
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'libraryId',
-              operator: 'in',
-              value: ['movies'],
-            },
-          ],
-        },
-        actionType: 'AUTO_DELETE',
-        schedule: '0 2 * * 0',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject rule with invalid mediaType', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'AUDIO',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject rule with invalid actionType', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-        actionType: 'SOFT_DELETE',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject rule with invalid criteria', () => {
-      const result = CreateMaintenanceRuleSchema.safeParse({
-        name: 'Test Rule',
-        mediaType: 'MOVIE',
-        criteria: {
-          maxRating: 15, // Invalid: > 10
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('UpdateMaintenanceRuleSchema', () => {
-    it('should accept empty update object', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({})
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with only name', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        name: 'Updated Name',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject update with empty name', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        name: '',
-      })
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('Rule name is required')
-      }
-    })
-
-    it('should accept update with only description', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        description: 'New description',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with only enabled', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        enabled: false,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with only mediaType', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        mediaType: 'TV_SERIES',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with only criteria', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: true,
-            },
-          ],
-        },
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with only actionType', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        actionType: 'AUTO_DELETE',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with only schedule', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        schedule: '0 3 * * *',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with multiple fields', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        name: 'Updated Rule',
-        enabled: false,
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'rating',
-              operator: 'lessThanOrEqual',
-              value: 4,
-            },
-          ],
-        },
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should accept update with all fields', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        name: 'Fully Updated Rule',
-        description: 'Updated description',
-        enabled: true,
-        mediaType: 'EPISODE',
-        criteria: {
-          type: 'group',
-          id: generateId(),
-          operator: 'AND',
-          conditions: [
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'neverWatched',
-              operator: 'equals',
-              value: false,
-            },
-            {
-              type: 'condition',
-              id: generateId(),
-              field: 'playCount',
-              operator: 'lessThanOrEqual',
-              value: 3,
-            },
-          ],
-        },
-        actionType: 'FLAG_FOR_REVIEW',
-        schedule: '0 4 * * 1',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject update with invalid mediaType', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        mediaType: 'PODCAST',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject update with invalid actionType', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        actionType: 'ARCHIVE',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject update with invalid criteria', () => {
-      const result = UpdateMaintenanceRuleSchema.safeParse({
-        criteria: {
-          minFileSize: {
-            value: -100,
-            unit: 'GB',
-          },
-        },
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('CreateUserMediaMarkSchema', () => {
-    it('should accept valid mark with minimal required fields', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.markedVia).toBe('web') // Default value
-      }
-    })
-
-    it('should reject mark without mediaType', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject mark without plexRatingKey', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject mark with empty plexRatingKey', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '',
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('Plex rating key is required')
-      }
-    })
-
-    it('should reject mark without title', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject mark with empty title', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: '',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('Title is required')
-      }
-    })
-
-    it('should reject mark without markType', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should accept mark with radarrId', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        radarrId: 100,
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.radarrId).toBe(100)
-      }
-    })
-
-    it('should accept mark with sonarrId', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'TV_SERIES',
-        plexRatingKey: '12345',
-        sonarrId: 200,
-        title: 'Test Series',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.sonarrId).toBe(200)
-      }
-    })
-
-    it('should accept mark with year', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        year: 2023,
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.year).toBe(2023)
-      }
-    })
-
-    it('should accept mark with episode details', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'EPISODE',
-        plexRatingKey: '12345',
-        title: 'Test Episode',
-        seasonNumber: 1,
-        episodeNumber: 5,
-        parentTitle: 'Test Series',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.seasonNumber).toBe(1)
-        expect(result.data.episodeNumber).toBe(5)
-        expect(result.data.parentTitle).toBe('Test Series')
-      }
-    })
-
-    it('should accept mark with note', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        markType: 'POOR_QUALITY',
-        note: 'Low bitrate video',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.note).toBe('Low bitrate video')
-      }
-    })
-
-    it('should accept mark with custom markedVia', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-        markedVia: 'discord',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.markedVia).toBe('discord')
-      }
-    })
-
-    it('should accept mark with discordChannelId', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        markType: 'FINISHED_WATCHING',
-        discordChannelId: '123456789',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.discordChannelId).toBe('123456789')
-      }
-    })
-
-    it('should accept mark with all valid markTypes', () => {
-      const markTypes = [
-        'FINISHED_WATCHING',
-        'NOT_INTERESTED',
-        'KEEP_FOREVER',
-        'REWATCH_CANDIDATE',
-        'POOR_QUALITY',
-        'WRONG_VERSION',
-      ]
-
-      markTypes.forEach((markType) => {
-        const result = CreateUserMediaMarkSchema.safeParse({
-          mediaType: 'MOVIE',
-          plexRatingKey: '12345',
-          title: 'Test Movie',
-          markType,
-        })
-        expect(result.success).toBe(true)
-      })
-    })
-
-    it('should accept mark with all fields populated', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'EPISODE',
-        plexRatingKey: '12345',
-        radarrId: 100,
-        sonarrId: 200,
-        title: 'Test Episode',
-        year: 2023,
-        seasonNumber: 2,
-        episodeNumber: 10,
-        parentTitle: 'Test Series',
-        markType: 'WRONG_VERSION',
-        note: 'Need better quality',
-        markedVia: 'discord',
-        discordChannelId: '987654321',
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject mark with invalid mediaType', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MUSIC',
-        plexRatingKey: '12345',
-        title: 'Test Album',
-        markType: 'FINISHED_WATCHING',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject mark with invalid markType', () => {
-      const result = CreateUserMediaMarkSchema.safeParse({
-        mediaType: 'MOVIE',
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        markType: 'ARCHIVED',
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-
-  describe('CreateUserWatchIntentSchema', () => {
-    it('should accept valid intent with minimal required fields', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.priority).toBe(0) // Default value
-      }
-    })
-
-    it('should reject intent without plexRatingKey', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject intent with empty plexRatingKey', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '',
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('Plex rating key is required')
-      }
-    })
-
-    it('should reject intent without mediaType', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        title: 'Test Movie',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject intent without title', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject intent with empty title', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        title: '',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-      if (!result.success) {
-        expect(result.error.issues[0].message).toBe('Title is required')
-      }
-    })
-
-    it('should reject intent without intentType', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should accept intent with custom priority', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        intentType: 'PLAN_TO_WATCH',
-        priority: 5,
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.priority).toBe(5)
-      }
-    })
-
-    it('should accept intent with negative priority', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        intentType: 'PLAN_TO_WATCH',
-        priority: -1,
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.priority).toBe(-1)
-      }
-    })
-
-    it('should accept intent with currentSeason', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'TV_SERIES',
-        title: 'Test Series',
-        intentType: 'WATCHING',
-        currentSeason: 2,
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.currentSeason).toBe(2)
-      }
-    })
-
-    it('should accept intent with currentEpisode', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'TV_SERIES',
-        title: 'Test Series',
-        intentType: 'WATCHING',
-        currentEpisode: 5,
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.currentEpisode).toBe(5)
-      }
-    })
-
-    it('should accept intent with both currentSeason and currentEpisode', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'TV_SERIES',
-        title: 'Test Series',
-        intentType: 'WATCHING',
-        currentSeason: 3,
-        currentEpisode: 7,
-      })
-      expect(result.success).toBe(true)
-      if (result.success) {
-        expect(result.data.currentSeason).toBe(3)
-        expect(result.data.currentEpisode).toBe(7)
-      }
-    })
-
-    it('should accept all valid intentTypes', () => {
-      const intentTypes = [
-        'PLAN_TO_WATCH',
-        'WATCHING',
-        'COMPLETED',
-        'DROPPED',
-        'ON_HOLD',
-      ]
-
-      intentTypes.forEach((intentType) => {
-        const result = CreateUserWatchIntentSchema.safeParse({
-          plexRatingKey: '12345',
-          mediaType: 'MOVIE',
-          title: 'Test Movie',
-          intentType,
-        })
-        expect(result.success).toBe(true)
-      })
-    })
-
-    it('should accept intent with all fields populated', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'TV_SERIES',
-        title: 'Test Series',
-        intentType: 'WATCHING',
-        priority: 10,
-        currentSeason: 2,
-        currentEpisode: 8,
-      })
-      expect(result.success).toBe(true)
-    })
-
-    it('should reject intent with invalid mediaType', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'BOOK',
-        title: 'Test Book',
-        intentType: 'PLAN_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-    })
-
-    it('should reject intent with invalid intentType', () => {
-      const result = CreateUserWatchIntentSchema.safeParse({
-        plexRatingKey: '12345',
-        mediaType: 'MOVIE',
-        title: 'Test Movie',
-        intentType: 'WANT_TO_WATCH',
-      })
-      expect(result.success).toBe(false)
-    })
-  })
-})
diff --git a/lib/validations/maintenance.ts b/lib/validations/maintenance.ts
deleted file mode 100644
index 0d85219e..00000000
--- a/lib/validations/maintenance.ts
+++ /dev/null
@@ -1,440 +0,0 @@
-import { z } from "zod"
-
-/**
- * Validates a cron expression pattern
- * Supports standard 5-field cron format: minute hour day month weekday
- * Example: "0 2 * * *" (daily at 2 AM)
- */
-function isValidCronExpression(cron: string): boolean {
-  // Standard 5-field cron: minute hour day-of-month month day-of-week
-  // Each field can be: number, *, */n, n-m, or comma-separated values
-  const fieldPatterns = [
-    /^(\*|(\*\/[1-9]\d*)|([0-5]?\d)(,[0-5]?\d)*|([0-5]?\d-[0-5]?\d))$/, // minute (0-59)
-    /^(\*|(\*\/[1-9]\d*)|(1?\d|2[0-3])(,(1?\d|2[0-3]))*|(1?\d|2[0-3])-(1?\d|2[0-3]))$/, // hour (0-23)
-    /^(\*|(\*\/[1-9]\d*)|([1-9]|[12]\d|3[01])(,([1-9]|[12]\d|3[01]))*|([1-9]|[12]\d|3[01])-([1-9]|[12]\d|3[01]))$/, // day (1-31)
-    /^(\*|(\*\/[1-9]\d*)|([1-9]|1[0-2])(,([1-9]|1[0-2]))*|([1-9]|1[0-2])-([1-9]|1[0-2]))$/, // month (1-12)
-    /^(\*|(\*\/[1-9]\d*)|[0-6](,[0-6])*|[0-6]-[0-6])$/, // weekday (0-6, 0=Sunday)
-  ]
-
-  const fields = cron.trim().split(/\s+/)
-  if (fields.length !== 5) {
-    return false
-  }
-
-  return fields.every((field, index) => fieldPatterns[index].test(field))
-}
-
-// Cron schedule schema with validation
-// Validates cron expression format when provided, allows empty/undefined/null
-const CronScheduleSchema = z.preprocess(
-  // First, normalize the input: undefined, null, empty string all become null
-  (val) => {
-    if (val === undefined || val === null) return null
-    if (typeof val === "string" && val.trim() === "") return null
-    return val
-  },
-  // Then validate: null is allowed, or must be valid cron
-  z.union([
-    z.null(),
-    z.string().refine((val) => isValidCronExpression(val), {
-      message: "Invalid cron expression. Use 5-field format: minute hour day month weekday (e.g., '0 2 * * *' for daily at 2 AM)",
-    }),
-  ])
-)
-
-// Enums matching Prisma schema
-export const MediaTypeEnum = z.enum(["MOVIE", "TV_SERIES", "EPISODE"])
-
-export const MarkTypeEnum = z.enum([
-  "FINISHED_WATCHING",
-  "NOT_INTERESTED",
-  "KEEP_FOREVER",
-  "REWATCH_CANDIDATE",
-  "POOR_QUALITY",
-  "WRONG_VERSION",
-])
-
-export const IntentTypeEnum = z.enum([
-  "PLAN_TO_WATCH",
-  "WATCHING",
-  "COMPLETED",
-  "DROPPED",
-  "ON_HOLD",
-])
-
-export const ScanStatusEnum = z.enum([
-  "PENDING",
-  "RUNNING",
-  "COMPLETED",
-  "FAILED",
-])
-
-export const ReviewStatusEnum = z.enum([
-  "PENDING",
-  "APPROVED",
-  "REJECTED",
-  "DELETED",
-])
-
-export const ActionTypeEnum = z.enum([
-  "FLAG_FOR_REVIEW",
-  "AUTO_DELETE",
-  "UNMONITOR_AND_DELETE",
-  "UNMONITOR_AND_KEEP",
-  "DO_NOTHING",
-])
-
-// Hierarchical rule criteria schema
-// Condition value schema (can be string, number, boolean, array, or null)
-const ConditionValueSchema = z.union([
-  z.string(),
-  z.number(),
-  z.boolean(),
-  z.array(z.string()),
-  z.array(z.number()),
-  z.null(),
-])
-
-// Base condition schema (atomic leaf node in rule tree)
-export const ConditionSchema = z.object({
-  type: z.literal('condition'),
-  id: z.string(),
-  field: z.string(), // Field key from field registry
-  operator: z.string(), // Operator validated at runtime against field's allowedOperators
-  value: ConditionValueSchema,
-  valueUnit: z.enum(['days', 'months', 'years', 'MB', 'GB', 'TB']).optional(),
-})
-
-// Condition group schema (branch node that can contain conditions or other groups)
-export const ConditionGroupSchema: z.ZodType<ConditionGroup> = z.lazy(() =>
-  z.object({
-    type: z.literal('group'),
-    id: z.string(),
-    operator: z.enum(['AND', 'OR']),
-    conditions: z.array(z.union([ConditionSchema, ConditionGroupSchema])).min(1, "Group must have at least one condition"),
-  })
-)
-
-// Root criteria is always a condition group
-export const RuleCriteriaSchema = ConditionGroupSchema
-
-// Legacy criteria schema for backwards compatibility
-export const LegacyRuleCriteriaSchema = z.object({
-  neverWatched: z.boolean().optional(),
-  lastWatchedBefore: z
-    .object({
-      value: z.number().min(1),
-      unit: z.enum(["days", "months", "years"]),
-    })
-    .optional(),
-  maxPlayCount: z.number().min(0).optional(),
-  addedBefore: z
-    .object({
-      value: z.number().min(1),
-      unit: z.enum(["days", "months", "years"]),
-    })
-    .optional(),
-  minFileSize: z
-    .object({
-      value: z.number().min(0),
-      unit: z.enum(["MB", "GB", "TB"]),
-    })
-    .optional(),
-  maxQuality: z.string().optional(),
-  maxRating: z.number().min(0).max(10).optional(),
-  libraryIds: z.array(z.string()).optional(),
-  tags: z.array(z.string()).optional(),
-  operator: z.enum(["AND", "OR"]).default("AND"),
-})
-
-// Maintenance rule schemas
-export const CreateMaintenanceRuleSchema = z.object({
-  name: z.string().min(1, "Rule name is required"),
-  description: z.string().optional(),
-  enabled: z.boolean().default(true),
-  mediaType: MediaTypeEnum,
-  criteria: RuleCriteriaSchema,
-  actionType: ActionTypeEnum,
-  actionDelayDays: z.number().int().min(0).optional(),
-  radarrId: z.string().optional(),
-  sonarrId: z.string().optional(),
-  schedule: CronScheduleSchema,
-})
-
-export const UpdateMaintenanceRuleSchema = z.object({
-  name: z.string().min(1, "Rule name is required").optional(),
-  description: z.string().optional(),
-  enabled: z.boolean().optional(),
-  mediaType: MediaTypeEnum.optional(),
-  criteria: RuleCriteriaSchema.optional(),
-  actionType: ActionTypeEnum.optional(),
-  actionDelayDays: z.number().int().min(0).optional(),
-  radarrId: z.string().optional(),
-  sonarrId: z.string().optional(),
-  schedule: CronScheduleSchema,
-})
-
-// User media mark schemas
-export const CreateUserMediaMarkSchema = z.object({
-  mediaType: MediaTypeEnum,
-  plexRatingKey: z.string().min(1, "Plex rating key is required"),
-  radarrId: z.number().optional(),
-  sonarrId: z.number().optional(),
-  title: z.string().min(1, "Title is required"),
-  year: z.number().optional(),
-  seasonNumber: z.number().optional(),
-  episodeNumber: z.number().optional(),
-  parentTitle: z.string().optional(),
-  markType: MarkTypeEnum,
-  note: z.string().optional(),
-  markedVia: z.string().default("web"),
-  discordChannelId: z.string().optional(),
-})
-
-// User watch intent schemas
-export const CreateUserWatchIntentSchema = z.object({
-  plexRatingKey: z.string().min(1, "Plex rating key is required"),
-  mediaType: MediaTypeEnum,
-  title: z.string().min(1, "Title is required"),
-  intentType: IntentTypeEnum,
-  priority: z.number().default(0),
-  currentSeason: z.number().optional(),
-  currentEpisode: z.number().optional(),
-})
-
-// Hierarchical rule type definitions (explicit types for recursive structure)
-export interface Condition {
-  type: 'condition'
-  id: string
-  field: string
-  operator: string
-  value: string | number | boolean | string[] | number[] | null
-  valueUnit?: 'days' | 'months' | 'years' | 'MB' | 'GB' | 'TB'
-}
-
-export interface ConditionGroup {
-  type: 'group'
-  id: string
-  operator: 'AND' | 'OR'
-  conditions: Array<Condition | ConditionGroup>
-}
-
-// Type exports
-export type MediaType = z.infer<typeof MediaTypeEnum>
-export type MarkType = z.infer<typeof MarkTypeEnum>
-export type IntentType = z.infer<typeof IntentTypeEnum>
-export type ScanStatus = z.infer<typeof ScanStatusEnum>
-export type ReviewStatus = z.infer<typeof ReviewStatusEnum>
-export type ActionType = z.infer<typeof ActionTypeEnum>
-
-export type RuleCriteria = ConditionGroup // Root is always a group
-export type LegacyRuleCriteria = z.infer<typeof LegacyRuleCriteriaSchema>
-export type CreateMaintenanceRule = z.infer<typeof CreateMaintenanceRuleSchema>
-export type UpdateMaintenanceRule = z.infer<typeof UpdateMaintenanceRuleSchema>
-export type CreateUserMediaMark = z.infer<typeof CreateUserMediaMarkSchema>
-export type CreateUserWatchIntent = z.infer<typeof CreateUserWatchIntentSchema>
-
-// Pagination schema for candidate listing
-export const CandidatePaginationSchema = z.object({
-  page: z.number().int().min(1).default(1),
-  pageSize: z.number().int().min(1).max(100).default(25),
-  reviewStatus: ReviewStatusEnum.optional(),
-  mediaType: MediaTypeEnum.optional(),
-  scanId: z.string().optional(),
-})
-
-export type CandidatePagination = z.infer<typeof CandidatePaginationSchema>
-
-/**
- * Runtime validation for rule criteria
- * Validates field/operator compatibility and media type constraints
- */
-export function validateRuleCriteria(
-  criteria: RuleCriteria,
-  mediaType: MediaType
-): { valid: boolean; errors: string[] } {
-  const errors: string[] = []
-
-  // Import field registry dynamically to avoid circular dependencies
-  const { FIELD_DEFINITIONS } = require('@/lib/maintenance/field-registry') as { FIELD_DEFINITIONS: import('@/lib/maintenance/field-registry').FieldDefinition[] }
-
-  function validateNode(node: Condition | ConditionGroup, path = 'root'): void {
-    if (node.type === 'condition') {
-      const fieldDef = FIELD_DEFINITIONS.find((f) => f.key === node.field)
-
-      if (!fieldDef) {
-        errors.push(`${path}: Unknown field "${node.field}"`)
-        return
-      }
-
-      if (!fieldDef.mediaTypes.includes(mediaType)) {
-        errors.push(
-          `${path}: Field "${node.field}" not available for media type ${mediaType}`
-        )
-      }
-
-      if (!(fieldDef.allowedOperators as string[]).includes(node.operator)) {
-        errors.push(
-          `${path}: Operator "${node.operator}" not allowed for field "${node.field}"`
-        )
-      }
-
-      // Type-specific value validation
-      if (node.value !== null && node.value !== undefined) {
-        if (fieldDef.type === 'number' && typeof node.value !== 'number') {
-          errors.push(`${path}: Field "${node.field}" expects a number value`)
-        }
-        if (fieldDef.type === 'boolean' && typeof node.value !== 'boolean') {
-          errors.push(`${path}: Field "${node.field}" expects a boolean value`)
-        }
-        if (fieldDef.type === 'array' && !Array.isArray(node.value)) {
-          errors.push(`${path}: Field "${node.field}" expects an array value`)
-        }
-      }
-    } else {
-      // Validate group
-      if (node.conditions.length === 0) {
-        errors.push(`${path}: Condition group must have at least one condition`)
-      }
-
-      node.conditions.forEach((child, index) => {
-        validateNode(child, `${path}.conditions[${index}]`)
-      })
-    }
-  }
-
-  validateNode(criteria)
-
-  return {
-    valid: errors.length === 0,
-    errors,
-  }
-}
-
-/**
- * Migrate legacy flat rule criteria to hierarchical format
- */
-export function migrateLegacyRuleCriteria(legacy: LegacyRuleCriteria): RuleCriteria {
-  const { generateId } = require('@/lib/maintenance/field-registry')
-  const conditions: Array<Condition | ConditionGroup> = []
-
-  if (legacy.neverWatched !== undefined) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'neverWatched',
-      operator: 'equals',
-      value: legacy.neverWatched,
-    })
-  }
-
-  if (legacy.lastWatchedBefore) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'lastWatchedAt',
-      operator: 'olderThan',
-      value: legacy.lastWatchedBefore.value,
-      valueUnit: legacy.lastWatchedBefore.unit,
-    })
-  }
-
-  if (legacy.maxPlayCount !== undefined) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'playCount',
-      operator: 'lessThanOrEqual',
-      value: legacy.maxPlayCount,
-    })
-  }
-
-  if (legacy.addedBefore) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'addedAt',
-      operator: 'olderThan',
-      value: legacy.addedBefore.value,
-      valueUnit: legacy.addedBefore.unit,
-    })
-  }
-
-  if (legacy.minFileSize) {
-    // Convert to bytes
-    let bytes = legacy.minFileSize.value
-    if (legacy.minFileSize.unit === 'GB') bytes *= 1024 * 1024 * 1024
-    else if (legacy.minFileSize.unit === 'TB') bytes *= 1024 * 1024 * 1024 * 1024
-    else bytes *= 1024 * 1024 // MB
-
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'fileSize',
-      operator: 'greaterThanOrEqual',
-      value: bytes,
-    })
-  }
-
-  if (legacy.maxQuality) {
-    // For maxQuality, we need to check if resolution is <= maxQuality alphabetically
-    // Since resolution is an enum, we'll use a custom approach: check if resolution equals or is in a list
-    // For now, we'll use 'in' operator with all values <= maxQuality
-    // This is a simplified approach - in practice, you'd need to know all enum values
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'resolution',
-      operator: 'lessThanOrEqual', // This will be handled specially for enum/string comparison
-      value: legacy.maxQuality,
-    })
-  }
-
-  if (legacy.maxRating !== undefined) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'rating',
-      operator: 'lessThanOrEqual',
-      value: legacy.maxRating,
-    })
-  }
-
-  if (legacy.libraryIds && legacy.libraryIds.length > 0) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'libraryId',
-      operator: 'in',
-      value: legacy.libraryIds,
-    })
-  }
-
-  if (legacy.tags && legacy.tags.length > 0) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'labels',
-      operator: 'containsAny',
-      value: legacy.tags,
-    })
-  }
-
-  // If no conditions, create a default "never watched" condition
-  if (conditions.length === 0) {
-    conditions.push({
-      type: 'condition',
-      id: generateId(),
-      field: 'neverWatched',
-      operator: 'equals',
-      value: true,
-    })
-  }
-
-  return {
-    type: 'group',
-    id: generateId(),
-    operator: legacy.operator || 'AND',
-    conditions,
-  }
-}
diff --git a/lib/validations/user-media.ts b/lib/validations/user-media.ts
new file mode 100644
index 00000000..a0f9716c
--- /dev/null
+++ b/lib/validations/user-media.ts
@@ -0,0 +1,56 @@
+import { z } from "zod"
+
+// Enums matching Prisma schema
+export const MediaTypeEnum = z.enum(["MOVIE", "TV_SERIES", "EPISODE"])
+
+export const MarkTypeEnum = z.enum([
+  "FINISHED_WATCHING",
+  "NOT_INTERESTED",
+  "KEEP_FOREVER",
+  "REWATCH_CANDIDATE",
+  "POOR_QUALITY",
+  "WRONG_VERSION",
+])
+
+export const IntentTypeEnum = z.enum([
+  "PLAN_TO_WATCH",
+  "WATCHING",
+  "COMPLETED",
+  "DROPPED",
+  "ON_HOLD",
+])
+
+// User media mark schemas
+export const CreateUserMediaMarkSchema = z.object({
+  mediaType: MediaTypeEnum,
+  plexRatingKey: z.string().min(1, "Plex rating key is required"),
+  radarrId: z.number().optional(),
+  sonarrId: z.number().optional(),
+  title: z.string().min(1, "Title is required"),
+  year: z.number().optional(),
+  seasonNumber: z.number().optional(),
+  episodeNumber: z.number().optional(),
+  parentTitle: z.string().optional(),
+  markType: MarkTypeEnum,
+  note: z.string().optional(),
+  markedVia: z.string().default("web"),
+  discordChannelId: z.string().optional(),
+})
+
+// User watch intent schemas
+export const CreateUserWatchIntentSchema = z.object({
+  plexRatingKey: z.string().min(1, "Plex rating key is required"),
+  mediaType: MediaTypeEnum,
+  title: z.string().min(1, "Title is required"),
+  intentType: IntentTypeEnum,
+  priority: z.number().default(0),
+  currentSeason: z.number().optional(),
+  currentEpisode: z.number().optional(),
+})
+
+// Type exports
+export type MediaType = z.infer<typeof MediaTypeEnum>
+export type MarkType = z.infer<typeof MarkTypeEnum>
+export type IntentType = z.infer<typeof IntentTypeEnum>
+export type CreateUserMediaMark = z.infer<typeof CreateUserMediaMarkSchema>
+export type CreateUserWatchIntent = z.infer<typeof CreateUserWatchIntentSchema>
diff --git a/prisma/migrations/20251206172926_remove_maintenance_tables/migration.sql b/prisma/migrations/20251206172926_remove_maintenance_tables/migration.sql
new file mode 100644
index 00000000..bcf0166d
--- /dev/null
+++ b/prisma/migrations/20251206172926_remove_maintenance_tables/migration.sql
@@ -0,0 +1,44 @@
+/*
+  Warnings:
+
+  - You are about to drop the `MaintenanceCandidate` table. If the table is not empty, all the data it contains will be lost.
+  - You are about to drop the `MaintenanceDeletionLog` table. If the table is not empty, all the data it contains will be lost.
+  - You are about to drop the `MaintenanceRule` table. If the table is not empty, all the data it contains will be lost.
+  - You are about to drop the `MaintenanceScan` table. If the table is not empty, all the data it contains will be lost.
+
+*/
+-- AlterEnum
+ALTER TYPE "DiscordCommandType" ADD VALUE 'HELP';
+
+-- DropForeignKey
+ALTER TABLE "MaintenanceCandidate" DROP CONSTRAINT "MaintenanceCandidate_scanId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "MaintenanceRule" DROP CONSTRAINT "MaintenanceRule_radarrId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "MaintenanceRule" DROP CONSTRAINT "MaintenanceRule_sonarrId_fkey";
+
+-- DropForeignKey
+ALTER TABLE "MaintenanceScan" DROP CONSTRAINT "MaintenanceScan_ruleId_fkey";
+
+-- DropTable
+DROP TABLE "MaintenanceCandidate";
+
+-- DropTable
+DROP TABLE "MaintenanceDeletionLog";
+
+-- DropTable
+DROP TABLE "MaintenanceRule";
+
+-- DropTable
+DROP TABLE "MaintenanceScan";
+
+-- DropEnum
+DROP TYPE "ActionType";
+
+-- DropEnum
+DROP TYPE "ReviewStatus";
+
+-- DropEnum
+DROP TYPE "ScanStatus";
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index f8cd5a01..e6f4c203 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -97,9 +97,6 @@ model Sonarr {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  // Relations
-  maintenanceRules MaintenanceRule[]
-
   @@index([isActive])
 }
 
@@ -113,9 +110,6 @@ model Radarr {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 
-  // Relations
-  maintenanceRules MaintenanceRule[]
-
   @@index([isActive])
 }
 
@@ -360,138 +354,6 @@ model InviteUsage {
   @@index([userId])
 }
 
-// Library Maintenance Models
-model MaintenanceRule {
-  id          String   @id @default(cuid())
-  name        String
-  description String?
-  enabled     Boolean  @default(true)
-  mediaType   MediaType
-
-  // Rule criteria stored as JSON
-  criteria    Json
-
-  // Actions
-  actionType  ActionType
-  actionDelayDays Int? // Optional delay before executing action (in days)
-
-  // Target server instances (optional - defaults to active server if not specified)
-  radarrId    String?
-  radarr      Radarr?  @relation(fields: [radarrId], references: [id], onDelete: SetNull)
-  sonarrId    String?
-  sonarr      Sonarr?  @relation(fields: [sonarrId], references: [id], onDelete: SetNull)
-
-  // Schedule (cron expression)
-  schedule    String?
-
-  // Statistics
-  lastRunAt   DateTime?
-  nextRunAt   DateTime?
-
-  createdAt   DateTime @default(now())
-  updatedAt   DateTime @updatedAt
-
-  // Relations
-  scans       MaintenanceScan[]
-
-  @@index([enabled])
-  @@index([nextRunAt])
-  @@index([mediaType])
-}
-
-model MaintenanceScan {
-  id              String   @id @default(cuid())
-  ruleId          String
-  rule            MaintenanceRule @relation(fields: [ruleId], references: [id], onDelete: Cascade)
-
-  status          ScanStatus
-  startedAt       DateTime?
-  completedAt     DateTime?
-  error           String?
-
-  // Statistics
-  itemsScanned    Int      @default(0)
-  itemsFlagged    Int      @default(0)
-
-  createdAt       DateTime @default(now())
-
-  // Relations
-  candidates      MaintenanceCandidate[]
-
-  @@index([ruleId, createdAt])
-  @@index([status])
-}
-
-model MaintenanceCandidate {
-  id              String   @id @default(cuid())
-  scanId          String
-  scan            MaintenanceScan @relation(fields: [scanId], references: [id], onDelete: Cascade)
-
-  // Media identification
-  mediaType       MediaType
-  plexRatingKey   String
-  radarrId        Int?
-  sonarrId        Int?
-  tmdbId          Int?
-  tvdbId          Int?
-
-  // Media details (cached for display)
-  title           String
-  year            Int?
-  poster          String?
-  filePath        String?
-  fileSize        BigInt?
-
-  // Watch statistics
-  playCount       Int      @default(0)
-  lastWatchedAt   DateTime?
-  addedAt         DateTime?
-
-  // Rule evaluation
-  matchedRules    Json
-  flaggedAt       DateTime @default(now())
-
-  // Review status
-  reviewStatus    ReviewStatus
-  reviewedAt      DateTime?
-  reviewedBy      String?
-  reviewNote      String?
-
-  // Deletion tracking
-  deletedAt       DateTime?
-  deletionError   String?
-
-  createdAt       DateTime @default(now())
-  updatedAt       DateTime @updatedAt
-
-  @@index([scanId, reviewStatus])
-  @@index([mediaType, reviewStatus])
-  @@index([reviewStatus, flaggedAt])
-  @@index([mediaType, plexRatingKey])
-  @@unique([scanId, plexRatingKey])
-}
-
-model MaintenanceDeletionLog {
-  id              String   @id @default(cuid())
-  candidateId     String?
-
-  mediaType       MediaType
-  title           String
-  year            Int?
-  fileSize        BigInt?
-
-  deletedBy       String
-  deletedAt       DateTime @default(now())
-
-  deletedFrom     String
-  filesDeleted    Boolean
-
-  ruleNames       Json
-
-  @@index([deletedAt])
-  @@index([deletedBy])
-}
-
 model UserMediaMark {
   id              String   @id @default(cuid())
   userId          String
@@ -565,28 +427,6 @@ enum MediaType {
   EPISODE
 }
 
-enum ScanStatus {
-  PENDING
-  RUNNING
-  COMPLETED
-  FAILED
-}
-
-enum ReviewStatus {
-  PENDING
-  APPROVED
-  REJECTED
-  DELETED
-}
-
-enum ActionType {
-  FLAG_FOR_REVIEW      // Flag media for manual review
-  AUTO_DELETE          // Automatically delete from disk and remove from Radarr/Sonarr
-  UNMONITOR_AND_DELETE // Unmonitor in Radarr/Sonarr and delete from disk
-  UNMONITOR_AND_KEEP   // Unmonitor in Radarr/Sonarr but keep files
-  DO_NOTHING           // Take no action (useful for reporting only)
-}
-
 enum MarkType {
   FINISHED_WATCHING
   NOT_INTERESTED
diff --git a/scripts/performance/profile-maintenance-query.ts b/scripts/performance/profile-maintenance-query.ts
deleted file mode 100644
index 97a735ce..00000000
--- a/scripts/performance/profile-maintenance-query.ts
+++ /dev/null
@@ -1,661 +0,0 @@
-/**
- * Script to profile maintenance rule query performance
- * Issue #39: Investigate potential N+1 query in maintenance rule fetching
- * Issue #108: Enhanced profiling tooling
- *
- * Usage:
- *   npx tsx scripts/performance/profile-maintenance-query.ts [options]
- *
- * Options:
- *   --seed          Create synthetic test data
- *   --cleanup       Remove synthetic test data after profiling
- *   --rules=N       Number of rules to seed (default: 100)
- *   --scans=N       Number of scans per rule to seed (default: 10)
- *   --export=FORMAT Export results (json, csv, or both)
- *   --output=PATH   Output directory for exports (default: ./profiling-results)
- *   --memory        Enable memory profiling alongside timing metrics
- *   --iterations=N  Number of iterations per test (default: 5)
- *   --help          Show help
- *
- * Examples:
- *   npx tsx scripts/performance/profile-maintenance-query.ts --seed --rules=200 --scans=50
- *   npx tsx scripts/performance/profile-maintenance-query.ts --seed --export=json --memory
- *   npx tsx scripts/performance/profile-maintenance-query.ts --seed --cleanup --export=both --output=./results
- */
-
-import { PrismaClient } from "../../lib/generated/prisma/client"
-import { PrismaPg } from "@prisma/adapter-pg"
-import * as fs from "fs"
-import * as path from "path"
-
-// Parse command line arguments
-function parseArgs(): {
-  seed: boolean
-  cleanup: boolean
-  rules: number
-  scans: number
-  export: "json" | "csv" | "both" | null
-  output: string
-  memory: boolean
-  iterations: number
-  help: boolean
-} {
-  const args = process.argv.slice(2)
-  const config = {
-    seed: false,
-    cleanup: false,
-    rules: 100,
-    scans: 10,
-    export: null as "json" | "csv" | "both" | null,
-    output: "./profiling-results",
-    memory: false,
-    iterations: 5,
-    help: false,
-  }
-
-  for (const arg of args) {
-    if (arg === "--seed") config.seed = true
-    else if (arg === "--cleanup") config.cleanup = true
-    else if (arg === "--memory") config.memory = true
-    else if (arg === "--help" || arg === "-h") config.help = true
-    else if (arg.startsWith("--rules=")) {
-      const value = parseInt(arg.split("=")[1], 10)
-      if (!isNaN(value) && value > 0) config.rules = value
-    } else if (arg.startsWith("--scans=")) {
-      const value = parseInt(arg.split("=")[1], 10)
-      if (!isNaN(value) && value >= 0) config.scans = value
-    } else if (arg.startsWith("--iterations=")) {
-      const value = parseInt(arg.split("=")[1], 10)
-      if (!isNaN(value) && value > 0) config.iterations = value
-    } else if (arg.startsWith("--export=")) {
-      const value = arg.split("=")[1] as "json" | "csv" | "both"
-      if (["json", "csv", "both"].includes(value)) config.export = value
-    } else if (arg.startsWith("--output=")) {
-      config.output = arg.split("=")[1]
-    }
-  }
-
-  return config
-}
-
-function showHelp() {
-  console.log(`
-Maintenance Query Performance Profiler
-
-Usage:
-  npx tsx scripts/performance/profile-maintenance-query.ts [options]
-
-Options:
-  --seed          Create synthetic test data
-  --cleanup       Remove synthetic test data after profiling
-  --rules=N       Number of rules to seed (default: 100)
-  --scans=N       Number of scans per rule to seed (default: 10)
-  --export=FORMAT Export results (json, csv, or both)
-  --output=PATH   Output directory for exports (default: ./profiling-results)
-  --memory        Enable memory profiling alongside timing metrics
-  --iterations=N  Number of iterations per test (default: 5)
-  --help, -h      Show this help message
-
-Examples:
-  # Basic profiling with existing data
-  npx tsx scripts/performance/profile-maintenance-query.ts
-
-  # Seed data and run profiling
-  npx tsx scripts/performance/profile-maintenance-query.ts --seed
-
-  # Custom data size with memory profiling
-  npx tsx scripts/performance/profile-maintenance-query.ts --seed --rules=200 --scans=50 --memory
-
-  # Export results to JSON
-  npx tsx scripts/performance/profile-maintenance-query.ts --seed --export=json
-
-  # Full profiling with cleanup and export
-  npx tsx scripts/performance/profile-maintenance-query.ts --seed --cleanup --export=both --memory
-`)
-}
-
-if (!process.env.DATABASE_URL) {
-  throw new Error("DATABASE_URL environment variable is not defined")
-}
-
-const adapter = new PrismaPg({
-  connectionString: process.env.DATABASE_URL,
-})
-
-const prisma = new PrismaClient({
-  adapter,
-  log: [
-    { emit: "event", level: "query" },
-    { emit: "stdout", level: "info" },
-    { emit: "stdout", level: "warn" },
-    { emit: "stdout", level: "error" },
-  ],
-})
-
-const TEST_DATA_PREFIX = "__PERF_TEST__"
-
-interface QueryLog {
-  query: string
-  params: string
-  duration: number
-  timestamp: Date
-}
-
-interface MemorySnapshot {
-  heapUsed: number
-  heapTotal: number
-  external: number
-  arrayBuffers: number
-  rss: number
-}
-
-interface ProfilingResult {
-  timestamp: string
-  config: {
-    ruleCount: number
-    scanCount: number
-    iterations: number
-    memoryEnabled: boolean
-  }
-  current: {
-    times: number[]
-    avgDuration: number
-    minDuration: number
-    maxDuration: number
-    queryCount: number
-    memory?: MemorySnapshot
-  }
-  optimized: {
-    times: number[]
-    avgDuration: number
-    minDuration: number
-    maxDuration: number
-    queryCount: number
-    memory?: MemorySnapshot
-  }
-  improvement: number
-  recommendation: string
-}
-
-const queryLogs: QueryLog[] = []
-
-// Log all queries for analysis
-prisma.$on("query", (e) => {
-  queryLogs.push({
-    query: e.query,
-    params: e.params,
-    duration: e.duration,
-    timestamp: new Date(),
-  })
-})
-
-function getMemorySnapshot(): MemorySnapshot {
-  const usage = process.memoryUsage()
-  return {
-    heapUsed: usage.heapUsed,
-    heapTotal: usage.heapTotal,
-    external: usage.external,
-    arrayBuffers: usage.arrayBuffers,
-    rss: usage.rss,
-  }
-}
-
-function formatBytes(bytes: number): string {
-  const units = ["B", "KB", "MB", "GB"]
-  let unitIndex = 0
-  let value = bytes
-  while (value >= 1024 && unitIndex < units.length - 1) {
-    value /= 1024
-    unitIndex++
-  }
-  return `${value.toFixed(2)} ${units[unitIndex]}`
-}
-
-async function seedTestData(ruleCount: number, scansPerRule: number) {
-  console.log(`\nSeeding test data: ${ruleCount} rules with ${scansPerRule} scans each...`)
-
-  const start = Date.now()
-
-  // Batch create for better performance
-  const batchSize = 50
-  for (let batch = 0; batch < ruleCount; batch += batchSize) {
-    const batchEnd = Math.min(batch + batchSize, ruleCount)
-
-    for (let i = batch; i < batchEnd; i++) {
-      const rule = await prisma.maintenanceRule.create({
-        data: {
-          name: `${TEST_DATA_PREFIX} Rule ${i + 1}`,
-          description: `Performance test rule ${i + 1}`,
-          enabled: i % 2 === 0,
-          mediaType: i % 2 === 0 ? "MOVIE" : "TV_SERIES",
-          criteria: {
-            type: "group",
-            id: `group-${i}`,
-            operator: "AND",
-            conditions: [
-              {
-                type: "condition",
-                id: `cond-${i}`,
-                field: "lastWatchedAt",
-                operator: "olderThan",
-                value: 30 + i,
-                valueUnit: "days",
-              },
-            ],
-          },
-          actionType: "FLAG_FOR_REVIEW",
-          schedule: "0 0 * * *",
-        },
-      })
-
-      // Create scans for this rule
-      if (scansPerRule > 0) {
-        const scanData = Array.from({ length: scansPerRule }, (_, j) => ({
-          ruleId: rule.id,
-          status: "COMPLETED" as const,
-          startedAt: new Date(Date.now() - (scansPerRule - j) * 86400000),
-          completedAt: new Date(Date.now() - (scansPerRule - j) * 86400000 + 60000),
-          itemsScanned: 100 + j * 10,
-          itemsFlagged: j * 2,
-        }))
-
-        await prisma.maintenanceScan.createMany({ data: scanData })
-      }
-    }
-
-    // Progress indicator
-    const progress = Math.round((batchEnd / ruleCount) * 100)
-    process.stdout.write(`\r  Progress: ${progress}%`)
-  }
-
-  const duration = Date.now() - start
-  const totalRecords = ruleCount * (1 + scansPerRule)
-  console.log(`\n  Seeded ${totalRecords} records in ${duration}ms`)
-}
-
-async function cleanupTestData() {
-  console.log("\nCleaning up test data...")
-
-  const rules = await prisma.maintenanceRule.findMany({
-    where: { name: { startsWith: TEST_DATA_PREFIX } },
-    select: { id: true },
-  })
-
-  // Cascading delete will handle scans
-  await prisma.maintenanceRule.deleteMany({
-    where: { name: { startsWith: TEST_DATA_PREFIX } },
-  })
-
-  console.log(`  Deleted ${rules.length} test rules and their scans`)
-}
-
-async function runCurrentQuery(): Promise<{ duration: number; resultCount: number }> {
-  queryLogs.length = 0 // Clear previous logs
-
-  const start = Date.now()
-
-  const rules = await prisma.maintenanceRule.findMany({
-    orderBy: { createdAt: "desc" },
-    include: {
-      scans: {
-        orderBy: { createdAt: "desc" },
-        take: 1,
-        select: {
-          id: true,
-          status: true,
-          itemsScanned: true,
-          itemsFlagged: true,
-          completedAt: true,
-        },
-      },
-      _count: {
-        select: {
-          scans: true,
-        },
-      },
-    },
-  })
-
-  const duration = Date.now() - start
-
-  return { duration, resultCount: rules.length }
-}
-
-async function runOptimizedQuery(): Promise<{
-  duration: number
-  resultCount: number
-  scanFetched: number
-}> {
-  queryLogs.length = 0 // Clear previous logs
-
-  const start = Date.now()
-
-  // Fetch rules without relations first
-  const rules = await prisma.maintenanceRule.findMany({
-    orderBy: { createdAt: "desc" },
-  })
-
-  const ruleIds = rules.map((r) => r.id)
-
-  // Fetch latest scans using Prisma's distinct to avoid N+1
-  const latestScans = await prisma.maintenanceScan.findMany({
-    where: {
-      ruleId: { in: ruleIds },
-    },
-    orderBy: { createdAt: "desc" },
-    distinct: ["ruleId"],
-    select: {
-      id: true,
-      ruleId: true,
-      status: true,
-      itemsScanned: true,
-      itemsFlagged: true,
-      completedAt: true,
-    },
-  })
-
-  // Get scan counts per rule
-  const scanCounts = await prisma.maintenanceScan.groupBy({
-    by: ["ruleId"],
-    where: { ruleId: { in: ruleIds } },
-    _count: { id: true },
-  })
-
-  const duration = Date.now() - start
-
-  // Create a map for easy lookup
-  const scansByRuleId = new Map(latestScans.map((s) => [s.ruleId, s]))
-  const countsByRuleId = new Map(scanCounts.map((c) => [c.ruleId, c._count.id]))
-
-  // Combine results (for demonstration)
-  const combinedResults = rules.map((rule) => ({
-    ...rule,
-    latestScan: scansByRuleId.get(rule.id) || null,
-    scanCount: countsByRuleId.get(rule.id) || 0,
-  }))
-
-  return {
-    duration,
-    resultCount: combinedResults.length,
-    scanFetched: latestScans.length,
-  }
-}
-
-function getQueryCount(): number {
-  return queryLogs.length
-}
-
-function printQueryAnalysis(label: string) {
-  console.log(`\n--- Query Analysis: ${label} ---`)
-  console.log(`  Total queries: ${queryLogs.length}`)
-
-  const totalDuration = queryLogs.reduce((sum, q) => sum + q.duration, 0)
-  console.log(`  Total query time: ${totalDuration}ms`)
-
-  // Group queries by type
-  const queryTypes = new Map<string, number>()
-  for (const log of queryLogs) {
-    const type = log.query.split(" ")[0]
-    queryTypes.set(type, (queryTypes.get(type) || 0) + 1)
-  }
-
-  console.log("  Query breakdown:")
-  for (const [type, count] of Array.from(queryTypes.entries())) {
-    console.log(`    ${type}: ${count}`)
-  }
-
-  // Show slowest queries
-  const slowest = [...queryLogs].sort((a, b) => b.duration - a.duration).slice(0, 3)
-  if (slowest.length > 0) {
-    console.log("  Slowest queries:")
-    for (const q of slowest) {
-      console.log(`    ${q.duration}ms: ${q.query.substring(0, 80)}...`)
-    }
-  }
-}
-
-function exportToJSON(result: ProfilingResult, outputPath: string) {
-  const filename = `profile-${new Date().toISOString().replace(/[:.]/g, "-")}.json`
-  const filepath = path.join(outputPath, filename)
-  fs.writeFileSync(filepath, JSON.stringify(result, null, 2))
-  console.log(`  JSON exported to: ${filepath}`)
-}
-
-function exportToCSV(result: ProfilingResult, outputPath: string) {
-  const filename = `profile-${new Date().toISOString().replace(/[:.]/g, "-")}.csv`
-  const filepath = path.join(outputPath, filename)
-
-  const headers = [
-    "timestamp",
-    "rule_count",
-    "scan_count",
-    "iterations",
-    "current_avg_ms",
-    "current_min_ms",
-    "current_max_ms",
-    "current_queries",
-    "optimized_avg_ms",
-    "optimized_min_ms",
-    "optimized_max_ms",
-    "optimized_queries",
-    "improvement_pct",
-    "recommendation",
-  ]
-
-  const values = [
-    result.timestamp,
-    result.config.ruleCount,
-    result.config.scanCount,
-    result.config.iterations,
-    result.current.avgDuration.toFixed(2),
-    result.current.minDuration,
-    result.current.maxDuration,
-    result.current.queryCount,
-    result.optimized.avgDuration.toFixed(2),
-    result.optimized.minDuration,
-    result.optimized.maxDuration,
-    result.optimized.queryCount,
-    result.improvement.toFixed(1),
-    `"${result.recommendation}"`,
-  ]
-
-  const csvContent = headers.join(",") + "\n" + values.join(",")
-  fs.writeFileSync(filepath, csvContent)
-  console.log(`  CSV exported to: ${filepath}`)
-}
-
-async function main() {
-  const config = parseArgs()
-
-  if (config.help) {
-    showHelp()
-    return
-  }
-
-  console.log("=== Maintenance Query Performance Profiling ===")
-  console.log(`Issue #39: Investigate potential N+1 query`)
-  console.log(`Issue #108: Enhanced profiling tooling\n`)
-  console.log(`Configuration:`)
-  console.log(`  Rules to seed: ${config.rules}`)
-  console.log(`  Scans per rule: ${config.scans}`)
-  console.log(`  Iterations: ${config.iterations}`)
-  console.log(`  Memory profiling: ${config.memory ? "enabled" : "disabled"}`)
-  console.log(`  Export format: ${config.export || "none"}`)
-
-  try {
-    if (config.seed) {
-      await seedTestData(config.rules, config.scans)
-    }
-
-    // Get data counts for profiling
-    const [ruleCount, scanCount] = await Promise.all([
-      prisma.maintenanceRule.count(),
-      prisma.maintenanceScan.count(),
-    ])
-
-    console.log(`\nData for profiling: ${ruleCount} rules, ${scanCount} scans`)
-
-    // Force garbage collection before memory profiling if available
-    if (config.memory && global.gc) {
-      global.gc()
-    }
-
-    // Profile current implementation
-    console.log("\n========================================")
-    console.log("CURRENT IMPLEMENTATION (with include)")
-    console.log("========================================")
-
-    const currentTimes: number[] = []
-    let currentMemory: MemorySnapshot | undefined
-    let currentQueryCount = 0
-
-    if (config.memory) {
-      currentMemory = getMemorySnapshot()
-      console.log(`  Memory before: ${formatBytes(currentMemory.heapUsed)} heap used`)
-    }
-
-    for (let i = 0; i < config.iterations; i++) {
-      const result = await runCurrentQuery()
-      currentTimes.push(result.duration)
-      console.log(`  Run ${i + 1}: ${result.duration}ms (${result.resultCount} rules)`)
-    }
-
-    currentQueryCount = getQueryCount()
-
-    if (config.memory) {
-      const afterMemory = getMemorySnapshot()
-      console.log(`  Memory after: ${formatBytes(afterMemory.heapUsed)} heap used`)
-      console.log(`  Memory delta: ${formatBytes(afterMemory.heapUsed - currentMemory!.heapUsed)}`)
-    }
-
-    printQueryAnalysis("Current Implementation")
-
-    const avgCurrent = currentTimes.reduce((a, b) => a + b, 0) / currentTimes.length
-    console.log(`\n  Average: ${avgCurrent.toFixed(2)}ms`)
-    console.log(`  Min: ${Math.min(...currentTimes)}ms`)
-    console.log(`  Max: ${Math.max(...currentTimes)}ms`)
-
-    // Profile optimized implementation
-    console.log("\n========================================")
-    console.log("OPTIMIZED IMPLEMENTATION (separate queries)")
-    console.log("========================================")
-
-    const optimizedTimes: number[] = []
-    let optimizedMemory: MemorySnapshot | undefined
-    let optimizedQueryCount = 0
-
-    if (config.memory) {
-      if (global.gc) global.gc()
-      optimizedMemory = getMemorySnapshot()
-      console.log(`  Memory before: ${formatBytes(optimizedMemory.heapUsed)} heap used`)
-    }
-
-    for (let i = 0; i < config.iterations; i++) {
-      const result = await runOptimizedQuery()
-      optimizedTimes.push(result.duration)
-      console.log(
-        `  Run ${i + 1}: ${result.duration}ms (${result.resultCount} rules, ${result.scanFetched} scans)`
-      )
-    }
-
-    optimizedQueryCount = getQueryCount()
-
-    if (config.memory) {
-      const afterMemory = getMemorySnapshot()
-      console.log(`  Memory after: ${formatBytes(afterMemory.heapUsed)} heap used`)
-      console.log(`  Memory delta: ${formatBytes(afterMemory.heapUsed - optimizedMemory!.heapUsed)}`)
-    }
-
-    printQueryAnalysis("Optimized Implementation")
-
-    const avgOptimized = optimizedTimes.reduce((a, b) => a + b, 0) / optimizedTimes.length
-    console.log(`\n  Average: ${avgOptimized.toFixed(2)}ms`)
-    console.log(`  Min: ${Math.min(...optimizedTimes)}ms`)
-    console.log(`  Max: ${Math.max(...optimizedTimes)}ms`)
-
-    // Summary
-    console.log("\n========================================")
-    console.log("PERFORMANCE SUMMARY")
-    console.log("========================================")
-    console.log(`  Current implementation: ${avgCurrent.toFixed(2)}ms avg`)
-    console.log(`  Optimized implementation: ${avgOptimized.toFixed(2)}ms avg`)
-
-    const improvement = ((avgCurrent - avgOptimized) / avgCurrent) * 100
-    if (improvement > 0) {
-      console.log(`  Improvement: ${improvement.toFixed(1)}% faster`)
-    } else {
-      console.log(`  Change: ${Math.abs(improvement).toFixed(1)}% slower (optimization not needed)`)
-    }
-
-    const threshold = 1000 // 1 second
-    console.log(`\n  Threshold: ${threshold}ms`)
-
-    let recommendation: string
-    if (avgCurrent > threshold) {
-      recommendation = `Current query exceeds threshold, optimization recommended`
-      console.log(`  RECOMMENDATION: ${recommendation}`)
-    } else {
-      recommendation = `Current query is within acceptable limits (< ${threshold}ms)`
-      console.log(`  RECOMMENDATION: ${recommendation}`)
-    }
-
-    // Export results if requested
-    if (config.export) {
-      console.log("\n========================================")
-      console.log("EXPORTING RESULTS")
-      console.log("========================================")
-
-      // Ensure output directory exists
-      if (!fs.existsSync(config.output)) {
-        fs.mkdirSync(config.output, { recursive: true })
-      }
-
-      const result: ProfilingResult = {
-        timestamp: new Date().toISOString(),
-        config: {
-          ruleCount,
-          scanCount,
-          iterations: config.iterations,
-          memoryEnabled: config.memory,
-        },
-        current: {
-          times: currentTimes,
-          avgDuration: avgCurrent,
-          minDuration: Math.min(...currentTimes),
-          maxDuration: Math.max(...currentTimes),
-          queryCount: currentQueryCount,
-          memory: currentMemory,
-        },
-        optimized: {
-          times: optimizedTimes,
-          avgDuration: avgOptimized,
-          minDuration: Math.min(...optimizedTimes),
-          maxDuration: Math.max(...optimizedTimes),
-          queryCount: optimizedQueryCount,
-          memory: optimizedMemory,
-        },
-        improvement,
-        recommendation,
-      }
-
-      if (config.export === "json" || config.export === "both") {
-        exportToJSON(result, config.output)
-      }
-
-      if (config.export === "csv" || config.export === "both") {
-        exportToCSV(result, config.output)
-      }
-    }
-
-    if (config.cleanup) {
-      await cleanupTestData()
-    }
-  } finally {
-    await prisma.$disconnect()
-  }
-}
-
-main().catch((e) => {
-  console.error(e)
-  process.exit(1)
-})
diff --git a/types/maintenance.ts b/types/maintenance.ts
deleted file mode 100644
index 7f1ce0ef..00000000
--- a/types/maintenance.ts
+++ /dev/null
@@ -1,248 +0,0 @@
-import type { MediaType, ReviewStatus, ScanStatus, RuleCriteria } from "@/lib/validations/maintenance"
-
-/**
- * Matched rule entry stored in maintenance candidates
- * Can be a simple rule name string or an object with rule details
- */
-export type MatchedRule = string | { ruleName: string }
-
-/**
- * Simplified maintenance candidate type used in candidate list views
- */
-export interface MaintenanceCandidate {
-  id: string
-  mediaType: string
-  plexRatingKey: string
-  title: string
-  year: number | null
-  poster: string | null
-  fileSize: bigint | null
-  playCount: number
-  lastWatchedAt: Date | null
-  addedAt: Date | null
-  reviewStatus: ReviewStatus
-  flaggedAt: Date
-  scan: {
-    id: string
-    rule: {
-      id: string
-      name: string
-      actionType: string
-    }
-  }
-}
-
-/**
- * Legacy rule criteria structure (flat format)
- * @deprecated Use RuleCriteria (hierarchical format) from @/lib/validations/maintenance instead
- */
-export interface LegacyRuleCriteriaFlat {
-  neverWatched?: boolean
-  lastWatchedBefore?: {
-    value: number
-    unit: "days" | "months" | "years"
-  }
-  maxPlayCount?: number
-  addedBefore?: {
-    value: number
-    unit: "days" | "months" | "years"
-  }
-  minFileSize?: {
-    value: number
-    unit: "MB" | "GB" | "TB"
-  }
-  maxQuality?: string
-  maxRating?: number
-  libraryIds?: string[]
-  tags?: string[]
-  operator: "AND" | "OR"
-}
-
-/**
- * @deprecated Use LegacyRuleCriteriaFlat for legacy flat format, or RuleCriteria from @/lib/validations/maintenance for hierarchical
- */
-export type { LegacyRuleCriteriaFlat as LegacyRuleCriteria }
-
-/**
- * Aggregated user feedback data for a media item
- */
-export interface UserFeedbackData {
-  finishedMarks: number
-  notInterestedMarks: number
-  keepMarks: number
-  rewatchMarks: number
-  poorQualityMarks: number
-  totalUniqueUsers: number
-}
-
-/**
- * Result of evaluating a rule against a media item
- */
-export interface EvaluationResult {
-  matches: boolean
-  score: number
-  reasons: string[]
-}
-
-/**
- * Media item interface for rule evaluation and display
- */
-export interface MediaItem {
-  plexRatingKey: string
-  title: string
-  year?: number
-  libraryId?: string
-  playCount: number
-  lastWatchedAt?: Date | null
-  addedAt?: Date | null
-  fileSize?: bigint | null
-  filePath?: string | null
-  quality?: string | null
-  rating?: number | null
-  tags?: string[]
-}
-
-/**
- * Result of a maintenance scan operation
- */
-export interface ScanResult {
-  scanId: string
-  status: "COMPLETED" | "FAILED"
-  itemsScanned: number
-  itemsFlagged: number
-  error?: string
-}
-
-/**
- * Result of a deletion operation
- */
-export interface DeletionResult {
-  success: number
-  failed: number
-  errors: string[]
-}
-
-/**
- * Statistics for the maintenance dashboard
- */
-export interface MaintenanceStats {
-  totalRules: number
-  activeRules: number
-  totalCandidates: number
-  candidatesByStatus: {
-    pending: number
-    approved: number
-    rejected: number
-    deleted: number
-  }
-  recentScans: Array<{
-    id: string
-    ruleId: string
-    ruleName: string
-    status: ScanStatus
-    itemsScanned: number
-    itemsFlagged: number
-    completedAt: Date | null
-  }>
-  totalDeletions: number
-  potentialSpaceSavings: bigint
-}
-
-/**
- * Maintenance candidate with scan and rule details
- */
-export interface CandidateWithDetails {
-  id: string
-  scanId: string
-  mediaType: MediaType
-  plexRatingKey: string
-  radarrId: number | null
-  sonarrId: number | null
-  tmdbId: number | null
-  tvdbId: number | null
-  title: string
-  year: number | null
-  poster: string | null
-  filePath: string | null
-  fileSize: bigint | null
-  playCount: number
-  lastWatchedAt: Date | null
-  addedAt: Date | null
-  matchedRules: MatchedRule[]
-  flaggedAt: Date
-  reviewStatus: ReviewStatus
-  reviewedAt: Date | null
-  reviewedBy: string | null
-  reviewNote: string | null
-  deletedAt: Date | null
-  deletionError: string | null
-  createdAt: Date
-  updatedAt: Date
-  scan: {
-    id: string
-    ruleId: string
-    rule: {
-      id: string
-      name: string
-      description: string | null
-      enabled: boolean
-      mediaType: MediaType
-      criteria: RuleCriteria
-      actionType: "FLAG_FOR_REVIEW" | "AUTO_DELETE"
-    }
-  }
-}
-
-/**
- * Filters for querying maintenance candidates
- */
-export interface CandidateFilters {
-  scanId?: string
-  mediaType?: MediaType
-  reviewStatus?: ReviewStatus
-  minFileSize?: number
-  maxFileSize?: number
-}
-
-/**
- * Paginated response for maintenance candidates
- */
-export interface PaginatedCandidatesResponse {
-  candidates: MaintenanceCandidate[]
-  pagination: {
-    page: number
-    pageSize: number
-    totalCount: number
-    totalPages: number
-    hasNextPage: boolean
-    hasPreviousPage: boolean
-  }
-}
-
-/**
- * Maintenance rule with scan statistics
- */
-export interface RuleWithStats {
-  id: string
-  name: string
-  description: string | null
-  enabled: boolean
-  mediaType: MediaType
-  criteria: RuleCriteria
-  actionType: "FLAG_FOR_REVIEW" | "AUTO_DELETE"
-  schedule: string | null
-  lastRunAt: Date | null
-  nextRunAt: Date | null
-  createdAt: Date
-  updatedAt: Date
-  scans: Array<{
-    id: string
-    status: ScanStatus
-    itemsScanned: number
-    itemsFlagged: number
-    completedAt: Date | null
-  }>
-  _count: {
-    scans: number
-  }
-}