feat: add super-admin role with admin impersonation support

Add a new super-admin role that can impersonate other admins. Regular
admins retain all existing permissions but cannot impersonate other
admins or promote users to super-admin.

Backend changes:
- Add isSuperAdmin field to users table with default false
- Add isSuperAdmin() check function to auth service
- Update JWT tokens to include isSuperAdmin claim
- Allow super-admins to impersonate other admins
- Add security rules for super-admin role changes

Frontend changes:
- Display "Super Admin" badge with gradient styling
- Add "Super Admin" option to role change modal
- Enable impersonate button for super-admins targeting admins
- Add "Super Admins Only" filter option

Security rules:
- Only super-admins can promote/demote super-admins
- Regular admins cannot promote users to super-admin
- Super-admins cannot demote themselves
- Cannot demote the last super-admin

Co-Authored-By: Claude <noreply@anthropic.com>

.dockerignore

@@ -1,61 +0,0 @@
-# Dependencies
-node_modules
-# Note: bun.lock is needed by Dockerfile for --frozen-lockfile
-
-# Environment
-.env
-.env.*
-!.env.example
-
-# Database - will be in volume mount
-**/*.db
-**/*.db-shm
-**/*.db-wal
-
-# Build outputs - built in container
-src/frontend/build/
-src/frontend/.svelte-kit/
-src/frontend/dist/
-build/
-dist/
-
-# IDE
-.vscode
-.idea
-*.swp
-*.swo
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Git
-.git/
-.gitignore
-
-# Documentation (keep docs in image but don't need in build context)
-# README.md
-docs/
-*.md
-
-# Logs
-logs/
-*.log
-backend.log
-
-# Tests
-*.test.js
-*.test.ts
-coverage/
-
-# Docker files
-Dockerfile
-docker-compose.yml
-.dockerignore
-
-# CI/CD
-.github/
-.gitlab-ci.yml
-
-# Data directory (for volume mount)
-data/

.env.docker.example

@@ -1,26 +0,0 @@
-# Docker Environment Configuration
-# Copy this file to .env and update with your values
-
-# ============================================
-# Application Settings
-# ============================================
-NODE_ENV=production
-PORT=3001
-LOG_LEVEL=debug
-
-# ============================================
-# Security (IMPORTANT: Change in production!)
-# ============================================
-# Generate a secure JWT secret with: openssl rand -base64 32
-JWT_SECRET=change-this-in-production-use-openssl-rand-base64-32
-
-# ============================================
-# CORS Configuration
-# ============================================
-# Your application's public URL (e.g., https://awards.example.com)
-VITE_APP_URL=
-
-# Comma-separated list of allowed origins for CORS
-# Only needed if not using same domain deployment
-# Example: https://awards.example.com,https://www.awards.example.com
-ALLOWED_ORIGINS=

.env.example

@@ -1,22 +1,47 @@
 # Application Configuration
 # Copy this file to .env and update with your values
 
-# Hostname for the application (e.g., https://awards.dj7nt.de)
+# ===================================================================
+# Environment
+# ===================================================================
+# Development: development
+# Production: production
+NODE_ENV=development
+
+# Log Level (debug, info, warn, error)
+# Development: debug
+# Production: info
+LOG_LEVEL=debug
+
+# Server Port (default: 3001)
+PORT=3001
+
+# ===================================================================
+# URLs
+# ===================================================================
+# Frontend URL (e.g., https://awards.dj7nt.de)
 # Leave empty for development (uses localhost)
 VITE_APP_URL=
 
-# API Base URL (in production, can be same domain or separate)
-# Leave empty to use relative paths (recommended for same-domain deployment)
+# API Base URL (leave empty for same-domain deployment)
+# Only set if API is on different domain
 VITE_API_BASE_URL=
 
 # Allowed CORS origins for backend (comma-separated)
-# Only needed for production if not using same domain
+# Add all domains that should access the API
 # Example: https://awards.dj7nt.de,https://www.awards.dj7nt.de
 ALLOWED_ORIGINS=
 
-# JWT Secret (for production, use a strong random string)
-# Generate with: openssl rand -base64 32
+# ===================================================================
+# Security
+# ===================================================================
+# JWT Secret (REQUIRED for production)
+# Development: uses default if not set
+# Production: Generate with: openssl rand -base64 32
 JWT_SECRET=change-this-in-production
 
-# Node Environment
-NODE_ENV=development
+# ===================================================================
+# Database (Optional)
+# ===================================================================
+# Leave empty to use default SQLite database
+# DATABASE_URL=file:/path/to/custom.db

.env.production.template

@@ -1,30 +0,0 @@
-# Production Configuration Template
-# Copy this file to .env.production and update with your production values
-
-# Application Environment
-NODE_ENV=production
-
-# Log Level (debug, info, warn, error)
-# Recommended: info for production
-LOG_LEVEL=info
-
-# Server Port (default: 3001)
-PORT=3001
-
-# Frontend URL (e.g., https://awards.dj7nt.de)
-VITE_APP_URL=https://awards.dj7nt.de
-
-# API Base URL (leave empty for same-domain deployment)
-VITE_API_BASE_URL=
-
-# Allowed CORS origins (comma-separated)
-# Add all domains that should access the API
-ALLOWED_ORIGINS=https://awards.dj7nt.de,https://www.awards.dj7nt.de
-
-# JWT Secret (REQUIRED - generate a strong secret!)
-# Generate with: openssl rand -base64 32
-JWT_SECRET=REPLACE_WITH_SECURE_RANDOM_STRING
-
-# Database (if using external database)
-# Leave empty to use default SQLite database
-# DATABASE_URL=file:/path/to/production.db

CLAUDE.md

@@ -77,58 +77,6 @@ test("hello world", () => {
 });
 ```
 
-## Docker Deployment
-
-The application supports Docker deployment with single-port architecture and host-mounted database persistence.
-
-**Quick Start**:
-```bash
-# Create environment file
-cp .env.docker.example .env
-
-# Generate JWT secret
-openssl rand -base64 32  # Add to .env as JWT_SECRET
-
-# Start application
-docker-compose up -d --build
-
-# Access at http://localhost:3001
-```
-
-**Architecture**:
-- **Single Port**: Port 3001 serves both API (`/api/*`) and frontend (all other routes)
-- **Database Persistence**: SQLite database stored at `./data/award.db` on host
-- **Auto-initialization**: Database created from template on first startup
-- **Health Checks**: Built-in health monitoring at `/api/health`
-
-**Key Docker Files**:
-- `Dockerfile`: Multi-stage build using official Bun runtime
-- `docker-compose.yml`: Stack orchestration with volume mounts
-- `docker-entrypoint.sh`: Database initialization logic
-- `.env.docker.example`: Environment variable template
-- `DOCKER.md`: Complete deployment documentation
-
-**Environment Variables**:
-- `NODE_ENV`: Environment mode (default: production)
-- `PORT`: Application port (default: 3001)
-- `LOG_LEVEL`: Logging level (debug/info/warn/error)
-- `JWT_SECRET`: JWT signing secret (required, change in production!)
-- `VITE_APP_URL`: Your application's public URL
-- `ALLOWED_ORIGINS`: CORS allowed origins (comma-separated)
-
-**Database Management**:
-- Database location: `./data/award.db` (host-mounted volume)
-- Backups: `cp data/award.db data/award.db.backup.$(date +%Y%m%d)`
-- Reset: `docker-compose down -v && docker-compose up -d`
-
-**Important Notes**:
-- Database persists across container restarts/recreations
-- Frontend dependencies are reinstalled in container to ensure correct platform binaries
-- Uses custom init script (`src/backend/scripts/init-db.js`) with `bun:sqlite`
-- Architecture-agnostic (works on x86, ARM64, etc.)
-
-For detailed documentation, see `DOCKER.md`.
-
 ## Frontend
 
 Use HTML imports with `Bun.serve()`. Don't use `vite`. HTML imports fully support React, CSS, Tailwind.
@@ -222,6 +170,8 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
 1. **`entity`**: Count unique entities (DXCC countries, states, grid squares)
    - `entityType`: What to count ("dxcc", "state", "grid", "callsign")
    - `target`: Number required for award
+   - `allowed_bands`: Optional array of bands that count (e.g., `["160m", "80m", "40m", "30m", "20m", "17m", "15m", "12m", "10m"]` for HF only)
+   - `satellite_only`: Optional boolean to only count satellite QSOs (QSOs with `satName` field)
    - `filters`: Optional filters (band, mode, etc.)
    - `displayField`: Optional field to display
 
@@ -231,7 +181,6 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
    - `filters`: Optional filters (band, mode, etc.) for award variants
    - Counts unique (DOK, band, mode) combinations
    - Only DCL-confirmed QSOs count
-   - Example variants: DLD 80m, DLD CW, DLD 80m CW
 
 3. **`points`**: Point-based awards
    - `stations`: Array of {callsign, points}
@@ -244,6 +193,16 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
 
 5. **`counter`**: Count QSOs or callsigns
 
+### Current Awards
+
+- **DXCC**: HF bands only (160m-10m), 100 entities required
+- **DXCC SAT**: Satellite QSOs only, 100 entities required
+- **WAS**: Worked All States award
+- **VUCC SAT**: VUCC Satellite award
+- **SAT-RS44**: Special satellite award
+- **73 on 73**: Special stations award
+- **DLD**: Deutschland Diplom, 100 unique DOKs required
+
 ### Key Files
 
 **Backend Award Service**: `src/backend/services/awards.service.js`
@@ -253,11 +212,13 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
 - `calculatePointsAwardProgress(userId, award, options)`: Point-based calculation
 - `getAwardEntityBreakdown(userId, awardId)`: Detailed entity breakdown
 - `getAwardProgressDetails(userId, awardId)`: Progress with details
+- Implements `allowed_bands` and `satellite_only` filtering
 
 **Database Schema**: `src/backend/db/schema/index.js`
-- QSO fields include: `darcDok`, `dclQslRstatus`, `dclQslRdate`
+- QSO fields include: `darcDok`, `dclQslRstatus`, `dclQslRdate`, `satName`
 - DOK fields support DLD award tracking
 - DCL confirmation fields separate from LoTW
+- `satName` field for satellite QSO tracking
 
 **Award Definitions**: `award-definitions/*.json`
 - Add new awards by creating JSON definition files
@@ -268,7 +229,6 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
   - Handles case-insensitive `<EOR>` delimiters (supports `<EOR>`, `<eor>`, `<Eor>`)
   - Uses `matchAll()` for reliable field parsing
   - Skips header records automatically
-- `parseDCLResponse(response)`: Parse DCL's JSON response format `{ "adif": "..." }`
 - `normalizeBand(band)`: Standardize band names (80m, 40m, etc.)
 - `normalizeMode(mode)`: Standardize mode names (CW, FT8, SSB, etc.)
 - Used by both LoTW and DCL services for consistency
@@ -289,6 +249,7 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
 - `POST /api/dcl/sync`: Queue DCL sync job
 - `GET /api/jobs/:jobId`: Get job status
 - `GET /api/jobs/active`: Get active job for current user
+- `DELETE /api/qsos/all`: Delete all QSOs for authenticated user
 - `GET /*`: Serves static files from `src/frontend/build/` with SPA fallback
 
 **SPA Routing**: The backend serves the SvelteKit frontend build from `src/frontend/build/`.
@@ -314,9 +275,9 @@ The award system is JSON-driven and located in `award-definitions/` directory. E
 - Fully implemented and functional
 - **Note**: DCL API is a custom prototype by DARC; contact DARC for API specification details
 
-### DLD Award Implementation (COMPLETED)
+### DLD Award Implementation
 
-The DLD (Deutschland Diplom) award was recently implemented:
+The DLD (Deutschland Diplom) award:
 
 **Definition**: `award-definitions/dld.json`
 ```json
@@ -336,7 +297,7 @@ The DLD (Deutschland Diplom) award was recently implemented:
 ```
 
 **Implementation Details**:
-- Function: `calculateDOKAwardProgress()` in `src/backend/services/awards.service.js` (lines 173-268)
+- Function: `calculateDOKAwardProgress()` in `src/backend/services/awards.service.js`
 - Counts unique (DOK, band, mode) combinations
 - Only DCL-confirmed QSOs count (`dclQslRstatus === 'Y'`)
 - Each unique DOK on each unique band/mode counts separately
@@ -349,8 +310,6 @@ The DLD (Deutschland Diplom) award was recently implemented:
 - `dclQslRstatus`: DCL confirmation status ('Y' = confirmed)
 - `dclQslRdate`: DCL confirmation date
 
-**Documentation**: See `docs/DOCUMENTATION.md` for complete documentation including DLD award example.
-
 **Frontend**: `src/frontend/src/routes/qsos/+page.svelte`
 - Separate sync buttons for LoTW (blue) and DCL (orange)
 - Independent progress tracking for each sync type
@@ -374,79 +333,59 @@ To add a new award:
 3. If new rule type needed, add calculation function
 4. Add type handling in `calculateAwardProgress()` switch statement
 5. Add type handling in `getAwardEntityBreakdown()` if needed
-6. Update documentation in `docs/DOCUMENTATION.md`
+6. Update documentation
 7. Test with sample QSO data
 
-### Creating DLD Award Variants
+### Award Rule Options
 
-The DOK award type supports filters to create award variants. Examples:
-
-**DLD on 80m** (`dld-80m.json`):
-```json
-{
-  "id": "dld-80m",
-  "name": "DLD 80m",
-  "description": "Confirm 100 unique DOKs on 80m",
-  "caption": "Contact 100 different DOKs on the 80m band.",
-  "category": "darc",
-  "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "displayField": "darcDok",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "band", "operator": "eq", "value": "80m" }
-      ]
-    }
-  }
-}
-```
-
-**DLD in CW mode** (`dld-cw.json`):
+**allowed_bands**: Restrict which bands count toward an award
 ```json
 {
   "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "mode", "operator": "eq", "value": "CW" }
-      ]
-    }
+    "type": "entity",
+    "allowed_bands": ["160m", "80m", "60m", "40m", "30m", "20m", "17m", "15m", "12m", "10m"]
   }
 }
 ```
+- If absent or empty, all bands are allowed (default behavior)
+- Used for DXCC to restrict to HF bands only
 
-**DLD on 80m using CW** (combined filters, `dld-80m-cw.json`):
+**satellite_only**: Only count satellite QSOs
 ```json
 {
   "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "band", "operator": "eq", "value": "80m" },
-        { "field": "mode", "operator": "eq", "value": "CW" }
-      ]
-    }
+    "type": "entity",
+    "satellite_only": true
   }
 }
 ```
+- If `true`, only QSOs with `satName` field set are counted
+- Used for DXCC SAT award
 
-**Available filter operators**:
+**modeGroups**: Define mode groups for filtering in award detail view
+```json
+{
+  "modeGroups": {
+    "Digi-Modes": ["FT8", "FT4", "MFSK", "PSK31", "RTTY", "JT65", "JT9"],
+    "Classic Digi-Modes": ["PSK31", "RTTY", "JT65", "JT9"],
+    "Mixed-Mode w/o WSJT-Modes": ["PSK31", "RTTY", "AM", "SSB", "FM", "CW"],
+    "Phone-Modes": ["AM", "SSB", "FM"]
+  }
+}
+```
+- Optional field at award definition level (not in `rules`)
+- Key is the display name shown in the mode filter dropdown
+- Value is an array of mode strings to include in the group
+- Used to create convenient mode filters that combine multiple modes
+- Awards without `modeGroups` work as before (backward compatible)
+
+**filters**: Additional filtering options
 - `eq`: equals
 - `ne`: not equals
 - `in`: in array
 - `nin`: not in array
 - `contains`: contains substring
-
-**Available filter fields**: Any QSO field (band, mode, callsign, grid, state, satName, etc.)
+- Can filter any QSO field (band, mode, callsign, grid, state, etc.)
 
 ### Confirmation Systems
 
@@ -466,13 +405,8 @@ The DOK award type supports filters to create award variants. Examples:
   - Required for DLD award
   - German amateur radio specific
   - Request format: POST JSON `{ key, limit, qsl_since, qso_since, cnf_only }`
-    - `cnf_only: null` - Fetch all QSOs (confirmed + unconfirmed)
-    - `cnf_only: true` - Fetch only confirmed QSOs
-    - `qso_since` - QSOs since this date (YYYYMMDD)
-    - `qsl_since` - QSL confirmations since this date (YYYYMMDD)
   - Response format: JSON with ADIF string in `adif` field
   - Syncs ALL QSOs (both confirmed and unconfirmed)
-  - Unconfirmed QSOs stored but don't count toward awards
   - Updates QSOs only if confirmation data has changed
 
 ### ADIF Format
@@ -491,138 +425,13 @@ Both LoTW and DCL return data in ADIF (Amateur Data Interchange Format):
 - `MY_DARC_DOK`: User's own DOK
 - `STATION_CALLSIGN`: User's callsign
 
-### Recent Commits
+### QSO Management
 
-- `aeeb75c`: feat: add QSO count display to filter section
-  - Shows count of QSOs matching current filters next to "Filters" heading
-  - Displays "Showing X filtered QSOs" when filters are active
-  - Displays "Showing X total QSOs" when no filters applied
-  - Dynamically updates when filters change
-- `bee02d1`: fix: count QSOs confirmed by either LoTW or DCL in stats
-  - QSO stats were only counting LoTW-confirmed QSOs (`lotwQslRstatus === 'Y'`)
-  - QSOs confirmed only by DCL were excluded from "confirmed" count
-  - Fixed by changing filter to: `q.lotwQslRstatus === 'Y' || q.dclQslRstatus === 'Y'`
-  - Now correctly shows all QSOs confirmed by at least one system
-- `233888c`: fix: make ADIF parser case-insensitive for EOR delimiter
-  - **Critical bug**: LoTW uses lowercase `<eor>` tags, parser was splitting on uppercase `<EOR>`
-  - Caused 242K+ QSOs to be parsed as 1 giant record with fields overwriting each other
-  - Changed to case-insensitive regex: `new RegExp('<eor>', 'gi')`
-  - Replaced `regex.exec()` while loop with `matchAll()` for-of iteration
-  - Now correctly imports all QSOs from large LoTW reports
-- `645f786`: fix: add missing timeOn field to LoTW duplicate detection
-  - LoTW sync was missing `timeOn` in duplicate detection query
-  - Multiple QSOs with same callsign/date/band/mode but different times were treated as duplicates
-  - Now matches DCL sync logic: `userId, callsign, qsoDate, timeOn, band, mode`
-- `7f77c3a`: feat: add filter support for DOK awards
-  - DOK award type now supports filtering by band, mode, and other QSO fields
-  - Allows creating award variants like DLD 80m, DLD CW, DLD 80m CW
-  - Uses existing filter system with eq, ne, in, nin, contains operators
-  - Example awards created: dld-80m, dld-40m, dld-cw, dld-80m-cw
-- `9e73704`: docs: update CLAUDE.md with DLD award variants documentation
-- `7201446`: fix: return proper HTML for SPA routes instead of Bun error page
-  - When accessing client-side routes (like /qsos) via curl or non-JS clients,
-    the server attempted to open them as static files, causing Bun to throw
-    an unhandled ENOENT error that showed an ugly error page
-  - Now checks if a path has a file extension before attempting to serve it
-  - Paths without extensions are immediately served index.html for SPA routing
-  - Also improves the 503 error page with user-friendly HTML when frontend build is missing
-- `223461f`: fix: enable debug logging and improve DCL sync observability
-- `27d2ef1`: fix: preserve DOK data when DCL doesn't send values
-  - DCL sync only updates DOK/grid fields when DCL provides non-empty values
-  - Prevents accidentally clearing DOK data from manual entry or other sources
-  - Preserves existing DOK when DCL syncs QSO without DOK information
-- `e09ab94`: feat: skip QSOs with unchanged confirmation data
-  - LoTW/DCL sync only updates QSOs if confirmation data has changed
-  - Tracks added, updated, and skipped QSO counts
-  - LoTW: Checks if lotwQslRstatus or lotwQslRdate changed
-  - DCL: Checks if dclQslRstatus, dclQslRdate, darcDok, myDarcDok, or grid changed
-- `3592dbb`: feat: add import log showing synced QSOs
-  - Backend returns addedQSOs and updatedQSOs arrays in sync result
-  - Frontend displays import log with callsign, date, band, mode for each QSO
-  - Separate sections for "New QSOs" and "Updated QSOs"
-  - Sync summary shows total, added, updated, skipped counts
-- `8a1a580`: feat: implement DCL ADIF parser and service integration
-  - Add shared ADIF parser utility (src/backend/utils/adif-parser.js)
-  - Implement DCL service with API integration
-  - Refactor LoTW service to use shared parser
-  - Tested with example DCL payload (6 QSOs parsed successfully)
-- `c982dcd`: feat: implement DLD (Deutschland Diplom) award
-- `322ccaf`: docs: add DLD (Deutschland Diplom) award documentation
-
-### Sync Behavior
-
-**Import Log**: After each sync, displays a table showing:
-- New QSOs: Callsign, Date, Band, Mode
-- Updated QSOs: Callsign, Date, Band, Mode (only if data changed)
-- Skipped QSOs: Counted but not shown (data unchanged)
-
-**Duplicate Handling**:
-- QSOs matched by: userId, callsign, qsoDate, timeOn, band, mode
-- If confirmation data unchanged: Skipped (not updated)
-- If confirmation data changed: Updated with new values
-- Prevents unnecessary database writes and shows accurate import counts
-
-**DOK Update Behavior**:
-- If QSO imported via LoTW (no DOK) and later DCL confirms with DOK: DOK is added ✓
-- If QSO already has DOK and DCL sends different DOK: DOK is updated ✓
-- If QSO has DOK and DCL syncs without DOK (empty): Existing DOK is preserved ✓
-- LoTW never sends DOK data; only DCL provides DOK fields
-
-**Important**: DCL sync only updates DOK/grid fields when DCL provides non-empty values. This prevents accidentally clearing DOK data that was manually entered or imported from other sources.
-
-### DCL Sync Strategy
-
-**Current Behavior**: DCL syncs ALL QSOs (confirmed + unconfirmed)
-
-The application syncs both confirmed and unconfirmed QSOs from DCL:
-- **Confirmed QSOs**: `dclQslRstatus = 'Y'` - Count toward awards
-- **Unconfirmed QSOs**: `dclQslRstatus = 'N'` - Stored but don't count toward awards
-
-**Purpose of syncing unconfirmed QSOs**:
-- Users can see who they've worked (via "Not Confirmed" filter)
-- Track QSOs awaiting confirmation
-- QSOs can get confirmed later and will be updated on next sync
-
-**Award Calculation**: Always uses confirmed QSOs only (e.g., `dclQslRstatus === 'Y'` for DLD award)
-
-### DCL Incremental Sync Strategy
-
-**Challenge**: Need to fetch both new QSOs AND confirmation updates to old QSOs
-
-**Example Scenario**:
-1. Full sync on 2026-01-20 → Last QSO date: 2026-01-20
-2. User works 3 new QSOs on 2026-01-25 (unconfirmed)
-3. Old QSO from 2026-01-10 gets confirmed on 2026-01-26
-4. Next sync needs both: new QSOs (2026-01-25) AND confirmation update (2026-01-10)
-
-**Solution**: Use both `qso_since` and `qsl_since` parameters with OR logic
-
-```javascript
-// Proposed sync logic (requires OR logic from DCL API)
-const lastQSODate = await getLastDCLQSODate(userId);  // Track QSO dates
-const lastQSLDate = await getLastDCLQSLDate(userId);  // Track QSL dates
-
-const requestBody = {
-  key: dclApiKey,
-  limit: 50000,
-  qso_since: lastQSODate,  // Get new QSOs since last contact
-  qsl_since: lastQSLDate,  // Get QSL confirmations since last sync
-  cnf_only: null,          // Fetch all QSOs
-};
-```
-
-**Required API Behavior (OR Logic)**:
-- Return QSOs where `(qso_date >= qso_since) OR (qsl_date >= qsl_since)`
-- This ensures we get both new QSOs and confirmation updates
-
-**Current DCL API Status**:
-- Unknown if current API uses AND or OR logic for combined filters
-- **Action Needed**: Request OR logic implementation from DARC
-- Test current behavior to confirm API response pattern
-
-**Why OR Logic is Needed**:
-- With AND logic: Old QSOs getting confirmed are missed (qso_date too old)
-- With OR logic: All updates captured efficiently in one API call
+**Delete All QSOs**: `DELETE /api/qsos/all`
+- Deletes all QSOs for authenticated user
+- Also deletes related `qso_changes` records to satisfy foreign key constraints
+- Invalidates stats and user caches after deletion
+- Returns count of deleted QSOs
 
 ### QSO Page Filters
 
@@ -630,34 +439,50 @@ The QSO page (`src/frontend/src/routes/qsos/+page.svelte`) includes advanced fil
 
 **Available Filters**:
 - **Search Box**: Full-text search across callsign, entity (DXCC country), and grid square fields
-  - Press Enter to apply search
-  - Case-insensitive partial matching
 - **Band Filter**: Dropdown to filter by amateur band (160m, 80m, 60m, 40m, 30m, 20m, 17m, 15m, 12m, 10m, 6m, 2m, 70cm)
 - **Mode Filter**: Dropdown to filter by mode (CW, SSB, AM, FM, RTTY, PSK31, FT8, FT4, JT65, JT9)
 - **Confirmation Type Filter**: Filter by confirmation status
-  - "All QSOs": Shows all QSOs (no filter)
-  - "LoTW Only": Shows QSOs confirmed by LoTW but NOT DCL
-  - "DCL Only": Shows QSOs confirmed by DCL but NOT LoTW
-  - "Both Confirmed": Shows QSOs confirmed by BOTH LoTW AND DCL
-  - "Not Confirmed": Shows QSOs confirmed by NEITHER LoTW nor DCL
-- **Clear Button**: Resets all filters and reloads all QSOs
+  - "All QSOs", "LoTW Only", "DCL Only", "Both Confirmed", "Not Confirmed"
+- **Clear Button**: Resets all filters
 
 **Backend Implementation** (`src/backend/services/lotw.service.js`):
 - `getUserQSOs(userId, filters, options)`: Main filtering function
 - Supports pagination with `page` and `limit` options
 - Filter logic uses Drizzle ORM query builders for safe SQL generation
-- Debug logging when `LOG_LEVEL=debug` shows applied filters
 
 **Frontend API** (`src/frontend/src/lib/api.js`):
 - `qsosAPI.getAll(filters)`: Fetch QSOs with optional filters
 - Filters passed as query parameters: `?band=20m&mode=CW&confirmationType=lotw&search=DL`
 
-**QSO Count Display**:
-- Shows count of QSOs matching current filters next to "Filters" heading
-- **With filters active**: "Showing **X** filtered QSOs"
-- **No filters**: "Showing **X** total QSOs"
-- Dynamically updates when filters are applied or cleared
-- Uses `pagination.totalCount` from backend API response
+### Award Detail View
+
+**Overview**: The award detail page (`src/frontend/src/routes/awards/[id]/+page.svelte`) displays award progress in a pivot table format.
+
+**Key Features**:
+- **Summary Cards**: Show total, confirmed, worked, needed counts for unique entities
+- **Mode Filter**: Filter by specific mode, mode group, or view "Mixed Mode" (aggregates all modes by band)
+  - Awards can define `modeGroups` to create convenient multi-mode filters
+  - Example groups: "Digi-Modes", "Classic Digi-Modes", "Phone-Modes", "Mixed-Mode w/o WSJT-Modes"
+  - Visual separator (`─────`) appears between mode groups and individual modes
+- **Table Columns**: Show bands (or band/mode combinations) as columns
+- **QSO Counts**: Each cell shows count of confirmed QSOs for that (entity, band, mode) slot
+- **Drill-Down**: Click a count to open modal showing all QSOs for that slot
+- **QSO Detail**: Click any QSO to view full QSO details
+- **Satellite Grouping**: Satellite QSOs grouped under "SAT" column instead of frequency band
+
+**Column Sorting**: Bands sorted by wavelength (longest to shortest):
+160m, 80m, 60m, 40m, 30m, 20m, 17m, 15m, 12m, 10m, 6m, 2m, 70cm, SAT
+
+**Column Sums**: Show unique entity count per column (not QSO counts)
+
+**Backend Changes** (`src/backend/services/awards.service.js`):
+- `getAllAwards()`: Returns award definitions including `modeGroups`
+- `getAwardById(awardId)`: Returns single award definition with `modeGroups`
+- `calculateDOKAwardProgress()`: Groups by (DOK, band, mode) slots, collects QSOs in `qsos` array
+- `calculatePointsAwardProgress()`: Handles all count modes with `qsos` array
+- `getAwardEntityBreakdown()`: Groups by (entity, band, mode) slots
+- Includes `satName` in QSO data for satellite grouping
+- Implements `allowed_bands` and `satellite_only` filtering
 
 ### DXCC Entity Priority Logic
 
@@ -665,58 +490,18 @@ When syncing QSOs from multiple confirmation sources, the system follows a prior
 
 **Priority Order**: LoTW > DCL
 
-**Implementation** (`src/backend/services/dcl.service.js`):
-```javascript
-// DXCC priority: LoTW > DCL
-// Only update entity fields from DCL if:
-// 1. QSO is NOT LoTW confirmed, AND
-// 2. DCL actually sent entity data, AND
-// 3. Current entity is missing
-const hasLoTWConfirmation = existingQSO.lotwQslRstatus === 'Y';
-const hasDCLData = dbQSO.entity || dbQSO.entityId;
-const missingEntity = !existingQSO.entity || existingQSO.entity === '';
-
-if (!hasLoTWConfirmation && hasDCLData && missingEntity) {
-  // Fill in entity data from DCL (only if DCL provides it)
-  updateData.entity = dbQSO.entity;
-  updateData.entityId = dbQSO.entityId;
-  // ... other entity fields
-}
-```
-
 **Rules**:
 1. **LoTW-confirmed QSOs**: Always use LoTW's DXCC data (most reliable)
 2. **DCL-only QSOs**: Use DCL's DXCC data IF available in ADIF payload
 3. **Empty entity fields**: If DCL doesn't send DXCC data, entity remains empty
 4. **Never overwrite**: Once LoTW confirms with entity data, DCL sync won't change it
 
-**Important Note**: DCL API currently doesn't send DXCC/entity fields in their ADIF export. This is a limitation of the DCL API, not the application. If DCL adds these fields in the future, the system will automatically use them for DCL-only QSOs.
+**Important Note**: DCL API currently doesn't send DXCC/entity fields in their ADIF export.
 
-### Recent Development Work (January 2025)
-
-**QSO Page Enhancements**:
-- Added confirmation type filter with exclusive logic (LoTW Only, DCL Only, Both Confirmed, Not Confirmed)
-- Added search box for filtering by callsign, entity, or grid square
-- Renamed "All Confirmation" to "All QSOs" for clarity
-- Fixed filter logic to properly handle exclusive confirmation types
-
-**Bug Fixes**:
-- Fixed confirmation filter showing wrong QSOs (e.g., "LoTW Only" was also showing DCL QSOs)
-- Implemented proper SQL conditions for exclusive filters using separate condition pushes
-- Added debug logging to track filter application
-
-**DXCC Entity Handling**:
-- Clarified that DCL API doesn't send DXCC fields (current limitation)
-- Implemented priority logic: LoTW entity data takes precedence over DCL
-- System ready to auto-use DCL DXCC data if they add it in future API updates
-
-### Critical LoTW Sync Behavior (LEARNED THE HARD WAY)
+### Critical LoTW Sync Behavior
 
 **⚠️ IMPORTANT: LoTW sync MUST only import confirmed QSOs**
 
-After attempting to implement "QSO Delta" sync (all QSOs, confirmed + unconfirmed), we discovered:
-
-**The Problem:**
 LoTW ADIF export with `qso_qsl=no` (all QSOs mode) only includes:
 - `CALL` (callsign)
 - `QSL_RCVD` (confirmation status: Y/N)
@@ -724,9 +509,7 @@ LoTW ADIF export with `qso_qsl=no` (all QSOs mode) only includes:
 **Missing Fields for Unconfirmed QSOs:**
 - `DXCC` (entity ID) ← **CRITICAL for awards!**
 - `COUNTRY` (entity name)
-- `CONTINENT`
-- `CQ_ZONE`
-- `ITU_ZONE`
+- `CONTINENT`, `CQ_ZONE`, `ITU_ZONE`
 
 **Result:** Unconfirmed QSOs have `entityId: null` and `entity: ""`, breaking award calculations.
 
@@ -742,67 +525,31 @@ const params = new URLSearchParams({
 });
 ```
 
-**Why This Matters:**
-- Awards require `entityId` to count entities
-- Without `entityId`, QSOs can't be counted toward DXCC, WAS, etc.
-- Users can still see "worked" stations in QSO list, but awards only count confirmed
-- DCL sync can import all QSOs because it provides entity data via callsign lookup
+### Recent Development Work (January 2026)
 
-**Attempted Solution (REVERTED):**
-- Tried implementing callsign prefix lookup to populate missing `entityId`
-- Created `src/backend/utils/callsign-lookup.js` with basic prefix mappings
-- Complexity: 1000+ DXCC entities, many special event callsigns, portable designators
-- Decision: Too complex, reverted (commit 310b154)
+**Award System Enhancements**:
+- Added `allowed_bands` filter to restrict which bands count toward awards
+- Added `satellite_only` flag for satellite-only awards
+- DXCC restricted to HF bands (160m-10m) only
+- Added DXCC SAT award for satellite-only QSOs
+- Removed redundant award variants (DXCC CW, DLD variants)
+- Added `modeGroups` for configurable multi-mode filters in award detail view
+  - Per-award configuration of mode groups (Digi-Modes, Phone-Modes, etc.)
+  - Visual separator in mode filter dropdown between groups and individual modes
+  - DXCC and DLD awards include: Digi-Modes, Classic Digi-Modes, Mixed-Mode w/o WSJT-Modes, Phone-Modes
 
-**Takeaway:** LoTW confirmed QSOs have reliable DXCC data. Don't try to workaround this fundamental limitation.
+**Award Detail View Improvements**:
+- Summary shows unique entity progress instead of QSO counts
+- Column sums count unique entities per column
+- Satellite QSOs grouped under "SAT" column
+- Bands sorted by wavelength instead of alphabetically
+- Mode removed from table headers (visible in filter dropdown)
+- Mode groups allow filtering multiple modes together (e.g., all digital modes)
 
-### QSO Confirmation Filters
+**Backend API Additions**:
+- Added `GET /api/awards/:awardId` endpoint for fetching single award definition
+- `getAllAwards()` now includes `modeGroups` field
 
-Added "Confirmed by at least 1 service" filter to QSO view (commit 688b0fc):
-
-**Filter Options:**
-- "All QSOs" - No filter
-- "Confirmed by at least 1 service" (NEW) - LoTW OR DCL confirmed
-- "LoTW Only" - Confirmed by LoTW but NOT DCL
-- "DCL Only" - Confirmed by DCL but NOT LoTW
-- "Both Confirmed" - Confirmed by BOTH LoTW AND DCL
-- "Not Confirmed" - Confirmed by NEITHER
-
-**SQL Logic:**
-```sql
--- "Confirmed by at least 1 service"
-WHERE lotwQslRstatus = 'Y' OR dclQslRstatus = 'Y'
-
--- "LoTW Only"
-WHERE lotwQslRstatus = 'Y' AND (dclQslRstatus IS NULL OR dclQslRstatus != 'Y')
-
--- "DCL Only"
-WHERE dclQslRstatus = 'Y' AND (lotwQslRstatus IS NULL OR lotwQslRstatus != 'Y')
-
--- "Both Confirmed"
-WHERE lotwQslRstatus = 'Y' AND dclQslRstatus = 'Y'
-
--- "Not Confirmed"
-WHERE (lotwQslRstatus IS NULL OR lotwQslRstatus != 'Y')
-AND (dclQslRstatus IS NULL OR dclQslRstatus != 'Y')
-```
-
-### Recent Development Work (January 2025)
-
-**Sync Type Support (ATTEMPTED & REVERTED):**
-- Commit 5b78935: Added LoTW sync type support (QSL/QSO delta/full)
-- Commit 310b154: Reverted - LoTW doesn't provide entity data for unconfirmed QSOs
-- **Lesson:** Keep it simple - only sync confirmed QSOs from LoTW
-
-**Dashboard Enhancements:**
-- Added sync job history display with real-time polling (every 2 seconds)
-- Shows job progress, status, and import logs
-- Cancel button for stale/failed jobs with rollback capability
-- Tracks all QSO changes in `qso_changes` table for rollback
-
-**Rollback System:**
-- `cancelJob(jobId, userId)` - Cancels and rolls back sync jobs
-- Tracks added QSOs (deletes them on rollback)
-- Tracks updated QSOs (restores previous state)
-- Only allows canceling failed jobs or stale running jobs (>1 hour)
-- Server-side validation prevents unauthorized cancellations
+**QSO Management**:
+- Fixed DELETE /api/qsos/all to handle foreign key constraints
+- Added cache invalidation after QSO deletion

DOCKER.md

@@ -1,219 +0,0 @@
-# Docker Deployment Guide
-
-This guide covers deploying Quickawards using Docker.
-
-## Quick Start
-
-1. **Create environment file:**
-   ```bash
-   cp .env.docker.example .env
-   ```
-
-2. **Generate secure JWT secret:**
-   ```bash
-   openssl rand -base64 32
-   ```
-   Copy the output and set it as `JWT_SECRET` in `.env`.
-
-3. **Update `.env` with your settings:**
-   - `JWT_SECRET`: Strong random string (required)
-   - `VITE_APP_URL`: Your domain (e.g., `https://awards.example.com`)
-   - `ALLOWED_ORIGINS`: Your domain(s) for CORS
-
-4. **Start the application:**
-   ```bash
-   docker-compose up -d
-   ```
-
-5. **Access the application:**
-   - URL: http://localhost:3001
-   - Health check: http://localhost:3001/api/health
-
-## Architecture
-
-### Single Port Design
-
-The Docker stack exposes a single port (3001) which serves both:
-- **Backend API** (`/api/*`)
-- **Frontend SPA** (all other routes)
-
-### Database Persistence
-
-- **Location**: `./data/award.db` (host-mounted volume)
-- **Initialization**: Automatic on first startup
-- **Persistence**: Database survives container restarts/recreations
-
-### Startup Behavior
-
-1. **First startup**: Database is created from template
-2. **Subsequent startups**: Existing database is used
-3. **Container recreation**: Database persists in volume
-
-## Commands
-
-### Start the application
-```bash
-docker-compose up -d
-```
-
-### View logs
-```bash
-docker-compose logs -f
-```
-
-### Stop the application
-```bash
-docker-compose down
-```
-
-### Rebuild after code changes
-```bash
-docker-compose up -d --build
-```
-
-### Stop and remove everything (including database volume)
-```bash
-docker-compose down -v
-```
-
-## Environment Variables
-
-| Variable | Required | Default | Description |
-|----------|----------|---------|-------------|
-| `NODE_ENV` | No | `production` | Environment mode |
-| `PORT` | No | `3001` | Application port |
-| `LOG_LEVEL` | No | `info` | Logging level (debug/info/warn/error) |
-| `JWT_SECRET` | **Yes** | - | JWT signing secret (change this!) |
-| `VITE_APP_URL` | No | - | Your application's public URL |
-| `ALLOWED_ORIGINS` | No | - | CORS allowed origins (comma-separated) |
-
-## Database Management
-
-### Backup the database
-```bash
-cp data/award.db data/award.db.backup.$(date +%Y%m%d)
-```
-
-### Restore from backup
-```bash
-docker-compose down
-cp data/award.db.backup.YYYYMMDD data/award.db
-docker-compose up -d
-```
-
-### Reset the database
-```bash
-docker-compose down -v
-docker-compose up -d
-```
-
-## Troubleshooting
-
-### Container won't start
-```bash
-# Check logs
-docker-compose logs -f
-
-# Check container status
-docker-compose ps
-```
-
-### Database errors
-```bash
-# Check database file exists
-ls -la data/
-
-# Check database permissions
-stat data/award.db
-```
-
-### Port already in use
-Change the port mapping in `docker-compose.yml`:
-```yaml
-ports:
-  - "8080:3001"  # Maps host port 8080 to container port 3001
-```
-
-### Health check failing
-```bash
-# Check if container is responding
-curl http://localhost:3001/api/health
-
-# Check container logs
-docker-compose logs quickawards
-```
-
-## Production Deployment
-
-### Using a Reverse Proxy (nginx)
-
-Example nginx configuration:
-
-```nginx
-server {
-    listen 80;
-    server_name awards.example.com;
-
-    location / {
-        proxy_pass http://localhost:3001;
-        proxy_http_version 1.1;
-        proxy_set_header Upgrade $http_upgrade;
-        proxy_set_header Connection 'upgrade';
-        proxy_set_header Host $host;
-        proxy_cache_bypass $http_upgrade;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-}
-```
-
-### SSL/TLS with Let's Encrypt
-
-Use certbot with nginx:
-
-```bash
-sudo certbot --nginx -d awards.example.com
-```
-
-### Security Checklist
-
-- [ ] Set strong `JWT_SECRET`
-- [ ] Set `NODE_ENV=production`
-- [ ] Set `LOG_LEVEL=info` (or `warn` in production)
-- [ ] Configure `ALLOWED_ORIGINS` to your domain only
-- [ ] Use HTTPS/TLS in production
-- [ ] Regular database backups
-- [ ] Monitor logs for suspicious activity
-- [ ] Keep Docker image updated
-
-## File Structure After Deployment
-
-```
-project/
-├── data/
-│   └── award.db          # Persisted database (volume mount)
-├── docker-compose.yml
-├── Dockerfile
-├── .dockerignore
-├── .env                  # Your environment variables
-└── ... (source code)
-```
-
-## Building Without docker-compose
-
-If you prefer to use `docker` directly:
-
-```bash
-# Build the image
-docker build -t quickawards .
-
-# Run the container
-docker run -d \
-  --name quickawards \
-  -p 3001:3001 \
-  -v $(pwd)/data:/data \
-  -e JWT_SECRET=your-secret-here \
-  -e NODE_ENV=production \
-  quickawards
-```

Dockerfile

@@ -1,72 +0,0 @@
-# Multi-stage Dockerfile for Quickawards
-# Uses official Bun runtime image
-
-# ============================================
-# Stage 1: Dependencies & Database Init
-# ============================================
-FROM oven/bun:1 AS builder
-
-WORKDIR /app
-
-# Install ALL dependencies (including devDependencies for drizzle-kit)
-COPY package.json bun.lock ./
-RUN bun install --frozen-lockfile
-
-# Copy source code (node_modules excluded by .dockerignore)
-COPY . .
-
-# Reinstall frontend dependencies to get correct platform binaries
-RUN cd src/frontend && bun install
-
-# Initialize database using custom script
-# This creates a fresh database with the correct schema using bun:sqlite
-RUN bun src/backend/scripts/init-db.js
-
-# Build frontend
-RUN bun run build
-
-# ============================================
-# Stage 2: Production Image
-# ============================================
-FROM oven/bun:1 AS production
-
-WORKDIR /app
-
-# Install production dependencies only
-COPY package.json bun.lock ./
-RUN bun install --frozen-lockfile --production
-
-# Copy backend source and schema files
-COPY src/backend ./src/backend
-COPY award-definitions ./award-definitions
-COPY drizzle.config.ts ./
-
-# Copy frontend build from builder stage
-COPY --from=builder /app/src/frontend/build ./src/frontend/build
-
-# Copy initialized database from builder (will be used as template)
-COPY --from=builder /app/src/backend/award.db /app/award.db.template
-
-# Copy drizzle migrations (if they exist)
-COPY --from=builder /app/drizzle ./drizzle
-
-# Create directory for database volume mount
-RUN mkdir -p /data
-
-# Copy entrypoint script
-COPY docker-entrypoint.sh /usr/local/bin/
-RUN chmod +x /usr/local/bin/docker-entrypoint.sh
-
-# Set environment variables
-ENV NODE_ENV=production \
-    PORT=3001 \
-    LOG_LEVEL=info
-
-# Expose the application port
-EXPOSE 3001
-
-# Use entrypoint script to handle database initialization
-ENTRYPOINT ["docker-entrypoint.sh"]
-
-# Start the backend server
-CMD ["bun", "run", "src/backend/index.js"]

README.md

@@ -116,7 +116,7 @@ award/
 │       └── package.json
 ├── award-definitions/            # Award rule definitions (JSON)
 ├── award.db                     # SQLite database (auto-created)
-├── .env.production.template     # Production configuration template
+├── .env.example                 # Environment configuration template
 ├── bunfig.toml                  # Bun configuration
 ├── drizzle.config.js            # Drizzle ORM configuration
 ├── package.json
@@ -149,20 +149,32 @@ cp .env.example .env
 
 Edit `.env` with your configuration:
 ```env
-# Application URL (for production deployment)
-VITE_APP_URL=https://awards.dj7nt.de
+# Environment (development/production)
+NODE_ENV=development
+
+# Log Level (debug/info/warn/error)
+LOG_LEVEL=debug
+
+# Server Port (default: 3001)
+PORT=3001
+
+# Frontend URL (e.g., https://awards.dj7nt.de)
+# Leave empty for development (uses localhost)
+VITE_APP_URL=
 
 # API Base URL (leave empty for same-domain deployment)
 VITE_API_BASE_URL=
 
-# JWT Secret (generate with: openssl rand -base64 32)
-JWT_SECRET=your-generated-secret-here
+# Allowed CORS origins (comma-separated)
+# Add all domains that should access the API
+ALLOWED_ORIGINS=
 
-# Environment
-NODE_ENV=production
+# JWT Secret (generate with: openssl rand -base64 32)
+JWT_SECRET=change-this-in-production
 ```
 
-**For development**: You can leave `.env` empty or use defaults.
+**For development**: Use defaults above.
+**For production**: Set `NODE_ENV=production`, `LOG_LEVEL=info`, and generate a strong `JWT_SECRET`.
 
 4. Initialize the database with performance indexes:
 ```bash
@@ -246,6 +258,7 @@ The application will be available at:
 
 ### Awards
 - `GET /api/awards` - Get all available awards
+- `GET /api/awards/:awardId` - Get single award definition (includes mode groups)
 - `GET /api/awards/batch/progress` - Get progress for all awards (optimized, single request)
 - `GET /api/awards/:awardId/progress` - Get award progress for a specific award
 - `GET /api/awards/:awardId/entities` - Get entity breakdown
@@ -414,20 +427,26 @@ bun run build
 Create `.env` in the project root:
 
 ```bash
-# Application URL
-VITE_APP_URL=https://awards.dj7nt.de
-
-# API Base URL (empty for same-domain)
-VITE_API_BASE_URL=
-
-# JWT Secret (generate with: openssl rand -base64 32)
-JWT_SECRET=your-generated-secret-here
-
 # Environment
 NODE_ENV=production
 
-# Database path (absolute path recommended)
-DATABASE_PATH=/path/to/award/award.db
+# Log Level (debug/info/warn/error)
+LOG_LEVEL=info
+
+# Server Port (default: 3001)
+PORT=3001
+
+# Frontend URL
+VITE_APP_URL=https://awards.dj7nt.de
+
+# API Base URL (leave empty for same-domain deployment)
+VITE_API_BASE_URL=
+
+# Allowed CORS origins (comma-separated)
+ALLOWED_ORIGINS=https://awards.dj7nt.de,https://www.awards.dj7nt.de
+
+# JWT Secret (generate with: openssl rand -base64 32)
+JWT_SECRET=your-generated-secret-here
 ```
 
 **Security**: Ensure `.env` has restricted permissions:
@@ -782,6 +801,26 @@ bun run db:studio
 
 ## Features in Detail
 
+### Mode Groups (Award Detail View)
+
+The award detail view includes configurable mode groups for filtering multiple modes together:
+
+**Available Mode Groups** (varies by award):
+- **Mixed Mode**: All modes aggregated by band (default view)
+- **Digi-Modes**: FT8, FT4, MFSK, PSK31, RTTY, JT65, JT9
+- **Classic Digi-Modes**: PSK31, RTTY, JT65, JT9 (excludes FT8, FT4, MFSK)
+- **Mixed-Mode w/o WSJT-Modes**: PSK31, RTTY, AM, SSB, FM, CW (excludes WSJT modes)
+- **Phone-Modes**: AM, SSB, FM
+- **Individual Modes**: CW, SSB, FT8, etc.
+
+The mode filter dropdown displays:
+1. Mixed Mode (default)
+2. Mode groups (configurable per award)
+3. Visual separator (`─────`)
+4. Individual modes
+
+Awards can define custom `modeGroups` in their JSON definition to add additional mode groupings.
+
 ### Background Job Queue
 
 The application uses an in-memory job queue system for async operations:

award-definitions/dld-40m.json

@@ -1,19 +0,0 @@
-{
-  "id": "dld-40m",
-  "name": "DLD 40m",
-  "description": "Confirm 100 unique DOKs on 40m",
-  "caption": "Contact and confirm stations with 100 unique DOKs (DARC Ortsverband Kennung) on the 40m band. Only DCL-confirmed QSOs with valid DOK information on 40m count toward this award.",
-  "category": "darc",
-  "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "displayField": "darcDok",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "band", "operator": "eq", "value": "40m" }
-      ]
-    }
-  }
-}

award-definitions/dld-80m-cw.json

@@ -1,20 +0,0 @@
-{
-  "id": "dld-80m-cw",
-  "name": "DLD 80m CW",
-  "description": "Confirm 100 unique DOKs on 80m using CW",
-  "caption": "Contact and confirm stations with 100 unique DOKs (DARC Ortsverband Kennung) on the 80m band using CW mode. Only DCL-confirmed QSOs with valid DOK information on 80m CW count toward this award.",
-  "category": "darc",
-  "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "displayField": "darcDok",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "band", "operator": "eq", "value": "80m" },
-        { "field": "mode", "operator": "eq", "value": "CW" }
-      ]
-    }
-  }
-}

award-definitions/dld-80m.json

@@ -1,19 +0,0 @@
-{
-  "id": "dld-80m",
-  "name": "DLD 80m",
-  "description": "Confirm 100 unique DOKs on 80m",
-  "caption": "Contact and confirm stations with 100 unique DOKs (DARC Ortsverband Kennung) on the 80m band. Only DCL-confirmed QSOs with valid DOK information on 80m count toward this award.",
-  "category": "darc",
-  "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "displayField": "darcDok",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "band", "operator": "eq", "value": "80m" }
-      ]
-    }
-  }
-}

award-definitions/dld-cw.json

@@ -1,19 +0,0 @@
-{
-  "id": "dld-cw",
-  "name": "DLD CW",
-  "description": "Confirm 100 unique DOKs using CW mode",
-  "caption": "Contact and confirm stations with 100 unique DOKs (DARC Ortsverband Kennung) using CW (Morse code). Each unique DOK on CW counts separately. Only DCL-confirmed QSOs with valid DOK information count toward this award.",
-  "category": "darc",
-  "rules": {
-    "type": "dok",
-    "target": 100,
-    "confirmationType": "dcl",
-    "displayField": "darcDok",
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        { "field": "mode", "operator": "eq", "value": "CW" }
-      ]
-    }
-  }
-}

award-definitions/dld.json

@@ -8,6 +8,33 @@
     "type": "dok",
     "target": 100,
     "confirmationType": "dcl",
-    "displayField": "darcDok"
+    "displayField": "darcDok",
+    "stations": []
+  },
+  "modeGroups": {
+    "Digi-Modes": [
+      "FT4",
+      "FT8",
+      "MFSK",
+      "PSK31",
+      "RTTY"
+    ],
+    "Classic Digi-Modes": [
+      "PSK31",
+      "RTTY"
+    ],
+    "Mixed-Mode w/o WSJT-Modes": [
+      "AM",
+      "CW",
+      "FM",
+      "PSK31",
+      "RTTY",
+      "SSB"
+    ],
+    "Phone-Modes": [
+      "AM",
+      "FM",
+      "SSB"
+    ]
   }
 }

award-definitions/dxcc-cw.json

@@ -1,27 +0,0 @@
-{
-  "id": "dxcc-cw",
-  "name": "DXCC CW",
-  "description": "Confirm 100 DXCC entities using CW mode",
-  "caption": "Contact and confirm 100 different DXCC entities using CW mode only. Only QSOs made with CW mode count toward this award. QSOs are confirmed when LoTW QSL is received.",
-  "category": "dxcc",
-  "rules": {
-    "target": 100,
-    "type": "filtered",
-    "baseRule": {
-      "type": "entity",
-      "entityType": "dxcc",
-      "target": 100,
-      "displayField": "entity"
-    },
-    "filters": {
-      "operator": "AND",
-      "filters": [
-        {
-          "field": "mode",
-          "operator": "eq",
-          "value": "CW"
-        }
-      ]
-    }
-  }
-}

award-definitions/dxcc-sat.json

@@ -0,0 +1,14 @@
+{
+  "id": "dxcc-sat",
+  "name": "DXCC SAT",
+  "description": "Confirm 100 DXCC entities via satellite",
+  "caption": "Contact and confirm 100 different DXCC entities using satellite communications. Only satellite QSOs count toward this award. QSOs are confirmed when LoTW QSL is received.",
+  "category": "dxcc",
+  "rules": {
+    "type": "entity",
+    "entityType": "dxcc",
+    "target": 100,
+    "displayField": "entity",
+    "satellite_only": true
+  }
+}

award-definitions/dxcc.json

@@ -1,13 +1,74 @@
 {
-  "id": "dxcc-mixed",
-  "name": "DXCC Mixed Mode",
-  "description": "Confirm 100 DXCC entities on any band/mode",
-  "caption": "Contact and confirm 100 different DXCC entities. Any band and mode combination counts. QSOs are confirmed when LoTW QSL is received.",
+  "id": "dxcc",
+  "name": "DXCC",
+  "description": "Confirm 100 DXCC entities on HF bands",
+  "caption": "Contact and confirm 100 different DXCC entities on HF bands (160m-10m). Only HF band QSOs count toward this award. QSOs are confirmed when LoTW QSL is received.",
   "category": "dxcc",
   "rules": {
     "type": "entity",
     "entityType": "dxcc",
     "target": 100,
-    "displayField": "entity"
-  }
+    "displayField": "entity",
+    "allowed_bands": [
+      "160m",
+      "80m",
+      "60m",
+      "40m",
+      "30m",
+      "20m",
+      "17m",
+      "15m",
+      "12m",
+      "10m"
+    ],
+    "stations": []
+  },
+  "modeGroups": {
+    "Digi-Modes": [
+      "FT4",
+      "FT8",
+      "JT65",
+      "JT9",
+      "MFSK",
+      "PSK31",
+      "RTTY"
+    ],
+    "Classic Digi-Modes": [
+      "JT65",
+      "JT9",
+      "PSK31",
+      "RTTY"
+    ],
+    "Mixed-Mode w/o WSJT-Modes": [
+      "AM",
+      "CW",
+      "FM",
+      "PSK31",
+      "RTTY",
+      "SSB"
+    ],
+    "Phone-Modes": [
+      "AM",
+      "FM",
+      "SSB"
+    ]
+  },
+  "achievements": [
+    {
+      "name": "Silver",
+      "threshold": 100
+    },
+    {
+      "name": "Gold",
+      "threshold": 200
+    },
+    {
+      "name": "Platinum",
+      "threshold": 300
+    },
+    {
+      "name": "All",
+      "threshold": 341
+    }
+  ]
 }

award-definitions/qo100grids.json

@@ -0,0 +1,25 @@
+{
+  "id": "qo100grids",
+  "name": "QO100 Grids",
+  "description": "Work as much Grids as possible on QO100 Satellite",
+  "caption": "Work as much Grids as possible on QO100 Satellite",
+  "category": "satellite",
+  "rules": {
+    "type": "entity",
+    "satellite_only": true,
+    "filters": {
+      "operator": "AND",
+      "filters": [
+        {
+          "field": "satName",
+          "operator": "eq",
+          "value": "QO-100"
+        }
+      ]
+    },
+    "entityType": "grid",
+    "target": 100,
+    "displayField": "grid"
+  },
+  "modeGroups": {}
+}

award-definitions/sat-rs44.json

@@ -1,9 +1,9 @@
 {
   "id": "sat-rs44",
-  "name": "RS-44 Satellite",
+  "name": "44 on RS-44",
   "description": "Work 44 QSOs on satellite RS-44",
   "caption": "Make 44 unique QSOs via the RS-44 satellite. Each QSO with a different callsign counts toward the total.",
-  "category": "custom",
+  "category": "satellite",
   "rules": {
     "type": "counter",
     "target": 44,
@@ -19,5 +19,6 @@
         }
       ]
     }
-  }
+  },
+  "modeGroups": {}
 }

award-definitions/was.json

@@ -4,6 +4,9 @@
   "description": "Confirm all 50 US states",
   "caption": "Contact and confirm all 50 US states. Only QSOs with stations located in United States states count toward this award. QSOs are confirmed when LoTW QSL is received.",
   "category": "was",
+  "achievements": [
+    { "name": "WAS Award", "threshold": 50 }
+  ],
   "rules": {
     "type": "entity",
     "entityType": "state",
@@ -14,8 +17,8 @@
       "filters": [
         {
           "field": "entityId",
-          "operator": "eq",
-          "value": 291
+          "operator": "in",
+          "value": [291, 6, 110]
         }
       ]
     }

docker-compose.yml

@@ -1,31 +0,0 @@
-services:
-  quickawards:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    container_name: quickawards
-    restart: unless-stopped
-    ports:
-      - "3001:3001"
-    environment:
-      # Application settings
-      NODE_ENV: production
-      PORT: 3001
-      LOG_LEVEL: info
-
-      # Security - IMPORTANT: Change these in production!
-      JWT_SECRET: ${JWT_SECRET:-change-this-in-production}
-
-      # CORS - Set to your domain in production
-      VITE_APP_URL: ${VITE_APP_URL:-}
-      ALLOWED_ORIGINS: ${ALLOWED_ORIGINS:-}
-    volumes:
-      # Host-mounted database directory
-      # Database will be created at ./data/award.db on first startup
-      - ./data:/data
-    healthcheck:
-      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:3001/api/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s

docker-entrypoint.sh

@@ -1,62 +0,0 @@
-#!/bin/sh
-set -e
-
-# Docker container entrypoint script
-# Handles database initialization on first startup
-
-echo "=========================================="
-echo "Quickawards - Docker Entrypoint"
-echo "=========================================="
-
-# Database location in volume mount
-DB_PATH="/data/award.db"
-TEMPLATE_DB="/app/award.db.template"
-APP_DB_PATH="/app/src/backend/award.db"
-
-# Check if database exists in the volume
-if [ ! -f "$DB_PATH" ]; then
-  echo ""
-  echo "📦 Database not found in volume mount."
-  echo "   Initializing from template database..."
-  echo ""
-
-  # Copy the template database (created during build with drizzle-kit push)
-  cp "$TEMPLATE_DB" "$DB_PATH"
-
-  # Ensure proper permissions
-  chmod 644 "$DB_PATH"
-
-  echo "✅ Database initialized at: $DB_PATH"
-  echo "   This database will persist in the Docker volume."
-else
-  echo ""
-  echo "✅ Existing database found at: $DB_PATH"
-  echo "   Using existing database from volume mount."
-fi
-
-# Create symlink from app's expected db location to volume mount
-# The app expects the database at src/backend/award.db
-# We create a symlink so it points to the volume-mounted database
-if [ -L "$APP_DB_PATH" ]; then
-  # Symlink already exists, remove it to refresh
-  rm "$APP_DB_PATH"
-elif [ -e "$APP_DB_PATH" ]; then
-  # File or directory exists (shouldn't happen in production, but handle it)
-  echo "⚠ Warning: Found existing database at $APP_DB_PATH, removing..."
-  rm -f "$APP_DB_PATH"
-fi
-
-# Create symlink to the volume-mounted database
-ln -s "$DB_PATH" "$APP_DB_PATH"
-echo "✅ Created symlink: $APP_DB_PATH -> $DB_PATH"
-
-echo ""
-echo "=========================================="
-echo "Starting Quickawards application..."
-echo "Port: ${PORT:-3001}"
-echo "Environment: ${NODE_ENV:-production}"
-echo "=========================================="
-echo ""
-
-# Execute the main command (passed as CMD in Dockerfile)
-exec "$@"

drizzle/0004_overrated_havok.sql

@@ -0,0 +1,17 @@
+CREATE TABLE `auto_sync_settings` (
+	`user_id` integer PRIMARY KEY NOT NULL,
+	`lotw_enabled` integer DEFAULT false NOT NULL,
+	`lotw_interval_hours` integer DEFAULT 24 NOT NULL,
+	`lotw_last_sync_at` integer,
+	`lotw_next_sync_at` integer,
+	`dcl_enabled` integer DEFAULT false NOT NULL,
+	`dcl_interval_hours` integer DEFAULT 24 NOT NULL,
+	`dcl_last_sync_at` integer,
+	`dcl_next_sync_at` integer,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL,
+	FOREIGN KEY (`user_id`) REFERENCES `users`(`id`) ON UPDATE no action ON DELETE no action
+);
+--> statement-breakpoint
+ALTER TABLE `users` ADD `is_super_admin` integer DEFAULT false NOT NULL;--> statement-breakpoint
+ALTER TABLE `users` ADD `last_seen` integer;

drizzle/meta/0004_snapshot.json

@@ -0,0 +1,868 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "0d928d09-61c6-4311-beb8-0f597172e510",
+  "prevId": "071c98fb-6721-4da7-98cb-c16cb6aaf0c1",
+  "tables": {
+    "admin_actions": {
+      "name": "admin_actions",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "admin_id": {
+          "name": "admin_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "action_type": {
+          "name": "action_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "target_user_id": {
+          "name": "target_user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "details": {
+          "name": "details",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "admin_actions_admin_id_users_id_fk": {
+          "name": "admin_actions_admin_id_users_id_fk",
+          "tableFrom": "admin_actions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "admin_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "admin_actions_target_user_id_users_id_fk": {
+          "name": "admin_actions_target_user_id_users_id_fk",
+          "tableFrom": "admin_actions",
+          "tableTo": "users",
+          "columnsFrom": [
+            "target_user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "auto_sync_settings": {
+      "name": "auto_sync_settings",
+      "columns": {
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "lotw_enabled": {
+          "name": "lotw_enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "lotw_interval_hours": {
+          "name": "lotw_interval_hours",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 24
+        },
+        "lotw_last_sync_at": {
+          "name": "lotw_last_sync_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lotw_next_sync_at": {
+          "name": "lotw_next_sync_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "dcl_enabled": {
+          "name": "dcl_enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "dcl_interval_hours": {
+          "name": "dcl_interval_hours",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 24
+        },
+        "dcl_last_sync_at": {
+          "name": "dcl_last_sync_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "dcl_next_sync_at": {
+          "name": "dcl_next_sync_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "auto_sync_settings_user_id_users_id_fk": {
+          "name": "auto_sync_settings_user_id_users_id_fk",
+          "tableFrom": "auto_sync_settings",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "award_progress": {
+      "name": "award_progress",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "award_id": {
+          "name": "award_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "worked_count": {
+          "name": "worked_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "confirmed_count": {
+          "name": "confirmed_count",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "total_required": {
+          "name": "total_required",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "worked_entities": {
+          "name": "worked_entities",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "confirmed_entities": {
+          "name": "confirmed_entities",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_calculated_at": {
+          "name": "last_calculated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_qso_sync_at": {
+          "name": "last_qso_sync_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "award_progress_user_id_users_id_fk": {
+          "name": "award_progress_user_id_users_id_fk",
+          "tableFrom": "award_progress",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "award_progress_award_id_awards_id_fk": {
+          "name": "award_progress_award_id_awards_id_fk",
+          "tableFrom": "award_progress",
+          "tableTo": "awards",
+          "columnsFrom": [
+            "award_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "awards": {
+      "name": "awards",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "description": {
+          "name": "description",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "definition": {
+          "name": "definition",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "is_active": {
+          "name": "is_active",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": true
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "qso_changes": {
+      "name": "qso_changes",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "job_id": {
+          "name": "job_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "qso_id": {
+          "name": "qso_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "change_type": {
+          "name": "change_type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "before_data": {
+          "name": "before_data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "after_data": {
+          "name": "after_data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "qso_changes_job_id_sync_jobs_id_fk": {
+          "name": "qso_changes_job_id_sync_jobs_id_fk",
+          "tableFrom": "qso_changes",
+          "tableTo": "sync_jobs",
+          "columnsFrom": [
+            "job_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        },
+        "qso_changes_qso_id_qsos_id_fk": {
+          "name": "qso_changes_qso_id_qsos_id_fk",
+          "tableFrom": "qso_changes",
+          "tableTo": "qsos",
+          "columnsFrom": [
+            "qso_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "qsos": {
+      "name": "qsos",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "callsign": {
+          "name": "callsign",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "qso_date": {
+          "name": "qso_date",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "time_on": {
+          "name": "time_on",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "band": {
+          "name": "band",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "mode": {
+          "name": "mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "freq": {
+          "name": "freq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "freq_rx": {
+          "name": "freq_rx",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "entity": {
+          "name": "entity",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "entity_id": {
+          "name": "entity_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "grid": {
+          "name": "grid",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "grid_source": {
+          "name": "grid_source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "continent": {
+          "name": "continent",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cq_zone": {
+          "name": "cq_zone",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "itu_zone": {
+          "name": "itu_zone",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "state": {
+          "name": "state",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "county": {
+          "name": "county",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sat_name": {
+          "name": "sat_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sat_mode": {
+          "name": "sat_mode",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "my_darc_dok": {
+          "name": "my_darc_dok",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "darc_dok": {
+          "name": "darc_dok",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lotw_qsl_rdate": {
+          "name": "lotw_qsl_rdate",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lotw_qsl_rstatus": {
+          "name": "lotw_qsl_rstatus",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "dcl_qsl_rdate": {
+          "name": "dcl_qsl_rdate",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "dcl_qsl_rstatus": {
+          "name": "dcl_qsl_rstatus",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lotw_synced_at": {
+          "name": "lotw_synced_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "qsos_user_id_users_id_fk": {
+          "name": "qsos_user_id_users_id_fk",
+          "tableFrom": "qsos",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "sync_jobs": {
+      "name": "sync_jobs",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "user_id": {
+          "name": "user_id",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "completed_at": {
+          "name": "completed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "result": {
+          "name": "result",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "error": {
+          "name": "error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {
+        "sync_jobs_user_id_users_id_fk": {
+          "name": "sync_jobs_user_id_users_id_fk",
+          "tableFrom": "sync_jobs",
+          "tableTo": "users",
+          "columnsFrom": [
+            "user_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "users": {
+      "name": "users",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "email": {
+          "name": "email",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "password_hash": {
+          "name": "password_hash",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "callsign": {
+          "name": "callsign",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "lotw_username": {
+          "name": "lotw_username",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "lotw_password": {
+          "name": "lotw_password",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "dcl_api_key": {
+          "name": "dcl_api_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "is_admin": {
+          "name": "is_admin",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "is_super_admin": {
+          "name": "is_super_admin",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": false
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "users_email_unique": {
+          "name": "users_email_unique",
+          "columns": [
+            "email"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

drizzle/meta/_journal.json

@@ -29,6 +29,13 @@
       "when": 1768989260562,
       "tag": "0003_tired_warpath",
       "breakpoints": true
+    },
+    {
+      "idx": 4,
+      "version": "6",
+      "when": 1769171258085,
+      "tag": "0004_overrated_havok",
+      "breakpoints": true
     }
   ]
 }

src/backend/db/schema/index.js

@@ -10,6 +10,8 @@ import { sqliteTable, text, integer } from 'drizzle-orm/sqlite-core';
  * @property {string|null} lotwPassword
  * @property {string|null} dclApiKey
  * @property {boolean} isAdmin
+ * @property {boolean} isSuperAdmin
+ * @property {Date|null} lastSeen
  * @property {Date} createdAt
  * @property {Date} updatedAt
  */
@@ -23,6 +25,8 @@ export const users = sqliteTable('users', {
   lotwPassword: text('lotw_password'), // Encrypted
   dclApiKey: text('dcl_api_key'), // DCL API key for future use
   isAdmin: integer('is_admin', { mode: 'boolean' }).notNull().default(false),
+  isSuperAdmin: integer('is_super_admin', { mode: 'boolean' }).notNull().default(false),
+  lastSeen: integer('last_seen', { mode: 'timestamp' }),
   createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
   updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
 });
@@ -223,5 +227,39 @@ export const adminActions = sqliteTable('admin_actions', {
   createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
 });
 
+/**
+ * @typedef {Object} AutoSyncSettings
+ * @property {number} userId
+ * @property {boolean} lotwEnabled
+ * @property {number} lotwIntervalHours
+ * @property {Date|null} lotwLastSyncAt
+ * @property {Date|null} lotwNextSyncAt
+ * @property {boolean} dclEnabled
+ * @property {number} dclIntervalHours
+ * @property {Date|null} dclLastSyncAt
+ * @property {Date|null} dclNextSyncAt
+ * @property {Date} createdAt
+ * @property {Date} updatedAt
+ */
+
+export const autoSyncSettings = sqliteTable('auto_sync_settings', {
+  userId: integer('user_id').primaryKey().references(() => users.id),
+
+  // LoTW auto-sync settings
+  lotwEnabled: integer('lotw_enabled', { mode: 'boolean' }).notNull().default(false),
+  lotwIntervalHours: integer('lotw_interval_hours').notNull().default(24),
+  lotwLastSyncAt: integer('lotw_last_sync_at', { mode: 'timestamp' }),
+  lotwNextSyncAt: integer('lotw_next_sync_at', { mode: 'timestamp' }),
+
+  // DCL auto-sync settings
+  dclEnabled: integer('dcl_enabled', { mode: 'boolean' }).notNull().default(false),
+  dclIntervalHours: integer('dcl_interval_hours').notNull().default(24),
+  dclLastSyncAt: integer('dcl_last_sync_at', { mode: 'timestamp' }),
+  dclNextSyncAt: integer('dcl_next_sync_at', { mode: 'timestamp' }),
+
+  createdAt: integer('created_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp' }).notNull().$defaultFn(() => new Date()),
+});
+
 // Export all schemas
-export const schema = { users, qsos, awards, awardProgress, syncJobs, qsoChanges, adminActions };
+export const schema = { users, qsos, awards, awardProgress, syncJobs, qsoChanges, adminActions, autoSyncSettings };

src/backend/index.js

@@ -12,10 +12,12 @@ import {
   getUserById,
   updateLoTWCredentials,
   updateDCLCredentials,
+  updateLastSeen,
 } from './services/auth.service.js';
 import {
   getSystemStats,
   getUserStats,
+  getAdminActions,
   impersonateUser,
   verifyImpersonation,
   stopImpersonation,
@@ -39,9 +41,28 @@ import {
 } from './services/job-queue.service.js';
 import {
   getAllAwards,
+  getAwardById,
   getAwardProgressDetails,
   getAwardEntityBreakdown,
 } from './services/awards.service.js';
+import {
+  getAllAwardDefinitions,
+  getAwardDefinition,
+  createAwardDefinition,
+  updateAwardDefinition,
+  deleteAwardDefinition,
+  testAwardCalculation,
+} from './services/awards-admin.service.js';
+import {
+  getAutoSyncSettings,
+  updateAutoSyncSettings,
+} from './services/auto-sync.service.js';
+import {
+  startScheduler,
+  stopScheduler,
+  getSchedulerStatus,
+  triggerSchedulerTick,
+} from './services/scheduler.service.js';
 
 /**
  * Main backend application
@@ -187,6 +208,14 @@ const app = new Elysia()
         return { user: null };
       }
 
+      // Update last_seen timestamp asynchronously (don't await)
+      updateLastSeen(payload.userId).catch((err) => {
+        // Silently fail - last_seen update failure shouldn't block requests
+        if (LOG_LEVEL === 'debug') {
+          logger.warn('Failed to update last_seen', { error: err.message });
+        }
+      });
+
       // Check if this is an impersonation token
       const isImpersonation = !!payload.impersonatedBy;
 
@@ -196,6 +225,7 @@ const app = new Elysia()
           email: payload.email,
           callsign: payload.callsign,
           isAdmin: payload.isAdmin,
+          isSuperAdmin: payload.isSuperAdmin,
           impersonatedBy: payload.impersonatedBy, // Admin ID if impersonating
         },
         isImpersonation,
@@ -331,6 +361,8 @@ const app = new Elysia()
         userId: user.id,
         email: user.email,
         callsign: user.callsign,
+        isAdmin: user.isAdmin,
+        isSuperAdmin: user.isSuperAdmin,
         exp,
       });
 
@@ -400,6 +432,7 @@ const app = new Elysia()
         email: user.email,
         callsign: user.callsign,
         isAdmin: user.isAdmin,
+        isSuperAdmin: user.isSuperAdmin,
         exp,
       });
 
@@ -434,9 +467,15 @@ const app = new Elysia()
       return { success: false, error: 'User not found' };
     }
 
+    // Include impersonatedBy from JWT if present (not stored in database)
+    const responseUser = {
+      ...userData,
+      impersonatedBy: user.impersonatedBy,
+    };
+
     return {
       success: true,
-      user: userData,
+      user: responseUser,
     };
   })
 
@@ -860,6 +899,7 @@ const app = new Elysia()
         message: `Deleted ${deleted} QSO(s)`,
       };
     } catch (error) {
+      logger.error('Failed to delete QSOs', { error: error.message, stack: error.stack });
       set.status = 500;
       return {
         success: false,
@@ -895,6 +935,42 @@ const app = new Elysia()
     }
   })
 
+  /**
+   * GET /api/awards/:awardId
+   * Get a single award by ID (requires authentication)
+   */
+  .get('/api/awards/:awardId', async ({ user, params, set }) => {
+    if (!user) {
+      set.status = 401;
+      return { success: false, error: 'Unauthorized' };
+    }
+
+    try {
+      const { awardId } = params;
+      const award = getAwardById(awardId);
+
+      if (!award) {
+        set.status = 404;
+        return {
+          success: false,
+          error: 'Award not found',
+        };
+      }
+
+      return {
+        success: true,
+        award,
+      };
+    } catch (error) {
+      logger.error('Error fetching award', { error: error.message });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch award',
+      };
+    }
+  })
+
   /**
    * GET /api/awards/:awardId/progress
    * Get award progress for user (requires authentication)
@@ -1137,7 +1213,7 @@ const app = new Elysia()
 
   /**
    * POST /api/admin/users/:userId/role
-   * Update user admin status (admin only)
+   * Update user role (admin only)
    */
   .post('/api/admin/users/:userId/role', async ({ user, params, body, set }) => {
     if (!user || !user.isAdmin) {
@@ -1151,21 +1227,27 @@ const app = new Elysia()
       return { success: false, error: 'Invalid user ID' };
     }
 
-    const { isAdmin } = body;
+    const { role } = body;
 
-    if (typeof isAdmin !== 'boolean') {
+    if (typeof role !== 'string') {
       set.status = 400;
-      return { success: false, error: 'isAdmin (boolean) is required' };
+      return { success: false, error: 'role (string) is required' };
+    }
+
+    const validRoles = ['user', 'admin', 'super-admin'];
+    if (!validRoles.includes(role)) {
+      set.status = 400;
+      return { success: false, error: `Invalid role. Must be one of: ${validRoles.join(', ')}` };
     }
 
     try {
-      await changeUserRole(user.id, targetUserId, isAdmin);
+      await changeUserRole(user.id, targetUserId, role);
       return {
         success: true,
-        message: 'User admin status updated successfully',
+        message: 'User role updated successfully',
       };
     } catch (error) {
-      logger.error('Error updating user admin status', { error: error.message, userId: user.id });
+      logger.error('Error updating user role', { error: error.message, userId: user.id });
       set.status = 400;
       return {
         success: false,
@@ -1232,6 +1314,7 @@ const app = new Elysia()
         email: targetUser.email,
         callsign: targetUser.callsign,
         isAdmin: targetUser.isAdmin,
+        isSuperAdmin: targetUser.isSuperAdmin,
         impersonatedBy: user.id, // Admin ID who started impersonation
         exp,
       });
@@ -1292,6 +1375,7 @@ const app = new Elysia()
         email: adminUser.email,
         callsign: adminUser.callsign,
         isAdmin: adminUser.isAdmin,
+        isSuperAdmin: adminUser.isSuperAdmin,
         exp,
       });
 
@@ -1390,6 +1474,348 @@ const app = new Elysia()
     }
   })
 
+  /**
+   * ================================================================
+   * AWARD MANAGEMENT ROUTES (Admin Only)
+   * ================================================================
+   */
+
+  /**
+   * GET /api/admin/awards
+   * Get all award definitions (admin only)
+   */
+  .get('/api/admin/awards', async ({ user, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const awards = await getAllAwardDefinitions();
+      return {
+        success: true,
+        awards,
+      };
+    } catch (error) {
+      logger.error('Error fetching award definitions', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch award definitions',
+      };
+    }
+  })
+
+  /**
+   * GET /api/admin/awards/:id
+   * Get a single award definition (admin only)
+   */
+  .get('/api/admin/awards/:id', async ({ user, params, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const award = await getAwardDefinition(params.id);
+
+      if (!award) {
+        set.status = 404;
+        return {
+          success: false,
+          error: 'Award not found',
+        };
+      }
+
+      return {
+        success: true,
+        award,
+      };
+    } catch (error) {
+      logger.error('Error fetching award definition', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch award definition',
+      };
+    }
+  })
+
+  /**
+   * POST /api/admin/awards
+   * Create a new award definition (admin only)
+   */
+  .post(
+    '/api/admin/awards',
+    async ({ user, body, set }) => {
+      if (!user || !user.isAdmin) {
+        set.status = !user ? 401 : 403;
+        return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+      }
+
+      try {
+        const award = await createAwardDefinition(body);
+        return {
+          success: true,
+          award,
+          message: 'Award definition created successfully',
+        };
+      } catch (error) {
+        logger.error('Error creating award definition', { error: error.message, userId: user.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        id: t.String(),
+        name: t.String(),
+        description: t.String(),
+        caption: t.String(),
+        category: t.String(),
+        rules: t.Any(),
+        modeGroups: t.Optional(t.Any()),
+      }),
+    }
+  )
+
+  /**
+   * PUT /api/admin/awards/:id
+   * Update an award definition (admin only)
+   */
+  .put(
+    '/api/admin/awards/:id',
+    async ({ user, params, body, set }) => {
+      if (!user || !user.isAdmin) {
+        set.status = !user ? 401 : 403;
+        return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+      }
+
+      try {
+        const award = await updateAwardDefinition(params.id, body);
+        return {
+          success: true,
+          award,
+          message: 'Award definition updated successfully',
+        };
+      } catch (error) {
+        logger.error('Error updating award definition', { error: error.message, userId: user.id, awardId: params.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        id: t.Optional(t.String()),
+        name: t.String(),
+        description: t.String(),
+        caption: t.String(),
+        category: t.String(),
+        rules: t.Any(),
+        modeGroups: t.Optional(t.Any()),
+        achievements: t.Optional(t.Any()),
+      }),
+    }
+  )
+
+  /**
+   * DELETE /api/admin/awards/:id
+   * Delete an award definition (admin only)
+   */
+  .delete('/api/admin/awards/:id', async ({ user, params, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const result = await deleteAwardDefinition(params.id);
+      return {
+        success: true,
+        ...result,
+        message: 'Award definition deleted successfully',
+      };
+    } catch (error) {
+      logger.error('Error deleting award definition', { error: error.message, userId: user.id, awardId: params.id });
+      set.status = 400;
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  })
+
+  /**
+   * POST /api/admin/awards/:id/test
+   * Test award calculation (admin only)
+   */
+  .post(
+    '/api/admin/awards/:id/test',
+    async ({ user, params, body, set }) => {
+      if (!user || !user.isAdmin) {
+        set.status = !user ? 401 : 403;
+        return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+      }
+
+      try {
+        // Use provided userId or admin's own account
+        const testUserId = body.userId || user.id;
+        const awardDefinition = body.awardDefinition || null;
+        const result = await testAwardCalculation(params.id, testUserId, awardDefinition);
+        return {
+          success: true,
+          ...result,
+        };
+      } catch (error) {
+        logger.error('Error testing award calculation', { error: error.message, userId: user.id, awardId: params.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        userId: t.Optional(t.Integer()),
+        awardDefinition: t.Optional(t.Any()),
+      }),
+    }
+  )
+
+  /**
+   * ================================================================
+   * AUTO-SYNC SETTINGS ROUTES
+   * ================================================================
+   * All auto-sync routes require authentication
+   */
+
+  /**
+   * GET /api/auto-sync/settings
+   * Get user's auto-sync settings (requires authentication)
+   */
+  .get('/api/auto-sync/settings', async ({ user, set }) => {
+    if (!user) {
+      set.status = 401;
+      return { success: false, error: 'Unauthorized' };
+    }
+
+    try {
+      const settings = await getAutoSyncSettings(user.id);
+
+      return {
+        success: true,
+        settings,
+      };
+    } catch (error) {
+      logger.error('Error fetching auto-sync settings', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch auto-sync settings',
+      };
+    }
+  })
+
+  /**
+   * PUT /api/auto-sync/settings
+   * Update user's auto-sync settings (requires authentication)
+   */
+  .put(
+    '/api/auto-sync/settings',
+    async ({ user, body, set }) => {
+      if (!user) {
+        set.status = 401;
+        return { success: false, error: 'Unauthorized' };
+      }
+
+      try {
+        const settings = await updateAutoSyncSettings(user.id, body);
+
+        return {
+          success: true,
+          settings,
+          message: 'Auto-sync settings updated successfully',
+        };
+      } catch (error) {
+        logger.error('Error updating auto-sync settings', { error: error.message, userId: user.id });
+        set.status = 400;
+        return {
+          success: false,
+          error: error.message,
+        };
+      }
+    },
+    {
+      body: t.Object({
+        lotwEnabled: t.Optional(t.Boolean()),
+        lotwIntervalHours: t.Optional(t.Number()),
+        dclEnabled: t.Optional(t.Boolean()),
+        dclIntervalHours: t.Optional(t.Number()),
+      }),
+    }
+  )
+
+  /**
+   * GET /api/auto-sync/scheduler/status
+   * Get scheduler status (admin only)
+   */
+  .get('/api/auto-sync/scheduler/status', async ({ user, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      const status = getSchedulerStatus();
+
+      return {
+        success: true,
+        scheduler: status,
+      };
+    } catch (error) {
+      logger.error('Error fetching scheduler status', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to fetch scheduler status',
+      };
+    }
+  })
+
+  /**
+   * POST /api/auto-sync/scheduler/trigger
+   * Manually trigger scheduler tick (admin only, for testing)
+   */
+  .post('/api/auto-sync/scheduler/trigger', async ({ user, set }) => {
+    if (!user || !user.isAdmin) {
+      set.status = !user ? 401 : 403;
+      return { success: false, error: !user ? 'Unauthorized' : 'Admin access required' };
+    }
+
+    try {
+      await triggerSchedulerTick();
+
+      return {
+        success: true,
+        message: 'Scheduler tick triggered successfully',
+      };
+    } catch (error) {
+      logger.error('Error triggering scheduler tick', { error: error.message, userId: user.id });
+      set.status = 500;
+      return {
+        success: false,
+        error: 'Failed to trigger scheduler tick',
+      };
+    }
+  })
+
   // Serve static files and SPA fallback for all non-API routes
   .get('/*', ({ request }) => {
     const url = new URL(request.url);
@@ -1546,3 +1972,21 @@ logger.info('Server started', {
   nodeEnv: process.env.NODE_ENV || 'unknown',
   logLevel: LOG_LEVEL,
 });
+
+// Start the auto-sync scheduler
+startScheduler();
+
+// Graceful shutdown handlers
+const gracefulShutdown = async (signal) => {
+  logger.info(`Received ${signal}, shutting down gracefully...`);
+
+  // Stop the scheduler
+  await stopScheduler();
+
+  logger.info('Graceful shutdown complete');
+  process.exit(0);
+};
+
+// Handle shutdown signals
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

src/backend/migrations/add-auto-sync-settings.js

@@ -0,0 +1,111 @@
+/**
+ * Migration: Add auto_sync_settings table
+ *
+ * This script creates the auto_sync_settings table for managing
+ * automatic sync intervals for DCL and LoTW services.
+ * Users can enable/disable auto-sync and configure sync intervals.
+ */
+
+import Database from 'bun:sqlite';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const dbPath = join(__dirname, '../award.db');
+const sqlite = new Database(dbPath);
+
+async function migrate() {
+  console.log('Starting migration: Add auto-sync settings...');
+
+  try {
+    // Check if auto_sync_settings table already exists
+    const tableExists = sqlite.query(`
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name='auto_sync_settings'
+    `).get();
+
+    if (tableExists) {
+      console.log('Table auto_sync_settings already exists. Skipping...');
+    } else {
+      // Create auto_sync_settings table
+      sqlite.exec(`
+        CREATE TABLE auto_sync_settings (
+          user_id INTEGER PRIMARY KEY,
+          lotw_enabled INTEGER NOT NULL DEFAULT 0,
+          lotw_interval_hours INTEGER NOT NULL DEFAULT 24,
+          lotw_last_sync_at INTEGER,
+          lotw_next_sync_at INTEGER,
+          dcl_enabled INTEGER NOT NULL DEFAULT 0,
+          dcl_interval_hours INTEGER NOT NULL DEFAULT 24,
+          dcl_last_sync_at INTEGER,
+          dcl_next_sync_at INTEGER,
+          created_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+          updated_at INTEGER NOT NULL DEFAULT (strftime('%s', 'now') * 1000),
+          FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
+        )
+      `);
+
+      // Create index for faster queries on next_sync_at
+      sqlite.exec(`
+        CREATE INDEX idx_auto_sync_settings_lotw_next_sync_at
+        ON auto_sync_settings(lotw_next_sync_at)
+        WHERE lotw_enabled = 1
+      `);
+
+      sqlite.exec(`
+        CREATE INDEX idx_auto_sync_settings_dcl_next_sync_at
+        ON auto_sync_settings(dcl_next_sync_at)
+        WHERE dcl_enabled = 1
+      `);
+
+      console.log('Created auto_sync_settings table with indexes');
+    }
+
+    console.log('Migration complete! Auto-sync settings table added to database.');
+  } catch (error) {
+    console.error('Migration failed:', error);
+    sqlite.close();
+    process.exit(1);
+  }
+
+  sqlite.close();
+}
+
+async function rollback() {
+  console.log('Starting rollback: Remove auto-sync settings...');
+
+  try {
+    // Drop indexes first
+    sqlite.exec(`DROP INDEX IF EXISTS idx_auto_sync_settings_lotw_next_sync_at`);
+    sqlite.exec(`DROP INDEX IF EXISTS idx_auto_sync_settings_dcl_next_sync_at`);
+
+    // Drop table
+    sqlite.exec(`DROP TABLE IF EXISTS auto_sync_settings`);
+
+    console.log('Rollback complete! Auto-sync settings table removed from database.');
+  } catch (error) {
+    console.error('Rollback failed:', error);
+    sqlite.close();
+    process.exit(1);
+  }
+
+  sqlite.close();
+}
+
+// Check if this is a rollback
+const args = process.argv.slice(2);
+if (args.includes('--rollback') || args.includes('-r')) {
+  rollback().then(() => {
+    console.log('Rollback script completed successfully');
+    process.exit(0);
+  });
+} else {
+  // Run migration
+  migrate().then(() => {
+    console.log('Migration script completed successfully');
+    process.exit(0);
+  });
+}

src/backend/migrations/add-last-seen.js

@@ -0,0 +1,86 @@
+/**
+ * Migration: Add last_seen column to users table
+ *
+ * This script adds the last_seen column to track when users last accessed the tool.
+ */
+
+import Database from 'bun:sqlite';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+// ES module equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const dbPath = join(__dirname, '../award.db');
+const sqlite = new Database(dbPath);
+
+async function migrate() {
+  console.log('Starting migration: Add last_seen column...');
+
+  try {
+    // Check if last_seen column already exists
+    const columnExists = sqlite.query(`
+      SELECT COUNT(*) as count
+      FROM pragma_table_info('users')
+      WHERE name='last_seen'
+    `).get();
+
+    if (columnExists.count > 0) {
+      console.log('Column last_seen already exists. Skipping...');
+    } else {
+      // Add last_seen column
+      sqlite.exec(`
+        ALTER TABLE users
+        ADD COLUMN last_seen INTEGER
+      `);
+
+      console.log('Added last_seen column to users table');
+    }
+
+    console.log('Migration complete! last_seen column added to database.');
+  } catch (error) {
+    console.error('Migration failed:', error);
+    sqlite.close();
+    process.exit(1);
+  }
+
+  sqlite.close();
+}
+
+async function rollback() {
+  console.log('Starting rollback: Remove last_seen column...');
+
+  try {
+    // SQLite doesn't support DROP COLUMN directly before version 3.35.5
+    // For older versions, we need to recreate the table
+    console.log('Note: SQLite does not support DROP COLUMN. Manual cleanup required.');
+    console.log('To rollback: Recreate users table without last_seen column');
+
+    // For SQLite 3.35.5+, you can use:
+    // sqlite.exec(`ALTER TABLE users DROP COLUMN last_seen`);
+
+    console.log('Rollback note issued.');
+  } catch (error) {
+    console.error('Rollback failed:', error);
+    sqlite.close();
+    process.exit(1);
+  }
+
+  sqlite.close();
+}
+
+// Check if this is a rollback
+const args = process.argv.slice(2);
+if (args.includes('--rollback') || args.includes('-r')) {
+  rollback().then(() => {
+    console.log('Rollback script completed');
+    process.exit(0);
+  });
+} else {
+  // Run migration
+  migrate().then(() => {
+    console.log('Migration script completed successfully');
+    process.exit(0);
+  });
+}

src/backend/services/admin.service.js

@@ -1,7 +1,7 @@
 import { eq, sql, desc } from 'drizzle-orm';
 import { db, sqlite, logger } from '../config.js';
 import { users, qsos, syncJobs, adminActions, awardProgress, qsoChanges } from '../db/schema/index.js';
-import { getUserByIdFull, isAdmin } from './auth.service.js';
+import { getUserByIdFull, isAdmin, isSuperAdmin } from './auth.service.js';
 
 /**
  * Log an admin action for audit trail
@@ -34,31 +34,35 @@ export async function logAdminAction(adminId, actionType, targetUserId = null, d
  * @returns {Promise<Array>} Array of admin actions
  */
 export async function getAdminActions(adminId = null, { limit = 50, offset = 0 } = {}) {
-  let query = db
-    .select({
-      id: adminActions.id,
-      adminId: adminActions.adminId,
-      adminEmail: users.email,
-      adminCallsign: users.callsign,
-      actionType: adminActions.actionType,
-      targetUserId: adminActions.targetUserId,
-      targetEmail: sql`target_users.email`.as('targetEmail'),
-      targetCallsign: sql`target_users.callsign`.as('targetCallsign'),
-      details: adminActions.details,
-      createdAt: adminActions.createdAt,
-    })
-    .from(adminActions)
-    .leftJoin(users, eq(adminActions.adminId, users.id))
-    .leftJoin(sql`${users} as target_users`, eq(adminActions.targetUserId, sql.raw('target_users.id')))
-    .orderBy(desc(adminActions.createdAt))
-    .limit(limit)
-    .offset(offset);
+  // Use raw SQL for the self-join (admin users and target users from same users table)
+  // Using bun:sqlite prepared statements for raw SQL
+  let query = `
+    SELECT
+      aa.id as id,
+      aa.admin_id as adminId,
+      admin_user.email as adminEmail,
+      admin_user.callsign as adminCallsign,
+      aa.action_type as actionType,
+      aa.target_user_id as targetUserId,
+      target_user.email as targetEmail,
+      target_user.callsign as targetCallsign,
+      aa.details as details,
+      aa.created_at as createdAt
+    FROM admin_actions aa
+    LEFT JOIN users admin_user ON admin_user.id = aa.admin_id
+    LEFT JOIN users target_user ON target_user.id = aa.target_user_id
+  `;
 
-  if (adminId) {
-    query = query.where(eq(adminActions.adminId, adminId));
+  const params = [];
+  if (adminId !== null) {
+    query += ` WHERE aa.admin_id = ?`;
+    params.push(adminId);
   }
 
-  return await query;
+  query += ` ORDER BY aa.created_at DESC LIMIT ? OFFSET ?`;
+  params.push(limit, offset);
+
+  return sqlite.prepare(query).all(...params);
 }
 
 /**
@@ -123,11 +127,17 @@ export async function getUserStats() {
       email: users.email,
       callsign: users.callsign,
       isAdmin: users.isAdmin,
+      lastSeen: users.lastSeen,
       qsoCount: sql`CAST(COUNT(${qsos.id}) AS INTEGER)`,
       lotwConfirmed: sql`CAST(SUM(CASE WHEN ${qsos.lotwQslRstatus} = 'Y' THEN 1 ELSE 0 END) AS INTEGER)`,
       dclConfirmed: sql`CAST(SUM(CASE WHEN ${qsos.dclQslRstatus} = 'Y' THEN 1 ELSE 0 END) AS INTEGER)`,
       totalConfirmed: sql`CAST(SUM(CASE WHEN ${qsos.lotwQslRstatus} = 'Y' OR ${qsos.dclQslRstatus} = 'Y' THEN 1 ELSE 0 END) AS INTEGER)`,
-      lastSync: sql`MAX(${qsos.createdAt})`,
+      lastSync: sql`(
+        SELECT MAX(${syncJobs.completedAt})
+        FROM ${syncJobs}
+        WHERE ${syncJobs.userId} = ${users.id}
+        AND ${syncJobs.status} = 'completed'
+      )`.mapWith(Number),
       createdAt: users.createdAt,
     })
     .from(users)
@@ -135,7 +145,14 @@ export async function getUserStats() {
     .groupBy(users.id)
     .orderBy(sql`COUNT(${qsos.id}) DESC`);
 
-  return stats;
+  // Convert timestamps (seconds) to Date objects for JSON serialization
+  // Note: lastSeen from Drizzle is already a Date object (timestamp mode)
+  // lastSync is raw SQL returning seconds, needs conversion
+  return stats.map(stat => ({
+    ...stat,
+    lastSync: stat.lastSync ? new Date(stat.lastSync * 1000) : null,
+    // lastSeen is already a Date object from Drizzle, don't convert
+  }));
 }
 
 /**
@@ -143,7 +160,7 @@ export async function getUserStats() {
  * @param {number} adminId - Admin user ID
  * @param {number} targetUserId - Target user ID to impersonate
  * @returns {Promise<Object>} Target user object
- * @throws {Error} If not admin or trying to impersonate another admin
+ * @throws {Error} If not admin or trying to impersonate another admin (without super-admin)
  */
 export async function impersonateUser(adminId, targetUserId) {
   // Verify the requester is an admin
@@ -158,9 +175,17 @@ export async function impersonateUser(adminId, targetUserId) {
     throw new Error('Target user not found');
   }
 
-  // Check if target is also an admin (prevent admin impersonation)
+  // Check if target is also an admin
   if (targetUser.isAdmin) {
-    throw new Error('Cannot impersonate another admin user');
+    // Only super-admins can impersonate other admins
+    const requesterIsSuperAdmin = await isSuperAdmin(adminId);
+    if (!requesterIsSuperAdmin) {
+      throw new Error('Cannot impersonate another admin user (super-admin required)');
+    }
+    // Prevent self-impersonation (edge case)
+    if (adminId === targetUserId) {
+      throw new Error('Cannot impersonate yourself');
+    }
   }
 
   // Log impersonation action
@@ -228,72 +253,95 @@ export async function stopImpersonation(adminId, targetUserId) {
  * @returns {Promise<Array>} Array of recent impersonation actions
  */
 export async function getImpersonationStatus(adminId, { limit = 10 } = {}) {
-  const impersonations = await db
-    .select({
-      id: adminActions.id,
-      actionType: adminActions.actionType,
-      targetUserId: adminActions.targetUserId,
-      targetEmail: sql`target_users.email`,
-      targetCallsign: sql`target_users.callsign`,
-      details: adminActions.details,
-      createdAt: adminActions.createdAt,
-    })
-    .from(adminActions)
-    .leftJoin(sql`${users} as target_users`, eq(adminActions.targetUserId, sql.raw('target_users.id')))
-    .where(eq(adminActions.adminId, adminId))
-    .where(sql`${adminActions.actionType} LIKE 'impersonate%'`)
-    .orderBy(desc(adminActions.createdAt))
-    .limit(limit);
+  // Use raw SQL for the self-join to avoid Drizzle alias issues
+  // Using bun:sqlite prepared statements for raw SQL
+  const query = `
+    SELECT
+      aa.id as id,
+      aa.action_type as actionType,
+      aa.target_user_id as targetUserId,
+      u.email as targetEmail,
+      u.callsign as targetCallsign,
+      aa.details as details,
+      aa.created_at as createdAt
+    FROM admin_actions aa
+    LEFT JOIN users u ON u.id = aa.target_user_id
+    WHERE aa.admin_id = ?
+      AND aa.action_type LIKE 'impersonate%'
+    ORDER BY aa.created_at DESC
+    LIMIT ?
+  `;
 
-  return impersonations;
+  return sqlite.prepare(query).all(adminId, limit);
 }
 
 /**
  * Update user admin status (admin operation)
  * @param {number} adminId - Admin user ID making the change
  * @param {number} targetUserId - User ID to update
- * @param {boolean} newIsAdmin - New admin flag
+ * @param {string} newRole - New role: 'user', 'admin', or 'super-admin'
  * @returns {Promise<void>}
- * @throws {Error} If not admin or would remove last admin
+ * @throws {Error} If not admin or violates security rules
  */
-export async function changeUserRole(adminId, targetUserId, newIsAdmin) {
+export async function changeUserRole(adminId, targetUserId, newRole) {
+  // Validate role
+  const validRoles = ['user', 'admin', 'super-admin'];
+  if (!validRoles.includes(newRole)) {
+    throw new Error('Invalid role. Must be one of: user, admin, super-admin');
+  }
+
   // Verify the requester is an admin
   const requesterIsAdmin = await isAdmin(adminId);
   if (!requesterIsAdmin) {
-    throw new Error('Only admins can change user admin status');
+    throw new Error('Only admins can change user roles');
   }
 
+  // Get requester super-admin status
+  const requesterIsSuperAdmin = await isSuperAdmin(adminId);
+
   // Get target user
   const targetUser = await getUserByIdFull(targetUserId);
   if (!targetUser) {
     throw new Error('Target user not found');
   }
 
-  // If demoting from admin, check if this would remove the last admin
-  if (targetUser.isAdmin && !newIsAdmin) {
-    const adminCount = await db
-      .select({ count: sql`CAST(COUNT(*) AS INTEGER)` })
-      .from(users)
-      .where(eq(users.isAdmin, 1));
+  // Security rules for super-admin role changes
+  const targetWillBeSuperAdmin = newRole === 'super-admin';
+  const targetIsCurrentlySuperAdmin = targetUser.isSuperAdmin;
 
-    if (adminCount[0].count === 1) {
-      throw new Error('Cannot demote the last admin user');
+  // Only super-admins can promote/demote super-admins
+  if (targetWillBeSuperAdmin || targetIsCurrentlySuperAdmin) {
+    if (!requesterIsSuperAdmin) {
+      throw new Error('Only super-admins can promote or demote super-admins');
     }
   }
 
-  // Update admin status
-  await db
-    .update(users)
-    .set({
-      isAdmin: newIsAdmin ? 1 : 0,
-      updatedAt: new Date(),
-    })
-    .where(eq(users.id, targetUserId));
+  // Prevent self-demotion (super-admins cannot demote themselves)
+  if (adminId === targetUserId) {
+    if (targetIsCurrentlySuperAdmin && !targetWillBeSuperAdmin) {
+      throw new Error('Cannot demote yourself from super-admin');
+    }
+  }
+
+  // Cannot demote the last super-admin
+  if (targetIsCurrentlySuperAdmin && !targetWillBeSuperAdmin) {
+    const superAdminCount = await db
+      .select({ count: sql`CAST(COUNT(*) AS INTEGER)` })
+      .from(users)
+      .where(eq(users.isSuperAdmin, 1));
+
+    if (superAdminCount[0].count === 1) {
+      throw new Error('Cannot demote the last super-admin');
+    }
+  }
+
+  // Update role (use the auth service function)
+  await updateUserRole(targetUserId, newRole);
 
   // Log action
   await logAdminAction(adminId, 'role_change', targetUserId, {
-    oldIsAdmin: targetUser.isAdmin,
-    newIsAdmin: newIsAdmin,
+    oldRole: targetUser.isSuperAdmin ? 'super-admin' : (targetUser.isAdmin ? 'admin' : 'user'),
+    newRole: newRole,
   });
 }
 

src/backend/services/auth.service.js

@@ -158,6 +158,21 @@ export async function isAdmin(userId) {
   return user?.isAdmin === true || user?.isAdmin === 1;
 }
 
+/**
+ * Check if user is super-admin
+ * @param {number} userId - User ID
+ * @returns {Promise<boolean>} True if user is super-admin
+ */
+export async function isSuperAdmin(userId) {
+  const [user] = await db
+    .select({ isSuperAdmin: users.isSuperAdmin })
+    .from(users)
+    .where(eq(users.id, userId))
+    .limit(1);
+
+  return user?.isSuperAdmin === true || user?.isSuperAdmin === 1;
+}
+
 /**
  * Get all admin users
  * @returns {Promise<Array>} Array of admin users (without passwords)
@@ -178,16 +193,20 @@ export async function getAdminUsers() {
 }
 
 /**
- * Update user admin status
+ * Update user role
  * @param {number} userId - User ID
- * @param {boolean} isAdmin - Admin flag
+ * @param {string} role - Role: 'user', 'admin', or 'super-admin'
  * @returns {Promise<void>}
  */
-export async function updateUserRole(userId, isAdmin) {
+export async function updateUserRole(userId, role) {
+  const isAdmin = role === 'admin' || role === 'super-admin';
+  const isSuperAdmin = role === 'super-admin';
+
   await db
     .update(users)
     .set({
       isAdmin: isAdmin ? 1 : 0,
+      isSuperAdmin: isSuperAdmin ? 1 : 0,
       updatedAt: new Date(),
     })
     .where(eq(users.id, userId));
@@ -204,6 +223,8 @@ export async function getAllUsers() {
       email: users.email,
       callsign: users.callsign,
       isAdmin: users.isAdmin,
+      isSuperAdmin: users.isSuperAdmin,
+      lastSeen: users.lastSeen,
       createdAt: users.createdAt,
       updatedAt: users.updatedAt,
     })
@@ -225,6 +246,7 @@ export async function getUserByIdFull(userId) {
       email: users.email,
       callsign: users.callsign,
       isAdmin: users.isAdmin,
+      isSuperAdmin: users.isSuperAdmin,
       lotwUsername: users.lotwUsername,
       dclApiKey: users.dclApiKey,
       createdAt: users.createdAt,
@@ -236,3 +258,17 @@ export async function getUserByIdFull(userId) {
 
   return user || null;
 }
+
+/**
+ * Update user's last seen timestamp
+ * @param {number} userId - User ID
+ * @returns {Promise<void>}
+ */
+export async function updateLastSeen(userId) {
+  await db
+    .update(users)
+    .set({
+      lastSeen: new Date(),
+    })
+    .where(eq(users.id, userId));
+}

src/backend/services/auto-sync.service.js

@@ -0,0 +1,373 @@
+import { db, logger } from '../config.js';
+import { autoSyncSettings, users } from '../db/schema/index.js';
+import { eq, and, lte, or } from 'drizzle-orm';
+
+/**
+ * Auto-Sync Settings Service
+ * Manages user preferences for automatic DCL and LoTW synchronization
+ */
+
+// Validation constants
+export const MIN_INTERVAL_HOURS = 1;
+export const MAX_INTERVAL_HOURS = 720; // 30 days
+export const DEFAULT_INTERVAL_HOURS = 24;
+
+/**
+ * Get auto-sync settings for a user
+ * Creates default settings if they don't exist
+ *
+ * @param {number} userId - User ID
+ * @returns {Promise<Object>} Auto-sync settings
+ */
+export async function getAutoSyncSettings(userId) {
+  try {
+    let [settings] = await db
+      .select()
+      .from(autoSyncSettings)
+      .where(eq(autoSyncSettings.userId, userId));
+
+    // Create default settings if they don't exist
+    if (!settings) {
+      logger.debug('Creating default auto-sync settings for user', { userId });
+      [settings] = await db
+        .insert(autoSyncSettings)
+        .values({
+          userId,
+          lotwEnabled: false,
+          lotwIntervalHours: DEFAULT_INTERVAL_HOURS,
+          dclEnabled: false,
+          dclIntervalHours: DEFAULT_INTERVAL_HOURS,
+        })
+        .returning();
+    }
+
+    return {
+      lotwEnabled: settings.lotwEnabled,
+      lotwIntervalHours: settings.lotwIntervalHours,
+      lotwLastSyncAt: settings.lotwLastSyncAt,
+      lotwNextSyncAt: settings.lotwNextSyncAt,
+      dclEnabled: settings.dclEnabled,
+      dclIntervalHours: settings.dclIntervalHours,
+      dclLastSyncAt: settings.dclLastSyncAt,
+      dclNextSyncAt: settings.dclNextSyncAt,
+    };
+  } catch (error) {
+    logger.error('Failed to get auto-sync settings', { error: error.message, userId });
+    throw error;
+  }
+}
+
+/**
+ * Validate interval hours
+ * @param {number} hours - Interval hours to validate
+ * @returns {Object} Validation result
+ */
+function validateIntervalHours(hours) {
+  if (typeof hours !== 'number' || isNaN(hours)) {
+    return { valid: false, error: 'Interval must be a number' };
+  }
+  if (!Number.isInteger(hours)) {
+    return { valid: false, error: 'Interval must be a whole number of hours' };
+  }
+  if (hours < MIN_INTERVAL_HOURS) {
+    return { valid: false, error: `Interval must be at least ${MIN_INTERVAL_HOURS} hour` };
+  }
+  if (hours > MAX_INTERVAL_HOURS) {
+    return { valid: false, error: `Interval must be at most ${MAX_INTERVAL_HOURS} hours (30 days)` };
+  }
+  return { valid: true };
+}
+
+/**
+ * Calculate next sync time based on interval
+ * @param {number} intervalHours - Interval in hours
+ * @returns {Date} Next sync time
+ */
+function calculateNextSyncTime(intervalHours) {
+  const nextSync = new Date();
+  nextSync.setHours(nextSync.getHours() + intervalHours);
+  return nextSync;
+}
+
+/**
+ * Update auto-sync settings for a user
+ *
+ * @param {number} userId - User ID
+ * @param {Object} settings - Settings to update
+ * @returns {Promise<Object>} Updated settings
+ */
+export async function updateAutoSyncSettings(userId, settings) {
+  try {
+    // Get current settings
+    let [currentSettings] = await db
+      .select()
+      .from(autoSyncSettings)
+      .where(eq(autoSyncSettings.userId, userId));
+
+    // Create default settings if they don't exist
+    if (!currentSettings) {
+      [currentSettings] = await db
+        .insert(autoSyncSettings)
+        .values({
+          userId,
+          lotwEnabled: false,
+          lotwIntervalHours: DEFAULT_INTERVAL_HOURS,
+          dclEnabled: false,
+          dclIntervalHours: DEFAULT_INTERVAL_HOURS,
+        })
+        .returning();
+    }
+
+    // Prepare update data
+    const updateData = {
+      updatedAt: new Date(),
+    };
+
+    // Validate and update LoTW settings
+    if (settings.lotwEnabled !== undefined) {
+      if (typeof settings.lotwEnabled !== 'boolean') {
+        throw new Error('lotwEnabled must be a boolean');
+      }
+      updateData.lotwEnabled = settings.lotwEnabled;
+
+      // If enabling for the first time or interval changed, set next sync time
+      if (settings.lotwEnabled && (!currentSettings.lotwEnabled || settings.lotwIntervalHours)) {
+        const intervalHours = settings.lotwIntervalHours || currentSettings.lotwIntervalHours;
+        const validation = validateIntervalHours(intervalHours);
+        if (!validation.valid) {
+          throw new Error(`LoTW interval: ${validation.error}`);
+        }
+        updateData.lotwNextSyncAt = calculateNextSyncTime(intervalHours);
+      } else if (!settings.lotwEnabled) {
+        // Clear next sync when disabling
+        updateData.lotwNextSyncAt = null;
+      }
+    }
+
+    if (settings.lotwIntervalHours !== undefined) {
+      const validation = validateIntervalHours(settings.lotwIntervalHours);
+      if (!validation.valid) {
+        throw new Error(`LoTW interval: ${validation.error}`);
+      }
+      updateData.lotwIntervalHours = settings.lotwIntervalHours;
+
+      // Update next sync time if LoTW is enabled
+      if (currentSettings.lotwEnabled || settings.lotwEnabled) {
+        updateData.lotwNextSyncAt = calculateNextSyncTime(settings.lotwIntervalHours);
+      }
+    }
+
+    // Validate and update DCL settings
+    if (settings.dclEnabled !== undefined) {
+      if (typeof settings.dclEnabled !== 'boolean') {
+        throw new Error('dclEnabled must be a boolean');
+      }
+      updateData.dclEnabled = settings.dclEnabled;
+
+      // If enabling for the first time or interval changed, set next sync time
+      if (settings.dclEnabled && (!currentSettings.dclEnabled || settings.dclIntervalHours)) {
+        const intervalHours = settings.dclIntervalHours || currentSettings.dclIntervalHours;
+        const validation = validateIntervalHours(intervalHours);
+        if (!validation.valid) {
+          throw new Error(`DCL interval: ${validation.error}`);
+        }
+        updateData.dclNextSyncAt = calculateNextSyncTime(intervalHours);
+      } else if (!settings.dclEnabled) {
+        // Clear next sync when disabling
+        updateData.dclNextSyncAt = null;
+      }
+    }
+
+    if (settings.dclIntervalHours !== undefined) {
+      const validation = validateIntervalHours(settings.dclIntervalHours);
+      if (!validation.valid) {
+        throw new Error(`DCL interval: ${validation.error}`);
+      }
+      updateData.dclIntervalHours = settings.dclIntervalHours;
+
+      // Update next sync time if DCL is enabled
+      if (currentSettings.dclEnabled || settings.dclEnabled) {
+        updateData.dclNextSyncAt = calculateNextSyncTime(settings.dclIntervalHours);
+      }
+    }
+
+    // Update settings in database
+    const [updated] = await db
+      .update(autoSyncSettings)
+      .set(updateData)
+      .where(eq(autoSyncSettings.userId, userId))
+      .returning();
+
+    logger.info('Updated auto-sync settings', {
+      userId,
+      lotwEnabled: updated.lotwEnabled,
+      lotwIntervalHours: updated.lotwIntervalHours,
+      dclEnabled: updated.dclEnabled,
+      dclIntervalHours: updated.dclIntervalHours,
+    });
+
+    return {
+      lotwEnabled: updated.lotwEnabled,
+      lotwIntervalHours: updated.lotwIntervalHours,
+      lotwLastSyncAt: updated.lotwLastSyncAt,
+      lotwNextSyncAt: updated.lotwNextSyncAt,
+      dclEnabled: updated.dclEnabled,
+      dclIntervalHours: updated.dclIntervalHours,
+      dclLastSyncAt: updated.dclLastSyncAt,
+      dclNextSyncAt: updated.dclNextSyncAt,
+    };
+  } catch (error) {
+    logger.error('Failed to update auto-sync settings', { error: error.message, userId });
+    throw error;
+  }
+}
+
+/**
+ * Get users with pending syncs for a specific service
+ *
+ * @param {string} service - 'lotw' or 'dcl'
+ * @returns {Promise<Array>} List of users with pending syncs
+ */
+export async function getPendingSyncUsers(service) {
+  try {
+    if (service !== 'lotw' && service !== 'dcl') {
+      throw new Error('Service must be "lotw" or "dcl"');
+    }
+
+    const enabledField = service === 'lotw' ? autoSyncSettings.lotwEnabled : autoSyncSettings.dclEnabled;
+    const nextSyncField = service === 'lotw' ? autoSyncSettings.lotwNextSyncAt : autoSyncSettings.dclNextSyncAt;
+    const credentialField = service === 'lotw' ? users.lotwUsername : users.dclApiKey;
+    const intervalField = service === 'lotw' ? autoSyncSettings.lotwIntervalHours : autoSyncSettings.dclIntervalHours;
+
+    const now = new Date();
+
+    // Get users with auto-sync enabled and next sync time in the past
+    const results = await db
+      .select({
+        userId: autoSyncSettings.userId,
+        lotwEnabled: autoSyncSettings.lotwEnabled,
+        lotwIntervalHours: autoSyncSettings.lotwIntervalHours,
+        lotwNextSyncAt: autoSyncSettings.lotwNextSyncAt,
+        dclEnabled: autoSyncSettings.dclEnabled,
+        dclIntervalHours: autoSyncSettings.dclIntervalHours,
+        dclNextSyncAt: autoSyncSettings.dclNextSyncAt,
+        hasCredentials: credentialField, // Just check if field exists (not null/empty)
+      })
+      .from(autoSyncSettings)
+      .innerJoin(users, eq(autoSyncSettings.userId, users.id))
+      .where(
+        and(
+          eq(enabledField, true),
+          lte(nextSyncField, now)
+        )
+      );
+
+    // Split into users with and without credentials
+    const withCredentials = results.filter(r => r.hasCredentials);
+    const withoutCredentials = results.filter(r => !r.hasCredentials);
+
+    // For users without credentials, update their next sync time to retry in 24 hours
+    // This prevents them from being continuously retried every minute
+    if (withoutCredentials.length > 0) {
+      const retryDate = new Date();
+      retryDate.setHours(retryDate.getHours() + 24);
+
+      for (const user of withoutCredentials) {
+        const updateData = {
+          updatedAt: new Date(),
+        };
+
+        if (service === 'lotw') {
+          updateData.lotwNextSyncAt = retryDate;
+        } else {
+          updateData.dclNextSyncAt = retryDate;
+        }
+
+        await db
+          .update(autoSyncSettings)
+          .set(updateData)
+          .where(eq(autoSyncSettings.userId, user.userId));
+      }
+
+      logger.warn('Skipped auto-sync for users without credentials, will retry in 24 hours', {
+        service,
+        count: withoutCredentials.length,
+        userIds: withoutCredentials.map(u => u.userId),
+      });
+    }
+
+    logger.debug('Found pending sync users', {
+      service,
+      total: results.length,
+      withCredentials: withCredentials.length,
+      withoutCredentials: withoutCredentials.length,
+    });
+
+    return withCredentials;
+  } catch (error) {
+    logger.error('Failed to get pending sync users', { error: error.message, service });
+    return [];
+  }
+}
+
+/**
+ * Update sync timestamps after a successful sync
+ *
+ * @param {number} userId - User ID
+ * @param {string} service - 'lotw' or 'dcl'
+ * @param {Date} lastSyncDate - Date of last sync
+ * @returns {Promise<void>}
+ */
+export async function updateSyncTimestamps(userId, service, lastSyncDate) {
+  try {
+    if (service !== 'lotw' && service !== 'dcl') {
+      throw new Error('Service must be "lotw" or "dcl"');
+    }
+
+    // Get current settings to find the interval
+    const [currentSettings] = await db
+      .select()
+      .from(autoSyncSettings)
+      .where(eq(autoSyncSettings.userId, userId));
+
+    if (!currentSettings) {
+      logger.warn('No auto-sync settings found for user', { userId, service });
+      return;
+    }
+
+    const intervalHours = service === 'lotw'
+      ? currentSettings.lotwIntervalHours
+      : currentSettings.dclIntervalHours;
+
+    // Calculate next sync time
+    const nextSyncAt = calculateNextSyncTime(intervalHours);
+
+    // Update timestamps
+    const updateData = {
+      updatedAt: new Date(),
+    };
+
+    if (service === 'lotw') {
+      updateData.lotwLastSyncAt = lastSyncDate;
+      updateData.lotwNextSyncAt = nextSyncAt;
+    } else {
+      updateData.dclLastSyncAt = lastSyncDate;
+      updateData.dclNextSyncAt = nextSyncAt;
+    }
+
+    await db
+      .update(autoSyncSettings)
+      .set(updateData)
+      .where(eq(autoSyncSettings.userId, userId));
+
+    logger.debug('Updated sync timestamps', {
+      userId,
+      service,
+      lastSyncAt: lastSyncDate.toISOString(),
+      nextSyncAt: nextSyncAt.toISOString(),
+    });
+  } catch (error) {
+    logger.error('Failed to update sync timestamps', { error: error.message, userId, service });
+    throw error;
+  }
+}

src/backend/services/awards-admin.service.js

@@ -0,0 +1,570 @@
+import { readFileSync, writeFileSync, readdirSync, unlinkSync, existsSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../config.js';
+import { calculateAwardProgress, getAwardById, clearAwardCache } from './awards.service.js';
+
+/**
+ * Awards Admin Service
+ * Manages award definition JSON files for admin operations
+ */
+
+const AWARD_DEFINITIONS_DIR = join(process.cwd(), 'award-definitions');
+
+// Valid entity types for entity rule type
+const VALID_ENTITY_TYPES = ['dxcc', 'state', 'grid', 'callsign'];
+
+// Valid rule types
+const VALID_RULE_TYPES = ['entity', 'dok', 'points', 'filtered', 'counter'];
+
+// Valid count modes for points rule type
+const VALID_COUNT_MODES = ['perStation', 'perBandMode', 'perQso'];
+
+// Valid filter operators
+const VALID_FILTER_OPERATORS = ['eq', 'ne', 'in', 'nin', 'contains'];
+
+// Valid filter fields
+const VALID_FILTER_FIELDS = [
+  'band', 'mode', 'callsign', 'entity', 'entityId', 'state', 'grid', 'satName', 'satellite'
+];
+
+// Valid bands
+const VALID_BANDS = [
+  '160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m',
+  '6m', '2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'
+];
+
+// Valid modes
+const VALID_MODES = [
+  'CW', 'SSB', 'AM', 'FM', 'RTTY', 'PSK31', 'FT8', 'FT4', 'JT65', 'JT9',
+  'MFSK', 'Q65', 'JS8', 'FSK441', 'ISCAT', 'JT6M', 'MSK144'
+];
+
+/**
+ * Load all award definitions with file metadata
+ */
+export async function getAllAwardDefinitions() {
+  const definitions = [];
+
+  try {
+    const files = readdirSync(AWARD_DEFINITIONS_DIR)
+      .filter(f => f.endsWith('.json'))
+      .sort();
+
+    for (const file of files) {
+      try {
+        const filePath = join(AWARD_DEFINITIONS_DIR, file);
+        const content = readFileSync(filePath, 'utf-8');
+        const definition = JSON.parse(content);
+
+        // Add file metadata
+        definitions.push({
+          ...definition,
+          _filename: file,
+          _filepath: filePath,
+        });
+      } catch (error) {
+        logger.warn('Failed to load award definition', { file, error: error.message });
+      }
+    }
+  } catch (error) {
+    logger.error('Error reading award definitions directory', { error: error.message });
+  }
+
+  return definitions;
+}
+
+/**
+ * Get a single award definition by ID
+ */
+export async function getAwardDefinition(id) {
+  const definitions = await getAllAwardDefinitions();
+  return definitions.find(def => def.id === id) || null;
+}
+
+/**
+ * Validate an award definition
+ * @returns {Object} { valid: boolean, errors: string[], warnings: string[] }
+ */
+export function validateAwardDefinition(definition, existingDefinitions = []) {
+  const errors = [];
+  const warnings = [];
+
+  // Check required top-level fields
+  const requiredFields = ['id', 'name', 'description', 'caption', 'category', 'rules'];
+  for (const field of requiredFields) {
+    if (!definition[field]) {
+      errors.push(`Missing required field: ${field}`);
+    }
+  }
+
+  // Validate ID
+  if (definition.id) {
+    if (typeof definition.id !== 'string') {
+      errors.push('ID must be a string');
+    } else if (!/^[a-z0-9-]+$/.test(definition.id)) {
+      errors.push('ID must contain only lowercase letters, numbers, and hyphens');
+    } else {
+      // Check for duplicate ID (unless updating existing award)
+      const existingIds = existingDefinitions.map(d => d.id);
+      const isUpdate = existingDefinitions.find(d => d.id === definition.id);
+      const duplicates = existingDefinitions.filter(d => d.id === definition.id);
+      if (duplicates.length > 1 || (duplicates.length === 1 && !isUpdate)) {
+        errors.push(`Award ID "${definition.id}" already exists`);
+      }
+    }
+  }
+
+  // Validate name
+  if (definition.name && typeof definition.name !== 'string') {
+    errors.push('Name must be a string');
+  }
+
+  // Validate description
+  if (definition.description && typeof definition.description !== 'string') {
+    errors.push('Description must be a string');
+  }
+
+  // Validate caption
+  if (definition.caption && typeof definition.caption !== 'string') {
+    errors.push('Caption must be a string');
+  }
+
+  // Validate category
+  if (definition.category && typeof definition.category !== 'string') {
+    errors.push('Category must be a string');
+  }
+
+  // Validate achievements if present
+  if (definition.achievements) {
+    if (!Array.isArray(definition.achievements)) {
+      errors.push('achievements must be an array');
+    } else {
+      for (let i = 0; i < definition.achievements.length; i++) {
+        const achievement = definition.achievements[i];
+        if (!achievement.name || typeof achievement.name !== 'string') {
+          errors.push(`Achievement ${i + 1} must have a name`);
+        }
+        if (typeof achievement.threshold !== 'number' || achievement.threshold <= 0) {
+          errors.push(`Achievement "${achievement.name || i + 1}" must have a positive threshold`);
+        }
+      }
+      // Check for duplicate thresholds
+      const thresholds = definition.achievements.map(a => a.threshold);
+      const uniqueThresholds = new Set(thresholds);
+      if (thresholds.length !== uniqueThresholds.size) {
+        errors.push('Achievements must have unique thresholds');
+      }
+    }
+  }
+
+  // Validate modeGroups if present
+  if (definition.modeGroups) {
+    if (typeof definition.modeGroups !== 'object') {
+      errors.push('modeGroups must be an object');
+    } else {
+      for (const [groupName, modes] of Object.entries(definition.modeGroups)) {
+        if (!Array.isArray(modes)) {
+          errors.push(`modeGroups "${groupName}" must be an array of mode strings`);
+        } else {
+          for (const mode of modes) {
+            if (typeof mode !== 'string') {
+              errors.push(`mode "${mode}" in group "${groupName}" must be a string`);
+            } else if (!VALID_MODES.includes(mode)) {
+              warnings.push(`Unknown mode "${mode}" in group "${groupName}"`);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Validate rules
+  if (!definition.rules) {
+    errors.push('Rules object is required');
+  } else if (typeof definition.rules !== 'object') {
+    errors.push('Rules must be an object');
+  } else {
+    const ruleValidation = validateRules(definition.rules);
+    errors.push(...ruleValidation.errors);
+    warnings.push(...ruleValidation.warnings);
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+  };
+}
+
+/**
+ * Validate rules object
+ */
+function validateRules(rules) {
+  const errors = [];
+  const warnings = [];
+
+  // Check rule type
+  if (!rules.type) {
+    errors.push('Rules must have a type');
+  } else if (!VALID_RULE_TYPES.includes(rules.type)) {
+    errors.push(`Invalid rule type: ${rules.type}. Must be one of: ${VALID_RULE_TYPES.join(', ')}`);
+  }
+
+  // Validate based on rule type
+  switch (rules.type) {
+    case 'entity':
+      validateEntityRule(rules, errors, warnings);
+      break;
+    case 'dok':
+      validateDOKRule(rules, errors, warnings);
+      break;
+    case 'points':
+      validatePointsRule(rules, errors, warnings);
+      break;
+    case 'filtered':
+      validateFilteredRule(rules, errors, warnings);
+      break;
+    case 'counter':
+      validateCounterRule(rules, errors, warnings);
+      break;
+  }
+
+  // Validate filters if present
+  if (rules.filters) {
+    const filterValidation = validateFilters(rules.filters);
+    errors.push(...filterValidation.errors);
+    warnings.push(...filterValidation.warnings);
+  }
+
+  return { errors, warnings };
+}
+
+/**
+ * Validate entity rule
+ */
+function validateEntityRule(rules, errors, warnings) {
+  if (!rules.entityType) {
+    errors.push('Entity rule requires entityType');
+  } else if (!VALID_ENTITY_TYPES.includes(rules.entityType)) {
+    errors.push(`Invalid entityType: ${rules.entityType}. Must be one of: ${VALID_ENTITY_TYPES.join(', ')}`);
+  }
+
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('Entity rule requires a positive target number');
+  }
+
+  if (rules.allowed_bands) {
+    if (!Array.isArray(rules.allowed_bands)) {
+      errors.push('allowed_bands must be an array');
+    } else {
+      for (const band of rules.allowed_bands) {
+        if (!VALID_BANDS.includes(band)) {
+          warnings.push(`Unknown band in allowed_bands: ${band}`);
+        }
+      }
+    }
+  }
+
+  if (rules.satellite_only !== undefined && typeof rules.satellite_only !== 'boolean') {
+    errors.push('satellite_only must be a boolean');
+  }
+
+  if (rules.displayField && typeof rules.displayField !== 'string') {
+    errors.push('displayField must be a string');
+  }
+}
+
+/**
+ * Validate DOK rule
+ */
+function validateDOKRule(rules, errors, warnings) {
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('DOK rule requires a positive target number');
+  }
+
+  if (rules.confirmationType && rules.confirmationType !== 'dcl') {
+    warnings.push('DOK rule confirmationType should be "dcl"');
+  }
+
+  if (rules.displayField && typeof rules.displayField !== 'string') {
+    errors.push('displayField must be a string');
+  }
+}
+
+/**
+ * Validate points rule
+ */
+function validatePointsRule(rules, errors, warnings) {
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('Points rule requires a positive target number');
+  }
+
+  if (!rules.stations || !Array.isArray(rules.stations)) {
+    errors.push('Points rule requires a stations array');
+  } else if (rules.stations.length === 0) {
+    errors.push('Points rule stations array cannot be empty');
+  } else {
+    for (let i = 0; i < rules.stations.length; i++) {
+      const station = rules.stations[i];
+      if (!station.callsign || typeof station.callsign !== 'string') {
+        errors.push(`Station ${i + 1} missing callsign`);
+      }
+      if (typeof station.points !== 'number' || station.points <= 0) {
+        errors.push(`Station ${i + 1} must have positive points value`);
+      }
+    }
+  }
+
+  if (rules.countMode && !VALID_COUNT_MODES.includes(rules.countMode)) {
+    errors.push(`Invalid countMode: ${rules.countMode}. Must be one of: ${VALID_COUNT_MODES.join(', ')}`);
+  }
+}
+
+/**
+ * Validate filtered rule
+ */
+function validateFilteredRule(rules, errors, warnings) {
+  if (!rules.baseRule) {
+    errors.push('Filtered rule requires baseRule');
+  } else {
+    // Recursively validate base rule
+    const baseValidation = validateRules(rules.baseRule);
+    errors.push(...baseValidation.errors);
+    warnings.push(...baseValidation.warnings);
+  }
+
+  if (!rules.filters) {
+    warnings.push('Filtered rule has no filters - baseRule will be used as-is');
+  }
+}
+
+/**
+ * Validate counter rule
+ */
+function validateCounterRule(rules, errors, warnings) {
+  if (!rules.target || typeof rules.target !== 'number' || rules.target <= 0) {
+    errors.push('Counter rule requires a positive target number');
+  }
+
+  if (!rules.countBy) {
+    errors.push('Counter rule requires countBy');
+  } else if (!['qso', 'callsign'].includes(rules.countBy)) {
+    errors.push(`Invalid countBy: ${rules.countBy}. Must be one of: qso, callsign`);
+  }
+
+  if (rules.displayField && typeof rules.displayField !== 'string') {
+    errors.push('displayField must be a string');
+  }
+}
+
+/**
+ * Validate filters object
+ */
+function validateFilters(filters, depth = 0) {
+  const errors = [];
+  const warnings = [];
+
+  if (!filters) {
+    return { errors, warnings };
+  }
+
+  // Prevent infinite recursion
+  if (depth > 10) {
+    errors.push('Filters are too deeply nested (maximum 10 levels)');
+    return { errors, warnings };
+  }
+
+  if (filters.operator && !['AND', 'OR'].includes(filters.operator)) {
+    errors.push(`Invalid filter operator: ${filters.operator}. Must be AND or OR`);
+  }
+
+  if (filters.filters) {
+    if (!Array.isArray(filters.filters)) {
+      errors.push('Filters must be an array');
+    } else {
+      for (const filter of filters.filters) {
+        if (filter.filters) {
+          // Nested filter group
+          const nestedValidation = validateFilters(filter, depth + 1);
+          errors.push(...nestedValidation.errors);
+          warnings.push(...nestedValidation.warnings);
+        } else {
+          // Leaf filter
+          if (!filter.field) {
+            errors.push('Filter missing field');
+          } else if (!VALID_FILTER_FIELDS.includes(filter.field)) {
+            warnings.push(`Unknown filter field: ${filter.field}`);
+          }
+
+          if (!filter.operator) {
+            errors.push('Filter missing operator');
+          } else if (!VALID_FILTER_OPERATORS.includes(filter.operator)) {
+            errors.push(`Invalid filter operator: ${filter.operator}`);
+          }
+
+          if (filter.value === undefined) {
+            errors.push('Filter missing value');
+          }
+
+          if (['in', 'nin'].includes(filter.operator) && !Array.isArray(filter.value)) {
+            errors.push(`Filter operator ${filter.operator} requires an array value`);
+          }
+        }
+      }
+    }
+  }
+
+  return { errors, warnings };
+}
+
+/**
+ * Create a new award definition
+ */
+export async function createAwardDefinition(definition) {
+  // Get all existing definitions for duplicate check
+  const existing = await getAllAwardDefinitions();
+
+  // Validate the definition
+  const validation = validateAwardDefinition(definition, existing);
+  if (!validation.valid) {
+    throw new Error(`Validation failed: ${validation.errors.join('; ')}`);
+  }
+
+  // Create filename from ID
+  const filename = `${definition.id}.json`;
+  const filepath = join(AWARD_DEFINITIONS_DIR, filename);
+
+  // Check if file already exists
+  if (existsSync(filepath)) {
+    throw new Error(`Award file "${filename}" already exists`);
+  }
+
+  // Remove metadata fields before saving
+  const { _filename, _filepath, ...cleanDefinition } = definition;
+
+  // Write to file
+  writeFileSync(filepath, JSON.stringify(cleanDefinition, null, 2), 'utf-8');
+
+  // Clear the cache so new award is immediately available
+  clearAwardCache();
+
+  logger.info('Created award definition', { id: definition.id, filename });
+
+  return {
+    ...cleanDefinition,
+    _filename: filename,
+    _filepath: filepath,
+  };
+}
+
+/**
+ * Update an existing award definition
+ */
+export async function updateAwardDefinition(id, updatedDefinition) {
+  // Get existing definition
+  const existing = await getAwardDefinition(id);
+  if (!existing) {
+    throw new Error(`Award "${id}" not found`);
+  }
+
+  // Ensure ID matches
+  if (updatedDefinition.id && updatedDefinition.id !== id) {
+    throw new Error('Cannot change award ID');
+  }
+
+  // Set the ID from the parameter
+  updatedDefinition.id = id;
+
+  // Get all definitions for validation
+  const allDefinitions = await getAllAwardDefinitions();
+
+  // Validate the updated definition
+  const validation = validateAwardDefinition(updatedDefinition, allDefinitions);
+  if (!validation.valid) {
+    throw new Error(`Validation failed: ${validation.errors.join('; ')}`);
+  }
+
+  // Keep the same filename
+  const filename = existing._filename;
+  const filepath = existing._filepath;
+
+  // Remove metadata fields before saving
+  const { _filename, _filepath, ...cleanDefinition } = updatedDefinition;
+
+  // Write to file
+  writeFileSync(filepath, JSON.stringify(cleanDefinition, null, 2), 'utf-8');
+
+  // Clear the cache so updated award is immediately available
+  clearAwardCache();
+
+  logger.info('Updated award definition', { id, filename });
+
+  return {
+    ...cleanDefinition,
+    _filename: filename,
+    _filepath: filepath,
+  };
+}
+
+/**
+ * Delete an award definition
+ */
+export async function deleteAwardDefinition(id) {
+  const existing = await getAwardDefinition(id);
+  if (!existing) {
+    throw new Error(`Award "${id}" not found`);
+  }
+
+  // Delete the file
+  unlinkSync(existing._filepath);
+
+  // Clear the cache so deleted award is immediately removed
+  clearAwardCache();
+
+  logger.info('Deleted award definition', { id, filename: existing._filename });
+
+  return { success: true, id };
+}
+
+/**
+ * Test award calculation for a user
+ * @param {string} id - Award ID (must exist unless awardDefinition is provided)
+ * @param {number} userId - User ID to test with
+ * @param {Object} awardDefinition - Optional award definition (for testing unsaved awards)
+ */
+export async function testAwardCalculation(id, userId, awardDefinition = null) {
+  // Get award definition - either from parameter or from cache
+  let award = awardDefinition;
+  if (!award) {
+    award = getAwardById(id);
+    if (!award) {
+      throw new Error(`Award "${id}" not found`);
+    }
+  }
+
+  // Calculate progress
+  const progress = await calculateAwardProgress(userId, award);
+
+  // Warn if no matches
+  const warnings = [];
+  if (progress.worked === 0 && progress.confirmed === 0) {
+    warnings.push('No QSOs matched the award criteria. Check filters and band/mode restrictions.');
+  }
+
+  // Get sample entities
+  const sampleEntities = (progress.confirmedEntities || []).slice(0, 10);
+
+  return {
+    award: {
+      id: award.id,
+      name: award.name,
+      description: award.description,
+    },
+    worked: progress.worked,
+    confirmed: progress.confirmed,
+    target: progress.target,
+    percentage: progress.percentage,
+    sampleEntities,
+    warnings,
+  };
+}

src/backend/services/awards.service.js

@@ -1,7 +1,7 @@
 import { db, logger } from '../config.js';
 import { qsos } from '../db/schema/index.js';
 import { eq, and, or, desc, sql } from 'drizzle-orm';
-import { readFileSync } from 'fs';
+import { readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
 import { getCachedAwardProgress, setCachedAwardProgress } from './cache.service.js';
 
@@ -13,27 +13,24 @@ import { getCachedAwardProgress, setCachedAwardProgress } from './cache.service.
 // Load award definitions from files
 const AWARD_DEFINITIONS_DIR = join(process.cwd(), 'award-definitions');
 
+// In-memory cache for award definitions (static, never changes at runtime)
+let cachedAwardDefinitions = null;
+
 /**
- * Load all award definitions
+ * Load all award definitions (cached in memory)
  */
 function loadAwardDefinitions() {
+  // Return cached definitions if available
+  if (cachedAwardDefinitions) {
+    return cachedAwardDefinitions;
+  }
+
   const definitions = [];
 
   try {
-    const files = [
-      'dxcc.json',
-      'dxcc-cw.json',
-      'was.json',
-      'vucc-sat.json',
-      'sat-rs44.json',
-      'special-stations.json',
-      'dld.json',
-      'dld-80m.json',
-      'dld-40m.json',
-      'dld-cw.json',
-      'dld-80m-cw.json',
-      '73-on-73.json',
-    ];
+    // Auto-discover all JSON files in the award-definitions directory
+    const files = readdirSync(AWARD_DEFINITIONS_DIR)
+      .filter(f => f.endsWith('.json'));
 
     for (const file of files) {
       try {
@@ -49,9 +46,102 @@ function loadAwardDefinitions() {
     logger.error('Error loading award definitions', { error: error.message });
   }
 
+  // Sort by award name with numeric prefixes in numerical order
+  definitions.sort((a, b) => {
+    const nameA = a.name || '';
+    const nameB = b.name || '';
+
+    // Extract leading numbers if present
+    const matchA = nameA.match(/^(\d+)/);
+    const matchB = nameB.match(/^(\d+)/);
+
+    // If both start with numbers, compare numerically first
+    if (matchA && matchB) {
+      const numA = parseInt(matchA[1], 10);
+      const numB = parseInt(matchB[1], 10);
+      if (numA !== numB) {
+        return numA - numB;
+      }
+      // If numbers are equal, fall through to alphabetical
+    }
+    // If one starts with a number, it comes first
+    else if (matchA) return -1;
+    else if (matchB) return 1;
+
+    // Otherwise, alphabetical comparison (case-insensitive)
+    return nameA.toLowerCase().localeCompare(nameB.toLowerCase());
+  });
+
+  // Cache the definitions for future calls
+  cachedAwardDefinitions = definitions;
+
   return definitions;
 }
 
+/**
+ * Clear the cached award definitions
+ * Call this after creating, updating, or deleting award definitions
+ */
+export function clearAwardCache() {
+  cachedAwardDefinitions = null;
+  logger.info('Award cache cleared');
+}
+
+/**
+ * Calculate achievement progress for an award
+ * @param {number} currentCount - Current confirmed count (entities or points)
+ * @param {Array} achievements - Array of achievement definitions
+ * @returns {Object|null} Achievement progress info or null if no achievements defined
+ */
+function calculateAchievementProgress(currentCount, achievements) {
+  if (!achievements || achievements.length === 0) {
+    return null;
+  }
+
+  // Sort achievements by threshold
+  const sorted = [...achievements].sort((a, b) => a.threshold - b.threshold);
+
+  // Find earned achievements, current level, and next level
+  const earned = [];
+  let currentLevel = null;
+  let nextLevel = null;
+
+  for (let i = 0; i < sorted.length; i++) {
+    const achievement = sorted[i];
+    if (currentCount >= achievement.threshold) {
+      earned.push(achievement);
+      currentLevel = achievement;
+    } else {
+      nextLevel = achievement;
+      break;
+    }
+  }
+
+  // Calculate progress toward next level
+  let progressPercent = 100;
+  let progressCurrent = currentCount;
+  let progressNeeded = 0;
+
+  if (nextLevel) {
+    const prevThreshold = currentLevel ? currentLevel.threshold : 0;
+    const range = nextLevel.threshold - prevThreshold;
+    const progressInLevel = currentCount - prevThreshold;
+    progressPercent = Math.round((progressInLevel / range) * 100);
+    progressNeeded = nextLevel.threshold - currentCount;
+  }
+
+  return {
+    earned,
+    currentLevel,
+    nextLevel,
+    progressPercent,
+    progressCurrent,
+    progressNeeded,
+    totalAchievements: sorted.length,
+    earnedCount: earned.length,
+  };
+}
+
 /**
  * Get all available awards
  */
@@ -65,9 +155,36 @@ export async function getAllAwards() {
     caption: def.caption,
     category: def.category,
     rules: def.rules,
+    modeGroups: def.modeGroups || null,
+    achievements: def.achievements || null,
   }));
 }
 
+/**
+ * Get a single award by ID
+ * @param {string} awardId - Award ID
+ * @returns {Object|null} Award definition or null if not found
+ */
+export function getAwardById(awardId) {
+  const definitions = loadAwardDefinitions();
+  const award = definitions.find((def) => def.id === awardId);
+
+  if (!award) {
+    return null;
+  }
+
+  return {
+    id: award.id,
+    name: award.name,
+    description: award.description,
+    caption: award.caption,
+    category: award.category,
+    rules: award.rules,
+    modeGroups: award.modeGroups || null,
+    achievements: award.achievements || null,
+  };
+}
+
 /**
  * Calculate award progress for a user
  * @param {number} userId - User ID
@@ -140,11 +257,27 @@ export async function calculateAwardProgress(userId, award, options = {}) {
     logger.debug('QSOs after filters', { count: filteredQSOs.length });
   }
 
+  // Apply allowed_bands filter if present
+  let finalQSOs = filteredQSOs;
+  if (rules.allowed_bands && Array.isArray(rules.allowed_bands) && rules.allowed_bands.length > 0) {
+    finalQSOs = filteredQSOs.filter(qso => {
+      const band = qso.band;
+      return rules.allowed_bands.includes(band);
+    });
+    logger.debug('QSOs after allowed_bands filter', { count: finalQSOs.length });
+  }
+
+  // Apply satellite_only filter if present
+  if (rules.satellite_only) {
+    finalQSOs = finalQSOs.filter(qso => qso.satName);
+    logger.debug('QSOs after satellite_only filter', { count: finalQSOs.length });
+  }
+
   // Calculate worked and confirmed entities
   const workedEntities = new Set();
   const confirmedEntities = new Set();
 
-  for (const qso of filteredQSOs) {
+  for (const qso of finalQSOs) {
     const entity = getEntityValue(qso, rules.entityType);
 
     if (entity) {
@@ -158,7 +291,7 @@ export async function calculateAwardProgress(userId, award, options = {}) {
     }
   }
 
-  return {
+  const result = {
     worked: workedEntities.size,
     confirmed: confirmedEntities.size,
     target: rules.target || 0,
@@ -166,6 +299,13 @@ export async function calculateAwardProgress(userId, award, options = {}) {
     workedEntities: Array.from(workedEntities),
     confirmedEntities: Array.from(confirmedEntities),
   };
+
+  // Add achievement progress if award has achievements defined
+  if (award.achievements && award.achievements.length > 0) {
+    result.achievements = calculateAchievementProgress(confirmedEntities.size, award.achievements);
+  }
+
+  return result;
 }
 
 /**
@@ -199,7 +339,7 @@ async function calculateDOKAwardProgress(userId, award, options = {}) {
   }
 
   // Track unique (DOK, band, mode) combinations
-  const dokCombinations = new Map(); // Key: "DOK/band/mode" -> detail object
+  const dokCombinations = new Map(); // Key: "DOK/band/mode" -> detail object with qsos array
 
   for (const qso of filteredQSOs) {
     const dok = qso.darcDok;
@@ -212,29 +352,36 @@ async function calculateDOKAwardProgress(userId, award, options = {}) {
     // Initialize combination if not exists
     if (!dokCombinations.has(combinationKey)) {
       dokCombinations.set(combinationKey, {
-        qsoId: qso.id,
         entity: dok,
         entityId: null,
         entityName: dok,
         band,
         mode,
-        callsign: qso.callsign,
         worked: false,
         confirmed: false,
-        qsoDate: qso.qsoDate,
-        dclQslRdate: null,
+        qsos: [], // Array of confirmed QSOs for this slot
       });
     }
 
     const detail = dokCombinations.get(combinationKey);
     detail.worked = true;
 
-    // Check for DCL confirmation
+    // Check for DCL confirmation and add to qsos array
     if (qso.dclQslRstatus === 'Y') {
       if (!detail.confirmed) {
         detail.confirmed = true;
-        detail.dclQslRdate = qso.dclQslRdate;
       }
+      // Add this confirmed QSO to the qsos array
+      detail.qsos.push({
+        qsoId: qso.id,
+        callsign: qso.callsign,
+        mode: qso.mode,
+        qsoDate: qso.qsoDate,
+        timeOn: qso.timeOn,
+        band: qso.band,
+        satName: qso.satName,
+        confirmed: true,
+      });
     }
   }
 
@@ -279,6 +426,11 @@ async function calculateDOKAwardProgress(userId, award, options = {}) {
     result.confirmed = result.entities.filter((e) => e.confirmed).length;
   }
 
+  // Add achievement progress if award has achievements defined
+  if (award.achievements && award.achievements.length > 0) {
+    result.achievements = calculateAchievementProgress(confirmedDOKs.size, award.achievements);
+  }
+
   return result;
 }
 
@@ -339,15 +491,13 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
 
       if (!combinationMap.has(combinationKey)) {
         combinationMap.set(combinationKey, {
-          qsoId: qso.id,
           callsign,
           band,
           mode,
           points,
           worked: true,
           confirmed: false,
-          qsoDate: qso.qsoDate,
-          lotwQslRdate: null,
+          qsos: [], // Array of confirmed QSOs for this slot
         });
       }
 
@@ -355,8 +505,18 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
         const detail = combinationMap.get(combinationKey);
         if (!detail.confirmed) {
           detail.confirmed = true;
-          detail.lotwQslRdate = qso.lotwQslRdate;
         }
+        // Add this confirmed QSO to the qsos array
+        detail.qsos.push({
+          qsoId: qso.id,
+          callsign: qso.callsign,
+          mode: qso.mode,
+          qsoDate: qso.qsoDate,
+          timeOn: qso.timeOn,
+          band: qso.band,
+          satName: qso.satName,
+          confirmed: true,
+        });
       }
     }
 
@@ -378,15 +538,11 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
 
       if (!stationMap.has(callsign)) {
         stationMap.set(callsign, {
-          qsoId: qso.id,
           callsign,
           points,
           worked: true,
           confirmed: false,
-          qsoDate: qso.qsoDate,
-          band: qso.band,
-          mode: qso.mode,
-          lotwQslRdate: null,
+          qsos: [], // Array of confirmed QSOs for this station
         });
       }
 
@@ -394,8 +550,18 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
         const detail = stationMap.get(callsign);
         if (!detail.confirmed) {
           detail.confirmed = true;
-          detail.lotwQslRdate = qso.lotwQslRdate;
         }
+        // Add this confirmed QSO to the qsos array
+        detail.qsos.push({
+          qsoId: qso.id,
+          callsign: qso.callsign,
+          mode: qso.mode,
+          qsoDate: qso.qsoDate,
+          timeOn: qso.timeOn,
+          band: qso.band,
+          satName: qso.satName,
+          confirmed: true,
+        });
       }
     }
 
@@ -415,6 +581,7 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
 
       if (qso.lotwQslRstatus === 'Y') {
         totalPoints += points;
+        // For perQso mode, each QSO is its own slot with a qsos array containing just itself
         stationDetails.push({
           qsoId: qso.id,
           callsign,
@@ -424,7 +591,16 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
           qsoDate: qso.qsoDate,
           band: qso.band,
           mode: qso.mode,
-          lotwQslRdate: qso.lotwQslRdate,
+          qsos: [{
+            qsoId: qso.id,
+            callsign: qso.callsign,
+            mode: qso.mode,
+            qsoDate: qso.qsoDate,
+            timeOn: qso.timeOn,
+            band: qso.band,
+            satName: qso.satName,
+            confirmed: true,
+          }],
         });
       }
     }
@@ -465,6 +641,7 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
           mode: detail.mode,
           callsign: detail.callsign,
           lotwQslRdate: detail.lotwQslRdate,
+          qsos: detail.qsos || [], // All confirmed QSOs for this slot
         };
       } else if (countMode === 'perStation') {
         return {
@@ -480,6 +657,7 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
           mode: detail.mode,
           callsign: detail.callsign,
           lotwQslRdate: detail.lotwQslRdate,
+          qsos: detail.qsos || [], // All confirmed QSOs for this station
         };
       } else {
         return {
@@ -495,6 +673,7 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
           mode: detail.mode,
           callsign: detail.callsign,
           lotwQslRdate: detail.lotwQslRdate,
+          qsos: detail.qsos || [], // All confirmed QSOs for this slot (just this one QSO)
         };
       }
     });
@@ -513,6 +692,12 @@ async function calculatePointsAwardProgress(userId, award, options = {}) {
     result.stationDetails = stationDetails;
   }
 
+  // Add achievement progress if award has achievements defined
+  // For point-based awards, use totalPoints instead of confirmed count
+  if (award.achievements && award.achievements.length > 0) {
+    result.achievements = calculateAchievementProgress(totalPoints, award.achievements);
+  }
+
   return result;
 }
 
@@ -675,48 +860,77 @@ export async function getAwardEntityBreakdown(userId, awardId) {
   // Apply filters
   const filteredQSOs = applyFilters(allQSOs, rules.filters);
 
-  // Group by entity
-  const entityMap = new Map();
+  // Apply allowed_bands filter if present
+  let finalQSOs = filteredQSOs;
+  if (rules.allowed_bands && Array.isArray(rules.allowed_bands) && rules.allowed_bands.length > 0) {
+    finalQSOs = filteredQSOs.filter(qso => {
+      const band = qso.band;
+      return rules.allowed_bands.includes(band);
+    });
+  }
 
-  for (const qso of filteredQSOs) {
+  // Apply satellite_only filter if present
+  if (rules.satellite_only) {
+    finalQSOs = finalQSOs.filter(qso => qso.satName);
+  }
+
+  // Group by (entity, band, mode) slot for entity awards
+  // This allows showing multiple QSOs per entity on different bands/modes
+  const slotMap = new Map(); // Key: "entity/band/mode" -> slot object
+
+  for (const qso of finalQSOs) {
     const entity = getEntityValue(qso, rules.entityType);
 
     if (!entity) continue;
 
-    if (!entityMap.has(entity)) {
-      // Determine what to display as the entity name
-      let displayName = String(entity);
-      if (rules.displayField) {
-        let rawValue = qso[rules.displayField];
-        if (rules.displayField === 'grid' && rawValue && rawValue.length > 4) {
-          rawValue = rawValue.substring(0, 4);
-        }
-        displayName = String(rawValue || entity);
-      } else {
-        displayName = qso.entity || qso.state || qso.grid || qso.callsign || String(entity);
-      }
+    const band = qso.band || 'Unknown';
+    const mode = qso.mode || 'Unknown';
+    const slotKey = `${entity}/${band}/${mode}`;
 
-      entityMap.set(entity, {
-        qsoId: qso.id,
+    // Determine what to display as the entity name (only on first create)
+    let displayName = String(entity);
+    if (rules.displayField) {
+      let rawValue = qso[rules.displayField];
+      if (rules.displayField === 'grid' && rawValue && rawValue.length > 4) {
+        rawValue = rawValue.substring(0, 4);
+      }
+      displayName = String(rawValue || entity);
+    } else {
+      displayName = qso.entity || qso.state || qso.grid || qso.callsign || String(entity);
+    }
+
+    if (!slotMap.has(slotKey)) {
+      slotMap.set(slotKey, {
         entity,
         entityId: qso.entityId,
         entityName: displayName,
+        band,
+        mode,
         worked: false,
         confirmed: false,
-        qsoDate: qso.qsoDate,
-        band: qso.band,
-        mode: qso.mode,
-        callsign: qso.callsign,
-        satName: qso.satName,
+        qsos: [], // Array of confirmed QSOs for this slot
       });
     }
 
-    const entityData = entityMap.get(entity);
-    entityData.worked = true;
+    const slotData = slotMap.get(slotKey);
+    slotData.worked = true;
 
+    // Check for LoTW confirmation and add to qsos array
     if (qso.lotwQslRstatus === 'Y') {
-      entityData.confirmed = true;
-      entityData.lotwQslRdate = qso.lotwQslRdate;
+      if (!slotData.confirmed) {
+        slotData.confirmed = true;
+      }
+      // Add this confirmed QSO to the qsos array
+      slotData.qsos.push({
+        qsoId: qso.id,
+        callsign: qso.callsign,
+        mode: qso.mode,
+        qsoDate: qso.qsoDate,
+        timeOn: qso.timeOn,
+        band: qso.band,
+        satName: qso.satName,
+        confirmed: true,
+      });
     }
   }
 
@@ -728,8 +942,8 @@ export async function getAwardEntityBreakdown(userId, awardId) {
       caption: award.caption,
       target: rules.target || 0,
     },
-    entities: Array.from(entityMap.values()),
-    total: entityMap.size,
-    confirmed: Array.from(entityMap.values()).filter((e) => e.confirmed).length,
+    entities: Array.from(slotMap.values()),
+    total: slotMap.size,
+    confirmed: Array.from(slotMap.values()).filter((e) => e.confirmed).length,
   };
 }

src/backend/services/cache.service.js

@@ -86,32 +86,6 @@ export function clearAllCache() {
   return size;
 }
 
-/**
- * Get cache statistics (for monitoring/debugging)
- * @returns {object} Cache stats
- */
-export function getCacheStats() {
-  const now = Date.now();
-  let expired = 0;
-  let valid = 0;
-
-  for (const [, value] of awardCache) {
-    const age = now - value.timestamp;
-    if (age > CACHE_TTL) {
-      expired++;
-    } else {
-      valid++;
-    }
-  }
-
-  return {
-    total: awardCache.size,
-    valid,
-    expired,
-    ttl: CACHE_TTL
-  };
-}
-
 /**
  * Clean up expired cache entries (maintenance function)
  * Can be called periodically to free memory

src/backend/services/dcl.service.js

@@ -4,6 +4,7 @@ import { max, sql, eq, and, desc } from 'drizzle-orm';
 import { updateJobProgress } from './job-queue.service.js';
 import { parseDCLResponse, normalizeBand, normalizeMode } from '../utils/adif-parser.js';
 import { invalidateUserCache, invalidateStatsCache } from './cache.service.js';
+import { yieldToEventLoop, getQSOKey } from '../utils/sync-helpers.js';
 
 /**
  * DCL (DARC Community Logbook) Service
@@ -122,17 +123,6 @@ export async function fetchQSOsFromDCL(dclApiKey, sinceDate = null) {
   }
 }
 
-/**
- * Parse DCL API response from JSON
- * Can be used for testing with example payloads
- *
- * @param {Object} jsonResponse - JSON response in DCL format
- * @returns {Array} Array of parsed QSO records
- */
-export function parseDCLJSONResponse(jsonResponse) {
-  return parseDCLResponse(jsonResponse);
-}
-
 /**
  * Convert DCL ADIF QSO to database format
  * @param {Object} adifQSO - Parsed ADIF QSO record
@@ -169,21 +159,6 @@ function convertQSODatabaseFormat(adifQSO, userId) {
   };
 }
 
-/**
- * Yield to event loop to allow other requests to be processed
- * This prevents blocking the server during long-running sync operations
- */
-function yieldToEventLoop() {
-  return new Promise(resolve => setImmediate(resolve));
-}
-
-/**
- * Get QSO key for duplicate detection
- */
-function getQSOKey(qso) {
-  return `${qso.callsign}|${qso.qsoDate}|${qso.timeOn}|${qso.band}|${qso.mode}`;
-}
-
 /**
  * Sync QSOs from DCL to database (optimized with batch operations)
  * Updates existing QSOs with DCL confirmation data

src/backend/services/lotw.service.js

@@ -1,10 +1,11 @@
 import { db, logger } from '../config.js';
-import { qsos, qsoChanges } from '../db/schema/index.js';
+import { qsos, qsoChanges, syncJobs, awardProgress } from '../db/schema/index.js';
 import { max, sql, eq, and, or, desc, like } from 'drizzle-orm';
 import { updateJobProgress } from './job-queue.service.js';
 import { parseADIF, normalizeBand, normalizeMode } from '../utils/adif-parser.js';
 import { invalidateUserCache, getCachedStats, setCachedStats, invalidateStatsCache } from './cache.service.js';
-import { trackQueryPerformance, getPerformanceSummary, resetPerformanceMetrics } from './performance.service.js';
+import { trackQueryPerformance } from './performance.service.js';
+import { yieldToEventLoop, getQSOKey } from '../utils/sync-helpers.js';
 
 /**
  * LoTW (Logbook of the World) Service
@@ -81,6 +82,7 @@ const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
  * Fetch QSOs from LoTW with retry support
  */
 async function fetchQSOsFromLoTW(lotwUsername, lotwPassword, sinceDate = null) {
+  const startTime = Date.now();
   const url = 'https://lotw.arrl.org/lotwuser/lotwreport.adi';
 
   const params = new URLSearchParams({
@@ -176,7 +178,7 @@ async function fetchQSOsFromLoTW(lotwUsername, lotwPassword, sinceDate = null) {
     }
   }
 
-  const totalTime = Math.round((Date.now() - Date.now()) / 1000);
+  const totalTime = Math.round((Date.now() - startTime) / 1000);
   return {
     error: `LoTW sync failed: Report not ready after ${MAX_RETRIES} attempts (${totalTime}s). LoTW may be experiencing high load. Please try again later.`
   };
@@ -210,21 +212,6 @@ function convertQSODatabaseFormat(adifQSO, userId) {
   };
 }
 
-/**
- * Yield to event loop to allow other requests to be processed
- * This prevents blocking the server during long-running sync operations
- */
-function yieldToEventLoop() {
-  return new Promise(resolve => setImmediate(resolve));
-}
-
-/**
- * Get QSO key for duplicate detection
- */
-function getQSOKey(qso) {
-  return `${qso.callsign}|${qso.qsoDate}|${qso.timeOn}|${qso.band}|${qso.mode}`;
-}
-
 /**
  * Sync QSOs from LoTW to database (optimized with batch operations)
  * @param {number} userId - User ID
@@ -609,10 +596,58 @@ export async function getLastLoTWQSLDate(userId) {
 
 /**
  * Delete all QSOs for a user
+ * Also deletes related qso_changes records to satisfy foreign key constraints
  */
 export async function deleteQSOs(userId) {
+  logger.debug('Deleting all QSOs for user', { userId });
+
+  // Step 1: Delete qso_changes that reference QSOs for this user
+  // Need to use a subquery since qso_changes doesn't have userId directly
+  const qsoIdsResult = await db
+    .select({ id: qsos.id })
+    .from(qsos)
+    .where(eq(qsos.userId, userId));
+
+  const qsoIds = qsoIdsResult.map(r => r.id);
+
+  let deletedChanges = 0;
+  if (qsoIds.length > 0) {
+    // Delete qso_changes where qsoId is in the list of QSO IDs
+    const changesResult = await db
+      .delete(qsoChanges)
+      .where(sql`${qsoChanges.qsoId} IN ${sql.raw(`(${qsoIds.join(',')})`)}`);
+
+    deletedChanges = changesResult.changes || changesResult || 0;
+    logger.debug('Deleted qso_changes', { count: deletedChanges });
+  }
+
+  // Step 2: Delete the QSOs
   const result = await db.delete(qsos).where(eq(qsos.userId, userId));
-  return result;
+  logger.debug('Delete result', { result, type: typeof result, keys: Object.keys(result || {}) });
+
+  // Drizzle with SQLite/bun:sqlite returns various formats depending on driver
+  let count = 0;
+  if (result) {
+    if (typeof result === 'number') {
+      count = result;
+    } else if (result.changes !== undefined) {
+      count = result.changes;
+    } else if (result.rows !== undefined) {
+      count = result.rows;
+    } else if (result.meta?.changes !== undefined) {
+      count = result.meta.changes;
+    } else if (result.meta?.rows !== undefined) {
+      count = result.meta.rows;
+    }
+  }
+
+  logger.info('Deleted QSOs', { userId, count, deletedChanges });
+
+  // Invalidate caches for this user
+  await invalidateStatsCache(userId);
+  await invalidateUserCache(userId);
+
+  return count;
 }
 
 /**

src/backend/services/scheduler.service.js

@@ -0,0 +1,234 @@
+import { logger } from '../config.js';
+import {
+  getPendingSyncUsers,
+  updateSyncTimestamps,
+} from './auto-sync.service.js';
+import {
+  enqueueJob,
+  getUserActiveJob,
+} from './job-queue.service.js';
+import { getUserById } from './auth.service.js';
+
+/**
+ * Auto-Sync Scheduler Service
+ * Manages automatic synchronization of DCL and LoTW data
+ * Runs every minute to check for due syncs and enqueues jobs
+ */
+
+// Scheduler state
+let schedulerInterval = null;
+let isRunning = false;
+let isShuttingDown = false;
+
+// Scheduler configuration
+const SCHEDULER_TICK_INTERVAL_MS = 60 * 1000; // 1 minute
+const INITIAL_DELAY_MS = 5000; // 5 seconds after server start
+
+// Allow faster tick interval for testing (set via environment variable)
+const TEST_MODE = process.env.SCHEDULER_TEST_MODE === 'true';
+const TEST_TICK_INTERVAL_MS = 10 * 1000; // 10 seconds in test mode
+
+/**
+ * Get scheduler status
+ * @returns {Object} Scheduler status
+ */
+export function getSchedulerStatus() {
+  return {
+    isRunning,
+    isShuttingDown,
+    tickIntervalMs: TEST_MODE ? TEST_TICK_INTERVAL_MS : SCHEDULER_TICK_INTERVAL_MS,
+    activeInterval: !!schedulerInterval,
+    testMode: TEST_MODE,
+  };
+}
+
+/**
+ * Process pending syncs for a specific service
+ * @param {string} service - 'lotw' or 'dcl'
+ */
+async function processServiceSyncs(service) {
+  try {
+    const pendingUsers = await getPendingSyncUsers(service);
+
+    if (pendingUsers.length === 0) {
+      logger.debug('No pending syncs', { service });
+      return;
+    }
+
+    logger.info('Processing pending syncs', {
+      service,
+      count: pendingUsers.length,
+    });
+
+    for (const user of pendingUsers) {
+      if (isShuttingDown) {
+        logger.info('Scheduler shutting down, skipping pending sync', {
+          service,
+          userId: user.userId,
+        });
+        break;
+      }
+
+      try {
+        // Check if there's already an active job for this user and service
+        const activeJob = await getUserActiveJob(user.userId, `${service}_sync`);
+
+        if (activeJob) {
+          logger.debug('User already has active job, skipping', {
+            service,
+            userId: user.userId,
+            activeJobId: activeJob.id,
+          });
+
+          // Update the next sync time to try again later
+          // This prevents continuous checking while a job is running
+          await updateSyncTimestamps(user.userId, service, new Date());
+          continue;
+        }
+
+        // Enqueue the sync job
+        logger.info('Enqueuing auto-sync job', {
+          service,
+          userId: user.userId,
+        });
+
+        const result = await enqueueJob(user.userId, `${service}_sync`);
+
+        if (result.success) {
+          // Update timestamps immediately on successful enqueue
+          await updateSyncTimestamps(user.userId, service, new Date());
+        } else {
+          logger.warn('Failed to enqueue auto-sync job', {
+            service,
+            userId: user.userId,
+            reason: result.error,
+          });
+        }
+      } catch (error) {
+        logger.error('Error processing user sync', {
+          service,
+          userId: user.userId,
+          error: error.message,
+        });
+      }
+    }
+  } catch (error) {
+    logger.error('Error processing service syncs', {
+      service,
+      error: error.message,
+    });
+  }
+}
+
+/**
+ * Main scheduler tick function
+ * Checks for pending LoTW and DCL syncs and processes them
+ */
+async function schedulerTick() {
+  if (isShuttingDown) {
+    logger.debug('Scheduler shutdown in progress, skipping tick');
+    return;
+  }
+
+  try {
+    logger.debug('Scheduler tick started');
+
+    // Process LoTW syncs
+    await processServiceSyncs('lotw');
+
+    // Process DCL syncs
+    await processServiceSyncs('dcl');
+
+    logger.debug('Scheduler tick completed');
+  } catch (error) {
+    logger.error('Scheduler tick error', {
+      error: error.message,
+      stack: error.stack,
+    });
+  }
+}
+
+/**
+ * Start the scheduler
+ * Begins periodic checks for pending syncs
+ */
+export function startScheduler() {
+  if (isRunning) {
+    logger.warn('Scheduler already running');
+    return;
+  }
+
+  // Check if scheduler is disabled via environment variable
+  if (process.env.DISABLE_SCHEDULER === 'true') {
+    logger.info('Scheduler disabled via DISABLE_SCHEDULER environment variable');
+    return;
+  }
+
+  isRunning = true;
+  isShuttingDown = false;
+
+  const tickInterval = TEST_MODE ? TEST_TICK_INTERVAL_MS : SCHEDULER_TICK_INTERVAL_MS;
+
+  // Initial delay to allow server to fully start
+  logger.info('Scheduler starting, initial tick in 5 seconds', {
+    testMode: TEST_MODE,
+    tickIntervalMs: tickInterval,
+  });
+
+  // Schedule first tick
+  setTimeout(() => {
+    if (!isShuttingDown) {
+      schedulerTick();
+
+      // Set up recurring interval
+      schedulerInterval = setInterval(() => {
+        if (!isShuttingDown) {
+          schedulerTick();
+        }
+      }, tickInterval);
+
+      logger.info('Scheduler started', {
+        tickIntervalMs: tickInterval,
+        testMode: TEST_MODE,
+      });
+    }
+  }, INITIAL_DELAY_MS);
+}
+
+/**
+ * Stop the scheduler gracefully
+ * Waits for current tick to complete before stopping
+ */
+export async function stopScheduler() {
+  if (!isRunning) {
+    logger.debug('Scheduler not running');
+    return;
+  }
+
+  logger.info('Stopping scheduler...');
+  isShuttingDown = true;
+
+  // Clear the interval
+  if (schedulerInterval) {
+    clearInterval(schedulerInterval);
+    schedulerInterval = null;
+  }
+
+  // Wait a moment for any in-progress tick to complete
+  await new Promise(resolve => setTimeout(resolve, 100));
+
+  isRunning = false;
+  logger.info('Scheduler stopped');
+}
+
+/**
+ * Trigger an immediate scheduler tick (for testing or manual sync)
+ */
+export async function triggerSchedulerTick() {
+  if (!isRunning) {
+    throw new Error('Scheduler is not running');
+  }
+
+  logger.info('Manual scheduler tick triggered');
+  await schedulerTick();
+}

src/backend/utils/sync-helpers.js

@@ -0,0 +1,23 @@
+/**
+ * Sync Helper Utilities
+ *
+ * Shared utilities for LoTW and DCL sync operations
+ */
+
+/**
+ * Yield to event loop to allow other requests to be processed
+ * This prevents blocking the server during long-running sync operations
+ * @returns {Promise<void>}
+ */
+export function yieldToEventLoop() {
+  return new Promise(resolve => setImmediate(resolve));
+}
+
+/**
+ * Get QSO key for duplicate detection
+ * @param {object} qso - QSO object
+ * @returns {string} Unique key for the QSO
+ */
+export function getQSOKey(qso) {
+  return `${qso.callsign}|${qso.qsoDate}|${qso.timeOn}|${qso.band}|${qso.mode}`;
+}

src/frontend/src/app.css

@@ -0,0 +1,186 @@
+/* Quickawards Theme System - CSS Variables */
+
+/* Light Mode (default) */
+:root, [data-theme="light"] {
+  /* Backgrounds */
+  --bg-body: #f5f5f5;
+  --bg-card: #ffffff;
+  --bg-navbar: #2c3e50;
+  --bg-footer: #2c3e50;
+  --bg-input: #ffffff;
+  --bg-hover: rgba(255, 255, 255, 0.1);
+  --bg-secondary: #f8f9fa;
+  --bg-tertiary: #e9ecef;
+
+  /* Text */
+  --text-primary: #333333;
+  --text-secondary: #666666;
+  --text-muted: #999999;
+  --text-inverted: #ffffff;
+  --text-link: #4a90e2;
+
+  /* Primary colors */
+  --color-primary: #4a90e2;
+  --color-primary-hover: #357abd;
+  --color-primary-light: rgba(74, 144, 226, 0.1);
+
+  /* Secondary colors */
+  --color-secondary: #6c757d;
+  --color-secondary-hover: #5a6268;
+
+  /* Semantic colors */
+  --color-success: #065f46;
+  --color-success-bg: #d1fae5;
+  --color-success-light: #10b981;
+
+  --color-warning: #ffc107;
+  --color-warning-hover: #e0a800;
+  --color-warning-bg: #fff3cd;
+  --color-warning-text: #856404;
+
+  --color-error: #dc3545;
+  --color-error-hover: #c82333;
+  --color-error-bg: #fee2e2;
+  --color-error-text: #991b1b;
+
+  --color-info: #1e40af;
+  --color-info-bg: #dbeafe;
+  --color-info-text: #1e40af;
+
+  /* Badge/status colors */
+  --badge-pending-bg: #fef3c7;
+  --badge-pending-text: #92400e;
+  --badge-running-bg: #dbeafe;
+  --badge-running-text: #1e40af;
+  --badge-completed-bg: #d1fae5;
+  --badge-completed-text: #065f46;
+  --badge-failed-bg: #fee2e2;
+  --badge-failed-text: #991b1b;
+  --badge-cancelled-bg: #f3e8ff;
+  --badge-cancelled-text: #6b21a8;
+  --badge-purple-bg: #8b5cf6;
+  --badge-purple-text: #ffffff;
+
+  /* Borders */
+  --border-color: #e0e0e0;
+  --border-color-light: #e9ecef;
+  --border-radius: 4px;
+  --border-radius-lg: 8px;
+  --border-radius-pill: 12px;
+
+  /* Shadows */
+  --shadow-sm: 0 1px 3px rgba(0, 0, 0, 0.1);
+  --shadow-md: 0 2px 8px rgba(0, 0, 0, 0.12);
+
+  /* Focus */
+  --focus-ring: 0 0 0 2px rgba(74, 144, 226, 0.2);
+
+  /* Logout button */
+  --color-logout: #ff6b6b;
+  --color-logout-hover: #ff5252;
+  --color-logout-bg: rgba(255, 107, 107, 0.1);
+
+  /* Admin link */
+  --color-admin-bg: #ffc107;
+  --color-admin-hover: #e0a800;
+  --color-admin-text: #000000;
+
+  /* Impersonation banner */
+  --impersonation-bg: #fff3cd;
+  --impersonation-border: #ffc107;
+  --impersonation-text: #856404;
+
+  /* Gradient colors */
+  --gradient-primary: linear-gradient(90deg, #4a90e2 0%, #357abd 100%);
+  --gradient-purple: linear-gradient(90deg, #8b5cf6, #a78bfa);
+  --gradient-scheduled: linear-gradient(to right, #f8f7ff, white);
+}
+
+/* Dark Mode */
+[data-theme="dark"] {
+  /* Backgrounds */
+  --bg-body: #1a1a1a;
+  --bg-card: #2d2d2d;
+  --bg-navbar: #1f2937;
+  --bg-footer: #1f2937;
+  --bg-input: #2d2d2d;
+  --bg-hover: rgba(255, 255, 255, 0.1);
+  --bg-secondary: #252525;
+  --bg-tertiary: #333333;
+
+  /* Text */
+  --text-primary: #e0e0e0;
+  --text-secondary: #a0a0a0;
+  --text-muted: #707070;
+  --text-inverted: #ffffff;
+  --text-link: #5ba3f5;
+
+  /* Primary colors */
+  --color-primary: #5ba3f5;
+  --color-primary-hover: #4a8ae4;
+  --color-primary-light: rgba(91, 163, 245, 0.15);
+
+  /* Secondary colors */
+  --color-secondary: #6b7280;
+  --color-secondary-hover: #4b5563;
+
+  /* Semantic colors */
+  --color-success: #10b981;
+  --color-success-bg: #064e3b;
+  --color-success-light: #10b981;
+
+  --color-warning: #fbbf24;
+  --color-warning-hover: #f59e0b;
+  --color-warning-bg: #451a03;
+  --color-warning-text: #fef3c7;
+
+  --color-error: #f87171;
+  --color-error-hover: #ef4444;
+  --color-error-bg: #7f1d1d;
+  --color-error-text: #fecaca;
+
+  --color-info: #3b82f6;
+  --color-info-bg: #1e3a8a;
+  --color-info-text: #93c5fd;
+
+  /* Badge/status colors */
+  --badge-pending-bg: #451a03;
+  --badge-pending-text: #fef3c7;
+  --badge-running-bg: #1e3a8a;
+  --badge-running-text: #93c5fd;
+  --badge-completed-bg: #064e3b;
+  --badge-completed-text: #6ee7b7;
+  --badge-failed-bg: #7f1d1d;
+  --badge-failed-text: #fecaca;
+  --badge-cancelled-bg: #3b0a4d;
+  --badge-cancelled-text: #d8b4fe;
+  --badge-purple-bg: #7c3aed;
+  --badge-purple-text: #ffffff;
+
+  /* Borders */
+  --border-color: #404040;
+  --border-color-light: #4a4a4a;
+
+  /* Focus */
+  --focus-ring: 0 0 0 2px rgba(91, 163, 245, 0.2);
+
+  /* Logout button */
+  --color-logout: #f87171;
+  --color-logout-hover: #ef4444;
+  --color-logout-bg: rgba(248, 113, 113, 0.15);
+
+  /* Admin link */
+  --color-admin-bg: #f59e0b;
+  --color-admin-hover: #d97706;
+  --color-admin-text: #000000;
+
+  /* Impersonation banner */
+  --impersonation-bg: #451a03;
+  --impersonation-border: #f59e0b;
+  --impersonation-text: #fef3c7;
+
+  /* Gradient colors */
+  --gradient-primary: linear-gradient(90deg, #5ba3f5 0%, #4a8ae4 100%);
+  --gradient-purple: linear-gradient(90deg, #7c3aed, #8b5cf6);
+  --gradient-scheduled: linear-gradient(to right, #2d1f3d, #2d2d2d);
+}

src/frontend/src/app.html

@@ -4,6 +4,14 @@
 		<meta charset="utf-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1" />
 		%sveltekit.head%
+		<script>
+			// Prevent flash of unstyled content (FOUC)
+			(function() {
+				const theme = localStorage.getItem('theme') || 'light';
+				const isDark = theme === 'dark' || (theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+				document.documentElement.setAttribute('data-theme', isDark ? 'dark' : 'light');
+			})();
+		</script>
 	</head>
 	<body data-sveltekit-preload-data="hover">
 		<div style="display: contents">%sveltekit.body%</div>

src/frontend/src/lib/api.js

@@ -95,9 +95,9 @@ export const adminAPI = {
 
   getUserDetails: (userId) => apiRequest(`/admin/users/${userId}`),
 
-  updateUserRole: (userId, isAdmin) => apiRequest(`/admin/users/${userId}/role`, {
+  updateUserRole: (userId, role) => apiRequest(`/admin/users/${userId}/role`, {
     method: 'POST',
-    body: JSON.stringify({ isAdmin }),
+    body: JSON.stringify({ role }),
   }),
 
   deleteUser: (userId) => apiRequest(`/admin/users/${userId}`, {
@@ -118,3 +118,41 @@ export const adminAPI = {
 
   getMyActions: (limit = 50, offset = 0) => apiRequest(`/admin/actions/my?limit=${limit}&offset=${offset}`),
 };
+
+// Auto-Sync API
+export const autoSyncAPI = {
+  getSettings: () => apiRequest('/auto-sync/settings'),
+
+  updateSettings: (settings) => apiRequest('/auto-sync/settings', {
+    method: 'PUT',
+    body: JSON.stringify(settings),
+  }),
+
+  getSchedulerStatus: () => apiRequest('/auto-sync/scheduler/status'),
+};
+
+// Awards Admin API
+export const awardsAdminAPI = {
+  getAll: () => apiRequest('/admin/awards'),
+
+  getById: (id) => apiRequest(`/admin/awards/${id}`),
+
+  create: (data) => apiRequest('/admin/awards', {
+    method: 'POST',
+    body: JSON.stringify(data),
+  }),
+
+  update: (id, data) => apiRequest(`/admin/awards/${id}`, {
+    method: 'PUT',
+    body: JSON.stringify(data),
+  }),
+
+  delete: (id) => apiRequest(`/admin/awards/${id}`, {
+    method: 'DELETE',
+  }),
+
+  test: (id, userId, awardDefinition) => apiRequest(`/admin/awards/${id}/test`, {
+    method: 'POST',
+    body: JSON.stringify({ userId, awardDefinition }),
+  }),
+};

src/frontend/src/lib/components/BackButton.svelte

@@ -11,10 +11,10 @@
 <style>
   .back-button {
     padding: 0.5rem 1rem;
-    background-color: #6c757d;
+    background-color: var(--color-secondary);
     color: white;
     text-decoration: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 0.9rem;
     font-weight: 500;
     transition: background-color 0.2s;
@@ -22,12 +22,12 @@
   }
 
   .back-button:hover {
-    background-color: #5a6268;
+    background-color: var(--color-secondary-hover);
   }
 
   .back-button.secondary {
     background-color: transparent;
-    color: #4a90e2;
+    color: var(--color-primary);
     padding: 0;
   }
 

src/frontend/src/lib/components/ErrorDisplay.svelte

@@ -16,21 +16,21 @@
     text-align: center;
     padding: 3rem;
     font-size: 1.1rem;
-    color: #d32f2f;
+    color: var(--color-error);
   }
 
   .btn {
     display: inline-block;
     margin-top: 1rem;
     padding: 0.5rem 1rem;
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
     text-decoration: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-weight: 500;
   }
 
   .btn:hover {
-    background-color: #357abd;
+    background-color: var(--color-primary-hover);
   }
 </style>

src/frontend/src/lib/components/Loading.svelte

@@ -11,6 +11,6 @@
     text-align: center;
     padding: 3rem;
     font-size: 1.1rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 </style>

src/frontend/src/lib/components/ThemeSwitcher.svelte

@@ -0,0 +1,152 @@
+<script>
+  import { theme } from '$lib/stores/theme.js';
+  import { browser } from '$app/environment';
+
+  let isOpen = false;
+
+  const themes = [
+    { value: 'light', label: 'Light', icon: '☀️' },
+    { value: 'dark', label: 'Dark', icon: '🌙' },
+    { value: 'system', label: 'System', icon: '💻' },
+  ];
+
+  function selectTheme(value) {
+    theme.setTheme(value);
+    isOpen = false;
+  }
+
+  function toggle() {
+    isOpen = !isOpen;
+  }
+
+  // Close dropdown when clicking outside
+  function handleClickOutside(event) {
+    if (!event.target.closest('.theme-switcher')) {
+      isOpen = false;
+    }
+  }
+
+  if (browser) {
+    document.addEventListener('click', handleClickOutside);
+  }
+</script>
+
+<svelte:head>
+  <style>
+    /* Ensure dropdown is above other content */
+    .theme-dropdown {
+      z-index: 1000;
+    }
+  </style>
+</svelte:head>
+
+<div class="theme-switcher">
+  <button
+    class="theme-button"
+    on:click={toggle}
+    aria-label="Change theme"
+    aria-expanded={isOpen}
+  >
+    <span class="current-icon">
+      {#if $theme === 'light'}
+        ☀️
+      {:else if $theme === 'dark'}
+        🌙
+      {:else}
+        💻
+      {/if}
+    </span>
+  </button>
+
+  {#if isOpen}
+    <div class="theme-dropdown">
+      {#each themes as t}
+        <button
+          class="theme-option"
+          class:active={$theme === t.value}
+          on:click={() => selectTheme(t.value)}
+        >
+          <span class="theme-icon">{t.icon}</span>
+          <span class="theme-label">{t.label}</span>
+          {#if $theme === t.value}
+            <span class="checkmark">✓</span>
+          {/if}
+        </button>
+      {/each}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .theme-switcher {
+    position: relative;
+    display: inline-block;
+  }
+
+  .theme-button {
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    padding: 0.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: var(--border-radius);
+    transition: background-color 0.2s;
+    color: var(--text-inverted);
+    font-size: 1.25rem;
+  }
+
+  .theme-button:hover {
+    background-color: var(--bg-hover);
+  }
+
+  .theme-dropdown {
+    position: absolute;
+    top: calc(100% + 0.5rem);
+    right: 0;
+    background-color: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
+    box-shadow: var(--shadow-md);
+    min-width: 140px;
+    overflow: hidden;
+  }
+
+  .theme-option {
+    width: 100%;
+    padding: 0.75rem 1rem;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    background: transparent;
+    border: none;
+    cursor: pointer;
+    text-align: left;
+    font-size: 0.9rem;
+    color: var(--text-primary);
+    transition: background-color 0.2s;
+  }
+
+  .theme-option:hover {
+    background-color: var(--bg-secondary);
+  }
+
+  .theme-option.active {
+    background-color: var(--bg-secondary);
+    font-weight: 600;
+  }
+
+  .theme-icon {
+    font-size: 1.1rem;
+  }
+
+  .theme-label {
+    flex: 1;
+  }
+
+  .checkmark {
+    color: var(--color-primary);
+    font-weight: bold;
+  }
+</style>

src/frontend/src/lib/stores.js

@@ -103,6 +103,15 @@ function createAuthStore() {
     clearError: () => {
       update((s) => ({ ...s, error: null }));
     },
+
+    // Direct login with user object and token (for impersonation)
+    loginWithToken: (user, token) => {
+      if (browser) {
+        localStorage.setItem('auth_token', token);
+        localStorage.setItem('auth_user', JSON.stringify(user));
+      }
+      set({ user, token, loading: false, error: null });
+    },
   };
 }
 

src/frontend/src/lib/stores/theme.js

@@ -0,0 +1,56 @@
+import { writable, derived } from 'svelte/store';
+import { browser } from '$app/environment';
+
+/**
+ * Theme store
+ * Manages theme state (light, dark, system) with localStorage persistence
+ */
+function createThemeStore() {
+  // Initialize state from localStorage
+  const initialState = browser ? localStorage.getItem('theme') || 'light' : 'light';
+
+  const { subscribe, set, update } = writable(initialState);
+
+  // Listen for system preference changes
+  let mediaQuery;
+  if (browser) {
+    mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+    const handleMediaChange = () => {
+      // Trigger update to recompute isDark
+      update((n) => n);
+    };
+    mediaQuery.addEventListener('change', handleMediaChange);
+  }
+
+  // Derived store for whether dark mode should be active
+  const isDark = derived(initialState, ($theme) => {
+    if (!browser) return false;
+    if ($theme === 'dark') return true;
+    if ($theme === 'light') return false;
+    // system preference
+    return window.matchMedia('(prefers-color-scheme: dark)').matches;
+  });
+
+  return {
+    subscribe,
+    isDark,
+    setTheme: (theme) => {
+      if (browser) {
+        localStorage.setItem('theme', theme);
+        // Apply data-theme attribute to document
+        const isDarkMode = theme === 'dark' || (theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+        document.documentElement.setAttribute('data-theme', isDarkMode ? 'dark' : 'light');
+      }
+      set(theme);
+    },
+    // Initialize theme on client-side
+    init: () => {
+      if (!browser) return;
+      const theme = localStorage.getItem('theme') || 'light';
+      const isDarkMode = theme === 'dark' || (theme === 'system' && window.matchMedia('(prefers-color-scheme: dark)').matches);
+      document.documentElement.setAttribute('data-theme', isDarkMode ? 'dark' : 'light');
+    },
+  };
+}
+
+export const theme = createThemeStore();

src/frontend/src/routes/+layout.svelte

@@ -1,11 +1,52 @@
 <script>
   import { browser } from '$app/environment';
+  import { onMount } from 'svelte';
   import { auth } from '$lib/stores.js';
+  import { theme } from '$lib/stores/theme.js';
   import { goto } from '$app/navigation';
+  import { adminAPI, authAPI } from '$lib/api.js';
+  import ThemeSwitcher from '$lib/components/ThemeSwitcher.svelte';
+  import '../app.css';
+
+  let stoppingImpersonation = false;
+
+  // Initialize theme on mount
+  onMount(() => {
+    theme.init();
+  });
 
   function handleLogout() {
     auth.logout();
-    goto('/auth/login');
+    // Use hard redirect to ensure proper navigation after logout
+    // goto() may not work properly due to SvelteKit client-side routing
+    if (browser) {
+      window.location.href = '/auth/login';
+    }
+  }
+
+  async function handleStopImpersonation() {
+    if (stoppingImpersonation) return;
+
+    try {
+      stoppingImpersonation = true;
+      const data = await adminAPI.stopImpersonation();
+
+      if (data.success) {
+        // Update auth store with admin user data and new token
+        auth.loginWithToken(data.user, data.token);
+
+        // Hard redirect to home page
+        if (browser) {
+          window.location.href = '/';
+        }
+      } else {
+        alert('Failed to stop impersonation: ' + (data.error || 'Unknown error'));
+      }
+    } catch (err) {
+      alert('Failed to stop impersonation: ' + err.message);
+    } finally {
+      stoppingImpersonation = false;
+    }
   }
 </script>
 
@@ -30,11 +71,32 @@
             {#if $auth.user?.isAdmin}
               <a href="/admin" class="nav-link admin-link">Admin</a>
             {/if}
+            <ThemeSwitcher />
             <button on:click={handleLogout} class="nav-link logout-btn">Logout</button>
           </div>
         </div>
       </nav>
     {/if}
+
+    <!-- Impersonation Banner -->
+    {#if $auth.user?.impersonatedBy}
+      <div class="impersonation-banner">
+        <div class="impersonation-content">
+          <span class="warning-icon">⚠️</span>
+          <span class="impersonation-text">
+            You are currently impersonating <strong>{$auth.user.email}</strong>
+          </span>
+          <button
+            class="stop-impersonation-btn"
+            on:click={handleStopImpersonation}
+            disabled={stoppingImpersonation}
+          >
+            {stoppingImpersonation ? 'Stopping...' : 'Stop Impersonation'}
+          </button>
+        </div>
+      </div>
+    {/if}
+
     <main>
       <slot />
     </main>
@@ -59,7 +121,8 @@
     margin: 0;
     font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu,
       Cantarell, 'Open Sans', 'Helvetica Neue', sans-serif;
-    background-color: #f5f5f5;
+    background-color: var(--bg-body);
+    color: var(--text-primary);
   }
 
   .app {
@@ -69,8 +132,8 @@
   }
 
   .navbar {
-    background-color: #2c3e50;
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    background-color: var(--bg-navbar);
+    box-shadow: var(--shadow-md);
   }
 
   .nav-container {
@@ -84,7 +147,7 @@
   }
 
   .nav-brand .callsign {
-    color: white;
+    color: var(--text-inverted);
     font-size: 1.25rem;
     font-weight: 600;
   }
@@ -96,11 +159,12 @@
   }
 
   .nav-link {
-    color: rgba(255, 255, 255, 0.8);
+    color: var(--text-inverted);
+    opacity: 0.8;
     text-decoration: none;
     font-size: 0.95rem;
     padding: 0.5rem 1rem;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     transition: all 0.2s;
     background: none;
     border: none;
@@ -109,27 +173,27 @@
   }
 
   .nav-link:hover {
-    color: white;
-    background-color: rgba(255, 255, 255, 0.1);
+    opacity: 1;
+    background-color: var(--bg-hover);
   }
 
   .logout-btn {
-    color: #ff6b6b;
+    color: var(--color-logout);
+    opacity: 1;
   }
 
   .logout-btn:hover {
-    color: #ff5252;
-    background-color: rgba(255, 107, 107, 0.1);
+    background-color: var(--color-logout-bg);
   }
 
   .admin-link {
-    background-color: #ffc107;
-    color: #000;
+    background-color: var(--color-admin-bg);
+    color: var(--color-admin-text);
     font-weight: 600;
   }
 
   .admin-link:hover {
-    background-color: #e0a800;
+    background-color: var(--color-admin-hover);
   }
 
   main {
@@ -141,8 +205,9 @@
   }
 
   footer {
-    background-color: #2c3e50;
-    color: rgba(255, 255, 255, 0.7);
+    background-color: var(--bg-footer);
+    color: var(--text-inverted);
+    opacity: 0.7;
     text-align: center;
     padding: 1.5rem;
     margin-top: auto;
@@ -152,4 +217,51 @@
     margin: 0;
     font-size: 0.875rem;
   }
+
+  /* Impersonation Banner */
+  .impersonation-banner {
+    background-color: var(--impersonation-bg);
+    border: 2px solid var(--impersonation-border);
+    padding: 0.75rem 1rem;
+  }
+
+  .impersonation-content {
+    max-width: 1200px;
+    margin: 0 auto;
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    flex-wrap: wrap;
+  }
+
+  .warning-icon {
+    font-size: 1.25rem;
+  }
+
+  .impersonation-text {
+    flex: 1;
+    font-size: 0.95rem;
+    color: var(--impersonation-text);
+  }
+
+  .stop-impersonation-btn {
+    background-color: var(--color-warning);
+    color: var(--impersonation-text);
+    border: none;
+    padding: 0.5rem 1rem;
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-weight: 600;
+    font-size: 0.9rem;
+    transition: background-color 0.2s;
+  }
+
+  .stop-impersonation-btn:hover:not(:disabled) {
+    background-color: var(--color-warning-hover);
+  }
+
+  .stop-impersonation-btn:disabled {
+    opacity: 0.6;
+    cursor: not-allowed;
+  }
 </style>

src/frontend/src/routes/+page.svelte

@@ -1,7 +1,7 @@
 <script>
   import { onMount, onDestroy, tick } from 'svelte';
   import { auth } from '$lib/stores.js';
-  import { jobsAPI } from '$lib/api.js';
+  import { jobsAPI, autoSyncAPI } from '$lib/api.js';
   import { browser } from '$app/environment';
 
   let jobs = [];
@@ -9,6 +9,18 @@
   let cancellingJobs = new Map(); // Track cancelling state per job
   let pollingInterval = null;
 
+  // Auto-sync settings state
+  let autoSyncSettings = null;
+  let loadingAutoSync = false;
+
+  // Reactive: scheduled jobs derived from settings
+  // Note: Explicitly reference autoSyncSettings to ensure Svelte tracks it as a dependency
+  let scheduledJobs = [];
+  $: {
+    autoSyncSettings; // Touch variable so Svelte tracks reactivity
+    scheduledJobs = getScheduledJobs();
+  }
+
   async function loadJobs() {
     try {
       const response = await jobsAPI.getRecent(5);
@@ -22,6 +34,81 @@
     }
   }
 
+  async function loadAutoSyncSettings() {
+    try {
+      loadingAutoSync = true;
+      const response = await autoSyncAPI.getSettings();
+      autoSyncSettings = response.settings || null;
+    } catch (error) {
+      console.error('Failed to load auto-sync settings:', error);
+      // Don't show error, auto-sync is optional
+    } finally {
+      loadingAutoSync = false;
+    }
+  }
+
+  function getScheduledJobs() {
+    if (!autoSyncSettings) {
+      return [];
+    }
+
+    const scheduled = [];
+
+    if (autoSyncSettings.lotwEnabled) {
+      scheduled.push({
+        type: 'lotw_sync',
+        icon: '📡',
+        name: 'LoTW Auto-Sync',
+        interval: autoSyncSettings.lotwIntervalHours,
+        nextSyncAt: autoSyncSettings.lotwNextSyncAt,
+        lastSyncAt: autoSyncSettings.lotwLastSyncAt,
+        enabled: true,
+      });
+    }
+
+    if (autoSyncSettings.dclEnabled) {
+      scheduled.push({
+        type: 'dcl_sync',
+        icon: '🛰️',
+        name: 'DCL Auto-Sync',
+        interval: autoSyncSettings.dclIntervalHours,
+        nextSyncAt: autoSyncSettings.dclNextSyncAt,
+        lastSyncAt: autoSyncSettings.dclLastSyncAt,
+        enabled: true,
+      });
+    }
+
+    return scheduled;
+  }
+
+  function getNextSyncLabel(nextSyncAt, interval) {
+    if (!nextSyncAt) return 'Pending...';
+
+    const now = new Date();
+    const nextSync = new Date(nextSyncAt);
+    const diffMs = nextSync - now;
+    const diffMins = Math.floor(diffMs / 60000);
+    const diffHours = Math.floor(diffMs / 3600000);
+    const diffDays = Math.floor(diffMs / 86400000);
+
+    if (diffMs < 0) return 'Due now';
+    if (diffMins < 60) return `In ${diffMins} minute${diffMins !== 1 ? 's' : ''}`;
+    if (diffHours < 24) return `In ${diffHours} hour${diffHours !== 1 ? 's' : ''}`;
+    return `In ${diffDays} day${diffDays !== 1 ? 's' : ''}`;
+  }
+
+  function formatNextSyncTime(nextSyncAt) {
+    if (!nextSyncAt) return null;
+    const date = new Date(nextSyncAt);
+    return date.toLocaleString();
+  }
+
+  function formatLastSyncTime(lastSyncAt) {
+    if (!lastSyncAt) return 'Never';
+    const date = new Date(lastSyncAt);
+    return formatDate(date);
+  }
+
   function hasActiveJobs() {
     return jobs.some(job => job.status === 'pending' || job.status === 'running');
   }
@@ -58,6 +145,7 @@
     // Load recent jobs if authenticated
     if ($auth.user) {
       await loadJobs();
+      await loadAutoSyncSettings();
       loading = false;
     }
   });
@@ -187,6 +275,47 @@
         </div>
       </div>
 
+      <!-- Scheduled Auto-Sync Jobs -->
+      {#if scheduledJobs.length > 0}
+        <div class="scheduled-section">
+          <h2 class="section-title">⏰ Upcoming Auto-Sync</h2>
+          <div class="jobs-list">
+            {#each scheduledJobs as scheduled (scheduled.type)}
+              <div class="job-card job-card-scheduled">
+                <div class="job-header">
+                  <div class="job-title">
+                    <span class="job-icon">{scheduled.icon}</span>
+                    <span class="job-name">{scheduled.name}</span>
+                    <span class="job-badge scheduled-badge">Scheduled</span>
+                  </div>
+                  <span class="scheduled-interval">Every {scheduled.interval}h</span>
+                </div>
+
+                <div class="job-meta">
+                  <span class="job-date">
+                    Next: <strong title={formatNextSyncTime(scheduled.nextSyncAt)}>
+                      {getNextSyncLabel(scheduled.nextSyncAt, scheduled.interval)}
+                    </strong>
+                  </span>
+                  <span class="job-time">
+                    Last: {formatLastSyncTime(scheduled.lastSyncAt)}
+                  </span>
+                </div>
+
+                <div class="scheduled-countdown">
+                  <div class="countdown-bar">
+                    <div class="countdown-progress"></div>
+                  </div>
+                  <p class="countdown-text">
+                    {formatNextSyncTime(scheduled.nextSyncAt)}
+                  </p>
+                </div>
+              </div>
+            {/each}
+          </div>
+        </div>
+      {/if}
+
       <!-- Recent Sync Jobs -->
       <div class="jobs-section">
         <h2 class="section-title">🔄 Recent Sync Jobs</h2>
@@ -316,13 +445,13 @@
 
   .welcome h1 {
     font-size: 2.5rem;
-    color: #333;
+    color: var(--text-primary);
     margin-bottom: 0.5rem;
   }
 
   .subtitle {
     font-size: 1.25rem;
-    color: #666;
+    color: var(--text-secondary);
     margin-bottom: 2rem;
   }
 
@@ -335,12 +464,12 @@
 
   .dashboard h1 {
     font-size: 2rem;
-    color: #333;
+    color: var(--text-primary);
     margin-bottom: 0.5rem;
   }
 
   .welcome-section p {
-    color: #666;
+    color: var(--text-secondary);
     font-size: 1.1rem;
     margin-bottom: 2rem;
   }
@@ -353,21 +482,21 @@
   }
 
   .action-card {
-    background: white;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
     padding: 1.5rem;
-    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    box-shadow: var(--shadow-sm);
   }
 
   .action-card h3 {
     margin: 0 0 0.5rem 0;
     font-size: 1.25rem;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .action-card p {
-    color: #666;
+    color: var(--text-secondary);
     margin-bottom: 1rem;
   }
 
@@ -375,7 +504,7 @@
     display: inline-block;
     padding: 0.75rem 1.5rem;
     border: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 1rem;
     font-weight: 500;
     text-decoration: none;
@@ -384,25 +513,25 @@
   }
 
   .btn-primary {
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
   }
 
   .btn-primary:hover {
-    background-color: #357abd;
+    background-color: var(--color-primary-hover);
   }
 
   .btn-secondary {
-    background-color: #6c757d;
+    background-color: var(--color-secondary);
     color: white;
   }
 
   .btn-secondary:hover {
-    background-color: #5a6268;
+    background-color: var(--color-secondary-hover);
   }
 
   .action-card .btn {
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
     width: 100%;
     text-align: center;
@@ -410,25 +539,25 @@
   }
 
   .action-card .btn:hover {
-    background-color: #357abd;
+    background-color: var(--color-primary-hover);
   }
 
   .info-box {
-    background: #f8f9fa;
-    border-left: 4px solid #4a90e2;
+    background: var(--bg-secondary);
+    border-left: 4px solid var(--color-primary);
     padding: 1.5rem;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
   }
 
   .info-box h3 {
     margin: 0 0 1rem 0;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .info-box ol {
     margin: 0;
     padding-left: 1.5rem;
-    color: #666;
+    color: var(--text-secondary);
     line-height: 1.8;
   }
 
@@ -439,18 +568,18 @@
 
   .section-title {
     font-size: 1.5rem;
-    color: #333;
+    color: var(--text-primary);
     margin-bottom: 1rem;
   }
 
   .loading-state,
   .empty-state {
-    background: white;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
     padding: 2rem;
     text-align: center;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .empty-actions {
@@ -468,20 +597,25 @@
   }
 
   .job-card {
-    background: white;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
     padding: 1rem 1.25rem;
-    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    box-shadow: var(--shadow-sm);
     transition: box-shadow 0.2s;
   }
 
   .job-card:hover {
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.12);
+    box-shadow: var(--shadow-md);
   }
 
   .job-card.failed {
-    border-left: 4px solid #dc3545;
+    border-left: 4px solid var(--color-error);
+  }
+
+  .job-card-scheduled {
+    border-left: 4px solid var(--badge-purple-bg);
+    background: var(--gradient-scheduled);
   }
 
   .job-header {
@@ -503,69 +637,83 @@
 
   .job-name {
     font-weight: 600;
-    color: #333;
+    color: var(--text-primary);
     font-size: 1.1rem;
   }
 
   .job-id {
     font-size: 0.85rem;
-    color: #999;
+    color: var(--text-muted);
     font-family: monospace;
   }
 
   .status-badge {
     padding: 0.25rem 0.75rem;
-    border-radius: 12px;
+    border-radius: var(--border-radius-pill);
     font-size: 0.85rem;
     font-weight: 500;
     text-transform: capitalize;
   }
 
   .bg-yellow-100 {
-    background-color: #fef3c7;
+    background-color: var(--badge-pending-bg);
   }
 
   .bg-blue-100 {
-    background-color: #dbeafe;
+    background-color: var(--badge-running-bg);
   }
 
   .bg-green-100 {
-    background-color: #d1fae5;
+    background-color: var(--badge-completed-bg);
   }
 
   .bg-red-100 {
-    background-color: #fee2e2;
+    background-color: var(--badge-failed-bg);
   }
 
   .text-yellow-800 {
-    color: #92400e;
+    color: var(--badge-pending-text);
   }
 
   .text-blue-800 {
-    color: #1e40af;
+    color: var(--badge-running-text);
   }
 
   .text-green-800 {
-    color: #065f46;
+    color: var(--badge-completed-text);
   }
 
   .text-red-800 {
-    color: #991b1b;
+    color: var(--badge-failed-text);
   }
 
   .bg-purple-100 {
-    background-color: #f3e8ff;
+    background-color: var(--badge-cancelled-bg);
   }
 
   .text-purple-800 {
-    color: #6b21a8;
+    color: var(--badge-cancelled-text);
+  }
+
+  .job-badge {
+    padding: 0.2rem 0.6rem;
+    border-radius: 10px;
+    font-size: 0.75rem;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+  }
+
+  .scheduled-badge {
+    background-color: var(--badge-purple-bg);
+    color: var(--badge-purple-text);
   }
 
   .job-meta {
     display: flex;
     gap: 0.75rem;
     font-size: 0.9rem;
-    color: #666;
+    color: var(--text-secondary);
     margin-bottom: 0.5rem;
     flex-wrap: wrap;
   }
@@ -576,14 +724,14 @@
 
   .job-time,
   .job-duration {
-    color: #999;
+    color: var(--text-muted);
   }
 
   .job-error {
-    background: #fee2e2;
-    color: #991b1b;
+    background: var(--color-error-bg);
+    color: var(--color-error-text);
     padding: 0.75rem;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 0.95rem;
     margin-top: 0.5rem;
   }
@@ -597,29 +745,29 @@
 
   .stat-item {
     font-size: 0.9rem;
-    color: #666;
+    color: var(--text-secondary);
     padding: 0.25rem 0.5rem;
-    background: #f8f9fa;
-    border-radius: 4px;
+    background: var(--bg-secondary);
+    border-radius: var(--border-radius);
   }
 
   .stat-item strong {
-    color: #333;
+    color: var(--text-primary);
   }
 
   .stat-added {
-    color: #065f46;
-    background: #d1fae5;
+    color: var(--color-success);
+    background: var(--color-success-bg);
   }
 
   .stat-updated {
-    color: #1e40af;
-    background: #dbeafe;
+    color: var(--color-info);
+    background: var(--color-info-bg);
   }
 
   .stat-skipped {
-    color: #92400e;
-    background: #fef3c7;
+    color: var(--badge-pending-text);
+    background: var(--badge-pending-bg);
   }
 
   .job-progress {
@@ -627,7 +775,7 @@
   }
 
   .progress-text {
-    color: #1e40af;
+    color: var(--color-info);
     font-size: 0.9rem;
     font-style: italic;
   }
@@ -641,17 +789,17 @@
   .btn-cancel {
     padding: 0.4rem 0.8rem;
     font-size: 0.85rem;
-    border: 1px solid #dc3545;
-    background: white;
-    color: #dc3545;
-    border-radius: 4px;
+    border: 1px solid var(--color-error);
+    background: var(--bg-card);
+    color: var(--color-error);
+    border-radius: var(--border-radius);
     cursor: pointer;
     transition: all 0.2s;
     font-weight: 500;
   }
 
   .btn-cancel:hover:not(:disabled) {
-    background: #dc3545;
+    background: var(--color-error);
     color: white;
   }
 
@@ -659,4 +807,53 @@
     opacity: 0.6;
     cursor: not-allowed;
   }
+
+  /* Scheduled Jobs Section */
+  .scheduled-section {
+    margin-bottom: 2rem;
+  }
+
+  /* Scheduled job countdown */
+  .scheduled-countdown {
+    margin-top: 1rem;
+  }
+
+  .countdown-bar {
+    height: 6px;
+    background: var(--border-color-light);
+    border-radius: 3px;
+    overflow: hidden;
+    margin-bottom: 0.5rem;
+  }
+
+  .countdown-progress {
+    height: 100%;
+    background: var(--gradient-purple);
+    border-radius: 3px;
+    width: 100%;
+    animation: pulse-countdown 2s ease-in-out infinite;
+  }
+
+  @keyframes pulse-countdown {
+    0%, 100% {
+      opacity: 1;
+    }
+    50% {
+      opacity: 0.7;
+    }
+  }
+
+  .countdown-text {
+    margin: 0;
+    font-size: 0.85rem;
+    color: var(--badge-purple-bg);
+    text-align: center;
+    font-weight: 500;
+  }
+
+  @media (max-width: 640px) {
+    .scheduled-list {
+      grid-template-columns: 1fr;
+    }
+  }
 </style>

src/frontend/src/routes/admin/+page.svelte

@@ -1,7 +1,7 @@
 <script>
   import { onMount } from 'svelte';
   import { auth } from '$lib/stores.js';
-  import { adminAPI } from '$lib/api.js';
+  import { adminAPI, authAPI } from '$lib/api.js';
   import { browser } from '$app/environment';
 
   let loading = true;
@@ -12,7 +12,7 @@
   let impersonationStatus = null;
 
   // UI state
-  let selectedTab = 'overview'; // 'overview', 'users', 'actions'
+  let selectedTab = 'overview'; // 'overview', 'users', 'awards', 'actions'
   let showImpersonationModal = false;
   let showDeleteUserModal = false;
   let showRoleChangeModal = false;
@@ -90,16 +90,16 @@
       const data = await adminAPI.impersonate(userId);
 
       if (data.success) {
-        // Store new token
+        // Store the new impersonation token
         if (browser) {
           localStorage.setItem('auth_token', data.token);
         }
 
-        // Update auth store with new user data
-        auth.login({
-          ...data.impersonating,
-          impersonatedBy: $auth.user.id,
-        });
+        // Fetch the full user profile (which includes impersonatedBy)
+        const profileData = await authAPI.getProfile();
+
+        // Update auth store with complete user data
+        auth.loginWithToken(profileData.user, data.token);
 
         // Redirect to home page
         window.location.href = '/';
@@ -114,32 +114,6 @@
     }
   }
 
-  async function handleStopImpersonation() {
-    try {
-      loading = true;
-      const data = await adminAPI.stopImpersonation();
-
-      if (data.success) {
-        // Store admin token
-        if (browser) {
-          localStorage.setItem('auth_token', data.token);
-        }
-
-        // Update auth store
-        auth.login(data.user);
-
-        alert(data.message);
-        window.location.reload();
-      } else {
-        alert('Failed to stop impersonation: ' + (data.error || 'Unknown error'));
-      }
-    } catch (err) {
-      alert('Failed to stop impersonation: ' + err.message);
-    } finally {
-      loading = false;
-    }
-  }
-
   async function handleDeleteUser(userId) {
     const user = users.find(u => u.id === userId);
     if (!user) return;
@@ -167,19 +141,19 @@
     }
   }
 
-  async function handleRoleChange(userId, newIsAdmin) {
+  async function handleRoleChange(userId, newRole) {
     try {
       loading = true;
-      const data = await adminAPI.updateUserRole(userId, newIsAdmin);
+      const data = await adminAPI.updateUserRole(userId, newRole);
 
       if (data.success) {
         alert(data.message);
         await loadUsers();
       } else {
-        alert('Failed to update user admin status: ' + (data.error || 'Unknown error'));
+        alert('Failed to update user role: ' + (data.error || 'Unknown error'));
       }
     } catch (err) {
-      alert('Failed to update user admin status: ' + err.message);
+      alert('Failed to update user role: ' + err.message);
     } finally {
       loading = false;
       showRoleChangeModal = false;
@@ -203,7 +177,11 @@
 
   function formatDate(dateString) {
     if (!dateString) return 'N/A';
-    return new Date(dateString).toLocaleDateString('en-US', {
+    // Handle Unix timestamps (seconds) by converting to milliseconds
+    const date = typeof dateString === 'number'
+      ? new Date(dateString * 1000)
+      : new Date(dateString);
+    return date.toLocaleDateString('en-US', {
       year: 'numeric',
       month: 'short',
       day: 'numeric',
@@ -219,7 +197,8 @@
       user.callsign.toLowerCase().includes(userSearch.toLowerCase());
 
     const matchesFilter = userFilter === 'all' ||
-      (userFilter === 'admin' && user.isAdmin) ||
+      (userFilter === 'super-admin' && user.isSuperAdmin) ||
+      (userFilter === 'admin' && user.isAdmin && !user.isSuperAdmin) ||
       (userFilter === 'user' && !user.isAdmin);
 
     return matchesSearch && matchesFilter;
@@ -232,21 +211,6 @@
   <div class="error">{error}</div>
 {:else}
   <div class="admin-dashboard">
-    <!-- Impersonation Banner -->
-    {#if $auth.user?.impersonatedBy}
-      <div class="impersonation-banner">
-        <div class="impersonation-content">
-          <span class="warning-icon">⚠️</span>
-          <span class="impersonation-text">
-            You are currently impersonating <strong>{$auth.user.email}</strong>
-          </span>
-          <button class="stop-impersonation-btn" on:click={handleStopImpersonation}>
-            Stop Impersonation
-          </button>
-        </div>
-      </div>
-    {/if}
-
     <h1>Admin Dashboard</h1>
 
     <!-- Tab Navigation -->
@@ -263,6 +227,12 @@
       >
         Users
       </button>
+      <button
+        class="tab {selectedTab === 'awards' ? 'active' : ''}"
+        on:click={() => selectedTab = 'awards'}
+      >
+        Awards
+      </button>
       <button
         class="tab {selectedTab === 'actions' ? 'active' : ''}"
         on:click={() => selectedTab = 'actions'}
@@ -348,6 +318,7 @@
             />
             <select class="filter-select" bind:value={userFilter}>
               <option value="all">All Users</option>
+              <option value="super-admin">Super Admins Only</option>
               <option value="admin">Admins Only</option>
               <option value="user">Regular Users Only</option>
             </select>
@@ -367,6 +338,7 @@
                 <th>DCL Conf.</th>
                 <th>Total Conf.</th>
                 <th>Last Sync</th>
+                <th>Last Seen</th>
                 <th>Actions</th>
               </tr>
             </thead>
@@ -377,8 +349,8 @@
                   <td>{user.email}</td>
                   <td>{user.callsign}</td>
                   <td>
-                    <span class="role-badge {user.isAdmin ? 'admin' : 'user'}">
-                      {user.isAdmin ? 'Admin' : 'User'}
+                    <span class="role-badge {user.isSuperAdmin ? 'super-admin' : (user.isAdmin ? 'admin' : 'user')}">
+                      {user.isSuperAdmin ? 'Super Admin' : (user.isAdmin ? 'Admin' : 'User')}
                     </span>
                   </td>
                   <td>{user.qsoCount || 0}</td>
@@ -386,11 +358,12 @@
                   <td>{user.dclConfirmed || 0}</td>
                   <td>{user.totalConfirmed || 0}</td>
                   <td>{formatDate(user.lastSync)}</td>
+                  <td>{formatDate(user.lastSeen)}</td>
                   <td class="actions-cell">
                     <button
                       class="action-button impersonate-btn"
                       on:click={() => openImpersonationModal(user)}
-                      disabled={user.isAdmin}
+                      disabled={user.isAdmin && !$auth.user.isSuperAdmin}
                     >
                       Impersonate
                     </button>
@@ -419,6 +392,30 @@
       </div>
     {/if}
 
+    <!-- Awards Tab -->
+    {#if selectedTab === 'awards'}
+      <div class="tab-content">
+        <h2>Award Definitions</h2>
+        <p class="help-text">Manage award definitions. Create, edit, and delete awards.</p>
+
+        <div class="awards-quick-actions">
+          <a href="/admin/awards" class="btn btn-primary">Manage Awards</a>
+        </div>
+
+        <div class="awards-info">
+          <h3>Award Management</h3>
+          <p>From the Awards management page, you can:</p>
+          <ul>
+            <li><strong>Create</strong> new award definitions</li>
+            <li><strong>Edit</strong> existing award definitions</li>
+            <li><strong>Delete</strong> awards</li>
+            <li><strong>Test</strong> award calculations with sample user data</li>
+          </ul>
+          <p>All award definitions are stored as JSON files in the <code>award-definitions/</code> directory.</p>
+        </div>
+      </div>
+    {/if}
+
     <!-- Actions Tab -->
     {#if selectedTab === 'actions'}
       <div class="tab-content">
@@ -500,25 +497,34 @@
     <div class="modal-content" on:click|stopPropagation>
       <h2>Change User Role</h2>
       <p>User: <strong>{selectedUser.email}</strong></p>
-      <p>Current Role: <strong>{selectedUser.isAdmin ? 'Admin' : 'User'}</strong></p>
+      <p>Current Role: <strong>{selectedUser.isSuperAdmin ? 'Super Admin' : (selectedUser.isAdmin ? 'Admin' : 'User')}</strong></p>
       <p>New Role:</p>
       <div class="role-options">
         <label>
-          <input type="radio" name="role" value="user" checked={!selectedUser.isAdmin} />
+          <input type="radio" name="role" value="user" checked={!selectedUser.isAdmin && !selectedUser.isSuperAdmin} />
           Regular User
         </label>
         <label>
-          <input type="radio" name="role" value="admin" checked={selectedUser.isAdmin} />
+          <input type="radio" name="role" value="admin" checked={selectedUser.isAdmin && !selectedUser.isSuperAdmin} />
           Admin
         </label>
+        {#if $auth.user.isSuperAdmin}
+          <label>
+            <input type="radio" name="role" value="super-admin" checked={selectedUser.isSuperAdmin} />
+            Super Admin
+          </label>
+        {/if}
       </div>
+      {#if !$auth.user.isSuperAdmin && (selectedUser.isSuperAdmin || (selectedUser.isAdmin && selectedUser.email !== selectedUser.email))}
+        <p class="warning">Note: Only super-admins can promote or demote super-admins.</p>
+      {/if}
       <div class="modal-actions">
         <button class="modal-button cancel" on:click={() => showRoleChangeModal = false}>
           Cancel
         </button>
         <button
           class="modal-button confirm"
-          on:click={() => handleRoleChange(selectedUser.id, !selectedUser.isAdmin)}
+          on:click={() => handleRoleChange(selectedUser.id, document.querySelector('input[name="role"]:checked')?.value || 'user')}
         >
           Change Role
         </button>
@@ -563,58 +569,20 @@
     text-align: center;
     padding: 3rem;
     font-size: 1.2rem;
+    color: var(--text-secondary);
   }
 
   .error {
-    background-color: #fee;
-    border: 1px solid #fcc;
+    background-color: var(--color-error-bg);
+    border: 1px solid var(--color-error);
     padding: 1rem;
-    border-radius: 4px;
-    color: #c00;
-  }
-
-  /* Impersonation Banner */
-  .impersonation-banner {
-    background-color: #fff3cd;
-    border: 2px solid #ffc107;
-    border-radius: 4px;
-    padding: 1rem;
-    margin-bottom: 2rem;
-  }
-
-  .impersonation-content {
-    display: flex;
-    align-items: center;
-    gap: 1rem;
-    flex-wrap: wrap;
-  }
-
-  .warning-icon {
-    font-size: 1.5rem;
-  }
-
-  .impersonation-text {
-    flex: 1;
-    font-size: 1rem;
-  }
-
-  .stop-impersonation-btn {
-    background-color: #ffc107;
-    color: #000;
-    border: none;
-    padding: 0.5rem 1rem;
-    border-radius: 4px;
-    cursor: pointer;
-    font-weight: bold;
-  }
-
-  .stop-impersonation-btn:hover {
-    background-color: #e0a800;
+    border-radius: var(--border-radius);
+    color: var(--color-error-text);
   }
 
   h1 {
     margin-bottom: 1.5rem;
-    color: #333;
+    color: var(--text-primary);
   }
 
   /* Tabs */
@@ -622,7 +590,7 @@
     display: flex;
     gap: 0.5rem;
     margin-bottom: 2rem;
-    border-bottom: 2px solid #ddd;
+    border-bottom: 2px solid var(--border-color);
   }
 
   .tab {
@@ -632,30 +600,30 @@
     cursor: pointer;
     font-size: 1rem;
     font-weight: 500;
-    color: #666;
+    color: var(--text-secondary);
     position: relative;
     top: 2px;
   }
 
   .tab:hover {
-    color: #333;
+    color: var(--text-primary);
   }
 
   .tab.active {
-    color: #007bff;
-    border-bottom: 2px solid #007bff;
+    color: var(--color-primary);
+    border-bottom: 2px solid var(--color-primary);
   }
 
   .tab-content {
-    background: white;
+    background: var(--bg-card);
     padding: 1.5rem;
-    border-radius: 4px;
-    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    border-radius: var(--border-radius);
+    box-shadow: var(--shadow-sm);
   }
 
   h2 {
     margin-bottom: 1rem;
-    color: #333;
+    color: var(--text-primary);
   }
 
   /* Stats Grid */
@@ -670,8 +638,8 @@
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
     color: white;
     padding: 1.5rem;
-    border-radius: 8px;
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+    border-radius: var(--border-radius-lg);
+    box-shadow: var(--shadow-md);
   }
 
   .stat-card h3 {
@@ -714,9 +682,11 @@
   .search-input,
   .filter-select {
     padding: 0.5rem 0.75rem;
-    border: 1px solid #ddd;
-    border-radius: 4px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
     font-size: 0.9rem;
+    background: var(--bg-input);
+    color: var(--text-primary);
   }
 
   .search-input {
@@ -731,8 +701,8 @@
   .users-table {
     width: 100%;
     border-collapse: collapse;
-    background: white;
-    border-radius: 4px;
+    background: var(--bg-card);
+    border-radius: var(--border-radius);
     overflow: hidden;
   }
 
@@ -740,23 +710,23 @@
   .users-table td {
     padding: 0.75rem 1rem;
     text-align: left;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color);
   }
 
   .users-table th {
-    background-color: #f5f5f5;
+    background-color: var(--bg-secondary);
     font-weight: 600;
     text-transform: uppercase;
     font-size: 0.8rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .users-table tr:hover {
-    background-color: #f9f9f9;
+    background-color: var(--bg-secondary);
   }
 
   .admin-row {
-    background-color: #fff9e6 !important;
+    background-color: var(--color-warning-bg) !important;
   }
 
   .actions-cell {
@@ -767,7 +737,7 @@
     padding: 0.4rem 0.8rem;
     margin-right: 0.3rem;
     border: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     cursor: pointer;
     font-size: 0.85rem;
     transition: all 0.2s;
@@ -788,21 +758,21 @@
   }
 
   .role-btn {
-    background-color: #ffc107;
+    background-color: var(--color-warning);
     color: #000;
   }
 
   .role-btn:hover:not(:disabled) {
-    background-color: #e0a800;
+    background-color: var(--color-warning-hover);
   }
 
   .delete-btn {
-    background-color: #dc3545;
+    background-color: var(--color-error);
     color: white;
   }
 
   .delete-btn:hover:not(:disabled) {
-    background-color: #c82333;
+    background-color: var(--color-error-hover);
   }
 
   .role-badge {
@@ -817,14 +787,19 @@
     color: white;
   }
 
+  .role-badge.super-admin {
+    background: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+    color: white;
+  }
+
   .role-badge.user {
-    background-color: #6c757d;
+    background-color: var(--color-secondary);
     color: white;
   }
 
   .users-count {
     margin-top: 1rem;
-    color: #666;
+    color: var(--text-secondary);
     font-style: italic;
   }
 
@@ -836,8 +811,8 @@
   .actions-table {
     width: 100%;
     border-collapse: collapse;
-    background: white;
-    border-radius: 4px;
+    background: var(--bg-card);
+    border-radius: var(--border-radius);
     overflow: hidden;
   }
 
@@ -845,15 +820,15 @@
   .actions-table td {
     padding: 0.75rem 1rem;
     text-align: left;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color);
   }
 
   .actions-table th {
-    background-color: #f5f5f5;
+    background-color: var(--bg-secondary);
     font-weight: 600;
     text-transform: uppercase;
     font-size: 0.8rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .action-type {
@@ -863,13 +838,13 @@
     font-weight: 600;
   }
 
-  .action-type.impostor_start {
-    background-color: #ffc107;
+  .action-type.impersonate_start {
+    background-color: var(--color-warning);
     color: #000;
   }
 
-  .action-type.impostor_stop {
-    background-color: #28a745;
+  .action-type.impersonate_stop {
+    background-color: var(--color-success-light);
     color: white;
   }
 
@@ -879,14 +854,14 @@
   }
 
   .action-type.user_delete {
-    background-color: #dc3545;
+    background-color: var(--color-error);
     color: white;
   }
 
   .details-json {
-    background-color: #f5f5f5;
+    background-color: var(--bg-secondary);
     padding: 0.5rem;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 0.8rem;
     max-height: 200px;
     overflow-y: auto;
@@ -895,7 +870,7 @@
   .no-actions {
     text-align: center;
     padding: 2rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   /* Modal */
@@ -913,30 +888,30 @@
   }
 
   .modal-content {
-    background: white;
+    background: var(--bg-card);
     padding: 2rem;
-    border-radius: 8px;
+    border-radius: var(--border-radius-lg);
     max-width: 500px;
     width: 90%;
-    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+    box-shadow: var(--shadow-md);
   }
 
   .modal-content h2 {
     margin-top: 0;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .modal-content p {
-    color: #666;
+    color: var(--text-secondary);
     line-height: 1.5;
   }
 
   .modal-content .warning {
-    background-color: #fff3cd;
-    border-left: 4px solid #ffc107;
+    background-color: var(--badge-pending-bg);
+    border-left: 4px solid var(--color-warning);
     padding: 1rem;
     margin: 1rem 0;
-    color: #856404;
+    color: var(--badge-pending-text);
   }
 
   .modal-actions {
@@ -949,36 +924,36 @@
   .modal-button {
     padding: 0.75rem 1.5rem;
     border: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     cursor: pointer;
     font-weight: 500;
     transition: all 0.2s;
   }
 
   .modal-button.cancel {
-    background-color: #6c757d;
+    background-color: var(--color-secondary);
     color: white;
   }
 
   .modal-button.cancel:hover {
-    background-color: #5a6268;
+    background-color: var(--color-secondary-hover);
   }
 
   .modal-button.confirm {
-    background-color: #007bff;
+    background-color: var(--color-primary);
     color: white;
   }
 
   .modal-button.confirm:hover {
-    background-color: #0056b3;
+    background-color: var(--color-primary-hover);
   }
 
   .modal-button.delete-confirm {
-    background-color: #dc3545;
+    background-color: var(--color-error);
   }
 
   .modal-button.delete-confirm:hover {
-    background-color: #c82333;
+    background-color: var(--color-error-hover);
   }
 
   .role-options {
@@ -995,6 +970,50 @@
     cursor: pointer;
   }
 
+  .help-text {
+    color: var(--text-secondary);
+    font-style: italic;
+    margin-bottom: 1rem;
+  }
+
+  .awards-quick-actions {
+    margin-bottom: 2rem;
+  }
+
+  .awards-info {
+    background-color: var(--bg-secondary);
+    border-left: 4px solid #667eea;
+    padding: 1.5rem;
+    border-radius: var(--border-radius);
+  }
+
+  .awards-info h3 {
+    margin-top: 0;
+    margin-bottom: 1rem;
+    color: var(--text-primary);
+  }
+
+  .awards-info p {
+    margin-bottom: 1rem;
+  }
+
+  .awards-info ul {
+    margin-bottom: 1rem;
+    padding-left: 1.5rem;
+  }
+
+  .awards-info li {
+    margin-bottom: 0.5rem;
+  }
+
+  .awards-info code {
+    background-color: var(--border-color);
+    padding: 0.2rem 0.4rem;
+    border-radius: 3px;
+    font-family: monospace;
+    font-size: 0.9rem;
+  }
+
   @media (max-width: 768px) {
     .users-header {
       flex-direction: column;

src/frontend/src/routes/admin/awards/+page.svelte

@@ -0,0 +1,380 @@
+<script>
+  import { onMount } from 'svelte';
+  import { auth } from '$lib/stores.js';
+  import { awardsAdminAPI } from '$lib/api.js';
+  import { browser } from '$app/environment';
+
+  let loading = true;
+  let error = null;
+  let awards = [];
+  let searchQuery = '';
+  let categoryFilter = 'all';
+
+  onMount(async () => {
+    if (!$auth.user) {
+      window.location.href = '/auth/login';
+      return;
+    }
+
+    if (!$auth.user.isAdmin) {
+      error = 'Admin access required';
+      loading = false;
+      return;
+    }
+
+    await loadAwards();
+    loading = false;
+  });
+
+  async function loadAwards() {
+    try {
+      const data = await awardsAdminAPI.getAll();
+      awards = data.awards || [];
+    } catch (err) {
+      error = err.message;
+    }
+  }
+
+  async function handleDelete(id) {
+    const award = awards.find(a => a.id === id);
+    if (!award) return;
+
+    if (!confirm(`Are you sure you want to delete award "${award.name}"?\n\nThis action cannot be undone.`)) {
+      return;
+    }
+
+    try {
+      loading = true;
+      await awardsAdminAPI.delete(id);
+      await loadAwards();
+    } catch (err) {
+      alert('Failed to delete award: ' + err.message);
+    } finally {
+      loading = false;
+    }
+  }
+
+  function getRuleTypeDisplayName(ruleType) {
+    const names = {
+      'entity': 'Entity',
+      'dok': 'DOK',
+      'points': 'Points',
+      'filtered': 'Filtered',
+      'counter': 'Counter'
+    };
+    return names[ruleType] || ruleType;
+  }
+
+  function getCategoryColor(category) {
+    const colors = {
+      'dxcc': 'purple',
+      'darc': 'orange',
+      'vucc': 'blue',
+      'was': 'green',
+      'special': 'red',
+    };
+    return colors[category] || 'gray';
+  }
+
+  $: filteredAwards = awards.filter(award => {
+    const matchesSearch = !searchQuery ||
+      award.name.toLowerCase().includes(searchQuery.toLowerCase()) ||
+      award.id.toLowerCase().includes(searchQuery.toLowerCase()) ||
+      award.category.toLowerCase().includes(searchQuery.toLowerCase());
+
+    const matchesCategory = categoryFilter === 'all' || award.category === categoryFilter;
+
+    return matchesSearch && matchesCategory;
+  });
+
+  $: categories = [...new Set(awards.map(a => a.category))].sort();
+</script>
+
+{#if loading && awards.length === 0}
+  <div class="loading">Loading award definitions...</div>
+{:else if error}
+  <div class="error">{error}</div>
+{:else}
+  <div class="awards-admin">
+    <div class="header">
+      <h1>Award Definitions</h1>
+      <a href="/admin/awards/create" class="btn btn-primary">Create New Award</a>
+    </div>
+
+    <div class="filters">
+      <input
+        type="text"
+        class="search-input"
+        placeholder="Search by name, ID, or category..."
+        bind:value={searchQuery}
+      />
+      <select class="category-filter" bind:value={categoryFilter}>
+        <option value="all">All Categories</option>
+        {#each categories as category}
+          <option value={category}>{category}</option>
+        {/each}
+      </select>
+    </div>
+
+    <div class="awards-table-container">
+      <table class="awards-table">
+        <thead>
+          <tr>
+            <th>ID</th>
+            <th>Name</th>
+            <th>Category</th>
+            <th>Rule Type</th>
+            <th>Target</th>
+            <th>Actions</th>
+          </tr>
+        </thead>
+        <tbody>
+          {#each filteredAwards as award}
+            <tr>
+              <td class="id-cell">{award.id}</td>
+              <td>
+                <div class="name-cell">
+                  <strong>{award.name}</strong>
+                  <small>{award.description}</small>
+                </div>
+              </td>
+              <td>
+                <span class="category-badge {getCategoryColor(award.category)}">
+                  {award.category}
+                </span>
+              </td>
+              <td>{getRuleTypeDisplayName(award.rules.type)}</td>
+              <td>{award.rules.target || '-'}</td>
+              <td class="actions-cell">
+                <a href="/admin/awards/{award.id}" class="action-btn edit-btn">Edit</a>
+                <a href="/awards/{award.id}" target="_blank" class="action-btn view-btn">View</a>
+                <button
+                  class="action-btn delete-btn"
+                  on:click={() => handleDelete(award.id)}
+                >
+                  Delete
+                </button>
+              </td>
+            </tr>
+          {/each}
+        </tbody>
+      </table>
+    </div>
+
+    <p class="count">Showing {filteredAwards.length} award(s)</p>
+  </div>
+{/if}
+
+<style>
+  .awards-admin {
+    padding: 2rem;
+    max-width: 1400px;
+    margin: 0 auto;
+  }
+
+  .loading {
+    text-align: center;
+    padding: 3rem;
+    font-size: 1.2rem;
+    color: var(--text-secondary);
+  }
+
+  .error {
+    background-color: var(--color-error-bg);
+    border: 1px solid var(--color-error);
+    padding: 1rem;
+    border-radius: var(--border-radius);
+    color: var(--color-error);
+    margin: 2rem;
+  }
+
+  .header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1.5rem;
+    flex-wrap: wrap;
+    gap: 1rem;
+  }
+
+  .header h1 {
+    margin: 0;
+    color: var(--text-primary);
+  }
+
+  .filters {
+    display: flex;
+    gap: 1rem;
+    margin-bottom: 1.5rem;
+    flex-wrap: wrap;
+  }
+
+  .search-input,
+  .category-filter {
+    padding: 0.5rem 0.75rem;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    font-size: 0.9rem;
+    background: var(--bg-input);
+    color: var(--text-primary);
+  }
+
+  .search-input {
+    flex: 1;
+    min-width: 250px;
+  }
+
+  .category-filter {
+    min-width: 150px;
+  }
+
+  .btn {
+    padding: 0.6rem 1.2rem;
+    border: none;
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-weight: 500;
+    text-decoration: none;
+    display: inline-block;
+    transition: all 0.2s;
+  }
+
+  .btn-primary {
+    background-color: var(--color-primary);
+    color: var(--text-inverted);
+  }
+
+  .btn-primary:hover {
+    background-color: var(--color-primary-hover);
+  }
+
+  .awards-table-container {
+    overflow-x: auto;
+    background: var(--bg-card);
+    border-radius: var(--border-radius-lg);
+    box-shadow: var(--shadow-sm);
+  }
+
+  .awards-table {
+    width: 100%;
+    border-collapse: collapse;
+  }
+
+  .awards-table th,
+  .awards-table td {
+    padding: 0.75rem 1rem;
+    text-align: left;
+    border-bottom: 1px solid var(--border-color);
+    color: var(--text-primary);
+  }
+
+  .awards-table th {
+    background-color: var(--bg-hover);
+    font-weight: 600;
+    text-transform: uppercase;
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+  }
+
+  .awards-table tr:hover {
+    background-color: var(--bg-secondary);
+  }
+
+  .id-cell {
+    font-family: monospace;
+    color: var(--text-secondary);
+    font-size: 0.9rem;
+  }
+
+  .name-cell {
+    display: flex;
+    flex-direction: column;
+  }
+
+  .name-cell small {
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    margin-top: 0.25rem;
+  }
+
+  .category-badge {
+    padding: 0.25rem 0.75rem;
+    border-radius: 12px;
+    font-size: 0.8rem;
+    font-weight: 600;
+    display: inline-block;
+  }
+
+  .category-badge.purple { background-color: #9b59b6; color: white; }
+  .category-badge.orange { background-color: #e67e22; color: white; }
+  .category-badge.blue { background-color: #3498db; color: white; }
+  .category-badge.green { background-color: #27ae60; color: white; }
+  .category-badge.red { background-color: #e74c3c; color: white; }
+  .category-badge.gray { background-color: #95a5a6; color: white; }
+
+  .actions-cell {
+    white-space: nowrap;
+  }
+
+  .action-btn {
+    padding: 0.4rem 0.8rem;
+    margin-right: 0.3rem;
+    border: none;
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-size: 0.85rem;
+    text-decoration: none;
+    display: inline-block;
+    transition: all 0.2s;
+    color: var(--text-inverted);
+  }
+
+  .edit-btn {
+    background-color: #3498db;
+  }
+
+  .edit-btn:hover {
+    background-color: #2980b9;
+  }
+
+  .view-btn {
+    background-color: #27ae60;
+  }
+
+  .view-btn:hover {
+    background-color: #219a52;
+  }
+
+  .delete-btn {
+    background-color: #e74c3c;
+  }
+
+  .delete-btn:hover {
+    background-color: #c0392b;
+  }
+
+  .count {
+    margin-top: 1rem;
+    color: var(--text-secondary);
+    font-style: italic;
+  }
+
+  @media (max-width: 768px) {
+    .awards-admin {
+      padding: 1rem;
+    }
+
+    .header {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .filters {
+      flex-direction: column;
+    }
+
+    .search-input {
+      width: 100%;
+    }
+  }
+</style>

src/frontend/src/routes/admin/awards/components/FilterBuilder.svelte

@@ -0,0 +1,486 @@
+<script>
+  import { createEventDispatcher } from 'svelte';
+
+  export let filters = null;
+  export let onChange = () => {};
+
+  const dispatch = createEventDispatcher();
+
+  const ALL_FIELDS = [
+    { value: 'band', label: 'Band' },
+    { value: 'mode', label: 'Mode' },
+    { value: 'callsign', label: 'Callsign' },
+    { value: 'entity', label: 'Entity (Country)' },
+    { value: 'entityId', label: 'Entity ID' },
+    { value: 'state', label: 'State' },
+    { value: 'grid', label: 'Grid Square' },
+    { value: 'satName', label: 'Satellite Name' },
+    { value: 'satellite', label: 'Is Satellite QSO' },
+  ];
+
+  const OPERATORS = [
+    { value: 'eq', label: 'Equals', needsArray: false },
+    { value: 'ne', label: 'Not Equals', needsArray: false },
+    { value: 'in', label: 'In', needsArray: true },
+    { value: 'nin', label: 'Not In', needsArray: true },
+    { value: 'contains', label: 'Contains', needsArray: false },
+  ];
+
+  const BAND_OPTIONS = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m', '6m', '2m', '70cm', '23cm', '13cm', '9cm', '6cm', '3cm'];
+  const MODE_OPTIONS = ['CW', 'SSB', 'AM', 'FM', 'RTTY', 'PSK31', 'FT8', 'FT4', 'JT65', 'JT9', 'MFSK', 'Q65', 'JS8', 'FSK441', 'ISCAT', 'JT6M', 'MSK144'];
+
+  // Add a new filter
+  function addFilter() {
+    if (!filters) {
+      filters = { operator: 'AND', filters: [] };
+    }
+    if (!filters.filters) {
+      filters.filters = [];
+    }
+    filters.filters.push({
+      field: 'band',
+      operator: 'eq',
+      value: ''
+    });
+    updateFilters();
+  }
+
+  // Add a nested filter group
+  function addFilterGroup() {
+    if (!filters) {
+      filters = { operator: 'AND', filters: [] };
+    }
+    if (!filters.filters) {
+      filters.filters = [];
+    }
+    filters.filters.push({
+      operator: 'AND',
+      filters: []
+    });
+    updateFilters();
+  }
+
+  // Remove a filter at index
+  function removeFilter(index) {
+    if (filters && filters.filters) {
+      filters.filters.splice(index, 1);
+      // If no filters left, set to null
+      if (filters.filters.length === 0) {
+        filters = null;
+      }
+      updateFilters();
+    }
+  }
+
+  // Update a filter at index
+  function updateFilter(index, key, value) {
+    if (filters && filters.filters) {
+      filters.filters[index][key] = value;
+      updateFilters();
+    }
+  }
+
+  // Update filter operator (AND/OR)
+  function updateOperator(operator) {
+    if (filters) {
+      filters.operator = operator;
+      updateFilters();
+    }
+  }
+
+  // Get input type based on field and operator
+  function getInputType(field, operator) {
+    const opConfig = OPERATORS.find(o => o.value === operator);
+    const needsArray = opConfig?.needsArray || false;
+
+    if (field === 'band' && needsArray) return 'band-multi';
+    if (field === 'band') return 'band';
+    if (field === 'mode' && needsArray) return 'mode-multi';
+    if (field === 'mode') return 'mode';
+    if (field === 'satellite') return 'boolean';
+    if (needsArray) return 'text-array';
+    return 'text';
+  }
+
+  // Notify parent of changes
+  function updateFilters() {
+    // Deep clone to avoid reactivity issues
+    const cloned = filters ? JSON.parse(JSON.stringify(filters)) : null;
+    onChange(cloned);
+    dispatch('change', cloned);
+  }
+
+  // Check if a filter is a group (has nested filters)
+  function isFilterGroup(filter) {
+    return filter && typeof filter === 'object' && filter.filters !== undefined;
+  }
+</script>
+
+<div class="filter-builder">
+  {#if !filters || !filters.filters || filters.filters.length === 0}
+    <div class="no-filters">
+      <p>No filters defined. All QSOs will be evaluated.</p>
+      <button class="btn btn-secondary" on:click={addFilter}>Add Filter</button>
+    </div>
+  {:else}
+    <div class="filter-group">
+      <div class="filter-group-header">
+        <h4>Filters</h4>
+        <div class="operator-selector">
+          <label>
+            <input
+              type="radio"
+              bind:group={filters.operator}
+              value="AND"
+              on:change={() => updateOperator('AND')}
+            />
+            AND
+          </label>
+          <label>
+            <input
+              type="radio"
+              bind:group={filters.operator}
+              value="OR"
+              on:change={() => updateOperator('OR')}
+            />
+            OR
+          </label>
+        </div>
+      </div>
+
+      <div class="filter-list">
+        {#each filters.filters as filter, index}
+          <div class="filter-item">
+            {#if isFilterGroup(filter)}
+              <!-- Nested filter group -->
+              <div class="nested-filter-group">
+                <div class="nested-header">
+                  <span class="group-label">Group ({filter.operator})</span>
+                  <button class="btn-remove" on:click={() => removeFilter(index)}>Remove</button>
+                </div>
+                <svelte:self filters={filter} onChange={(nested) => updateFilter(index, nested)} />
+              </div>
+            {:else}
+              <!-- Single filter -->
+              <div class="single-filter">
+                <select
+                  class="field-select"
+                  bind:value={filter.field}
+                  on:change={() => updateFilter(index, 'field', filter.field)}
+                >
+                  {#each ALL_FIELDS as field}
+                    <option value={field.value}>{field.label}</option>
+                  {/each}
+                </select>
+
+                <select
+                  class="operator-select"
+                  bind:value={filter.operator}
+                  on:change={() => updateFilter(index, 'operator', filter.operator)}
+                >
+                  {#each OPERATORS as op}
+                    <option value={op.value}>{op.label}</option>
+                  {/each}
+                </select>
+
+                <div class="filter-value">
+                  {#if getInputType(filter.field, filter.operator) === 'band'}
+                    <select bind:value={filter.value} on:change={() => updateFilter(index, 'value', filter.value)}>
+                      <option value="">Select band</option>
+                      {#each BAND_OPTIONS as band}
+                        <option value={band}>{band}</option>
+                      {/each}
+                    </select>
+                  {:else if getInputType(filter.field, filter.operator) === 'band-multi'}
+                    <div class="multi-select">
+                      {#each BAND_OPTIONS as band}
+                        <label class="checkbox-option">
+                          <input
+                            type="checkbox"
+                            checked={Array.isArray(filter.value) && filter.value.includes(band)}
+                            on:change={(e) => {
+                              if (!Array.isArray(filter.value)) filter.value = [];
+                              if (e.target.checked) {
+                                filter.value = [...filter.value, band];
+                              } else {
+                                filter.value = filter.value.filter(v => v !== band);
+                              }
+                              updateFilter(index, 'value', filter.value);
+                            }}
+                          />
+                          {band}
+                        </label>
+                      {/each}
+                    </div>
+                  {:else if getInputType(filter.field, filter.operator) === 'mode'}
+                    <select bind:value={filter.value} on:change={() => updateFilter(index, 'value', filter.value)}>
+                      <option value="">Select mode</option>
+                      {#each MODE_OPTIONS as mode}
+                        <option value={mode}>{mode}</option>
+                      {/each}
+                    </select>
+                  {:else if getInputType(filter.field, filter.operator) === 'mode-multi'}
+                    <div class="multi-select">
+                      {#each MODE_OPTIONS as mode}
+                        <label class="checkbox-option">
+                          <input
+                            type="checkbox"
+                            checked={Array.isArray(filter.value) && filter.value.includes(mode)}
+                            on:change={(e) => {
+                              if (!Array.isArray(filter.value)) filter.value = [];
+                              if (e.target.checked) {
+                                filter.value = [...filter.value, mode];
+                              } else {
+                                filter.value = filter.value.filter(v => v !== mode);
+                              }
+                              updateFilter(index, 'value', filter.value);
+                            }}
+                          />
+                          {mode}
+                        </label>
+                      {/each}
+                    </div>
+                  {:else if getInputType(filter.field, filter.operator) === 'boolean'}
+                    <select bind:value={filter.value} on:change={() => updateFilter(index, 'value', filter.value)}>
+                      <option value="true">Yes</option>
+                      <option value="false">No</option>
+                    </select>
+                  {:else if getInputType(filter.field, filter.operator) === 'text-array'}
+                    <input
+                      type="text"
+                      placeholder="comma-separated values"
+                      value={Array.isArray(filter.value) ? filter.value.join(', ') : filter.value}
+                      on:change={(e) => {
+                        const values = e.target.value.split(',').map(v => v.trim()).filter(v => v);
+                        updateFilter(index, 'value', values);
+                      }}
+                    />
+                  {:else}
+                    <input
+                      type="text"
+                      placeholder="Value"
+                      bind:value={filter.value}
+                      on:change={() => updateFilter(index, 'value', filter.value)}
+                    />
+                  {/if}
+                </div>
+
+                <button class="btn-remove" on:click={() => removeFilter(index)}>Remove</button>
+              </div>
+            {/if}
+          </div>
+        {/each}
+      </div>
+
+      <div class="filter-actions">
+        <button class="btn btn-secondary" on:click={addFilter}>Add Filter</button>
+        <button class="btn btn-secondary" on:click={addFilterGroup}>Add Filter Group</button>
+        <button class="btn btn-danger" on:click={() => { filters = null; updateFilters(); }}>Clear All Filters</button>
+      </div>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .filter-builder {
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    padding: 1.5rem;
+    background: var(--bg-secondary);
+  }
+
+  .no-filters {
+    text-align: center;
+    padding: 1rem;
+    color: var(--text-secondary);
+  }
+
+  .filter-group {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+  }
+
+  .filter-group-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+  }
+
+  .filter-group-header h4 {
+    margin: 0;
+    color: var(--text-primary);
+  }
+
+  .operator-selector {
+    display: flex;
+    gap: 1rem;
+  }
+
+  .operator-selector label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    cursor: pointer;
+    color: var(--text-primary);
+  }
+
+  .filter-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+  }
+
+  .filter-item {
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    padding: 1rem;
+  }
+
+  .single-filter {
+    display: flex;
+    gap: 0.5rem;
+    align-items: center;
+    flex-wrap: wrap;
+  }
+
+  .single-filter select,
+  .single-filter input {
+    padding: 0.5rem;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    font-size: 0.9rem;
+    background: var(--bg-input);
+    color: var(--text-primary);
+  }
+
+  .field-select {
+    min-width: 150px;
+  }
+
+  .operator-select {
+    min-width: 120px;
+  }
+
+  .filter-value {
+    flex: 1;
+    min-width: 200px;
+  }
+
+  .filter-value select,
+  .filter-value input {
+    width: 100%;
+  }
+
+  .nested-filter-group {
+    border-left: 3px solid var(--color-primary);
+    padding-left: 1rem;
+  }
+
+  .nested-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+  }
+
+  .group-label {
+    font-weight: 500;
+    color: var(--color-primary);
+  }
+
+  .multi-select {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+
+  .checkbox-option {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    padding: 0.25rem 0.5rem;
+    background: var(--bg-hover);
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-size: 0.85rem;
+    color: var(--text-primary);
+  }
+
+  .checkbox-option input {
+    cursor: pointer;
+  }
+
+  .btn-remove {
+    background-color: var(--color-error);
+    color: var(--text-inverted);
+    padding: 0.4rem 0.8rem;
+    border: none;
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-size: 0.85rem;
+  }
+
+  .btn-remove:hover {
+    background-color: #c82333;
+  }
+
+  .filter-actions {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+    margin-top: 1rem;
+    padding-top: 1rem;
+    border-top: 1px solid var(--border-color);
+  }
+
+  .btn {
+    padding: 0.5rem 1rem;
+    border: none;
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-weight: 500;
+    font-size: 0.9rem;
+    color: var(--text-inverted);
+  }
+
+  .btn-secondary {
+    background-color: #6c757d;
+  }
+
+  .btn-secondary:hover {
+    background-color: #5a6268;
+  }
+
+  .btn-danger {
+    background-color: var(--color-error);
+  }
+
+  .btn-danger:hover {
+    background-color: #c82333;
+  }
+
+  @media (max-width: 768px) {
+    .single-filter {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .field-select,
+    .operator-select,
+    .filter-value {
+      width: 100%;
+      min-width: unset;
+    }
+
+    .filter-actions {
+      flex-direction: column;
+    }
+
+    .filter-actions button {
+      width: 100%;
+    }
+  }
+</style>

src/frontend/src/routes/admin/awards/components/TestAwardModal.svelte

@@ -0,0 +1,841 @@
+<script>
+  import { onMount } from 'svelte';
+  import { awardsAdminAPI, adminAPI } from '$lib/api.js';
+
+  export let awardId = null;
+  export let awardDefinition = null;
+  export let onClose = () => {};
+
+  let loading = false;
+  let testResult = null;
+  let testError = null;
+  let users = [];
+  let selectedUserId = null;
+
+  // Extended validation results
+  let logicValidation = null;
+
+  onMount(async () => {
+    await loadUsers();
+    if (awardDefinition) {
+      performLogicValidation();
+    }
+  });
+
+  async function loadUsers() {
+    try {
+      const data = await adminAPI.getUsers();
+      users = data.users || [];
+    } catch (err) {
+      console.error('Failed to load users:', err);
+    }
+  }
+
+  async function runTest() {
+    if (!awardId) return;
+
+    loading = true;
+    testResult = null;
+    testError = null;
+
+    try {
+      // Pass awardDefinition for unsaved awards (testing during create/edit)
+      const data = await awardsAdminAPI.test(awardId, selectedUserId, awardDefinition);
+      testResult = data;
+    } catch (err) {
+      testError = err.message;
+    } finally {
+      loading = false;
+    }
+  }
+
+  // Perform deep logic validation on award definition
+  function performLogicValidation() {
+    if (!awardDefinition) return;
+
+    const issues = {
+      errors: [],
+      warnings: [],
+      info: []
+    };
+
+    const rules = awardDefinition.rules;
+
+    // 1. Check for impossible filter combinations
+    if (rules.filters) {
+      const impossibleFilterCombos = checkImpossibleFilters(rules.filters, rules);
+      issues.errors.push(...impossibleFilterCombos.errors);
+      issues.warnings.push(...impossibleFilterCombos.warnings);
+    }
+
+    // 2. Check for redundancy
+    const redundancies = checkRedundancies(rules);
+    issues.warnings.push(...redundancies.warnings);
+    issues.info.push(...redundancies.info);
+
+    // 3. Check for logical contradictions
+    const contradictions = checkContradictions(rules);
+    issues.errors.push(...contradictions.errors);
+    issues.warnings.push(...contradictions.warnings);
+
+    // 4. Check for edge cases that might cause issues
+    const edgeCases = checkEdgeCases(rules);
+    issues.info.push(...edgeCases);
+
+    // 5. Provide helpful suggestions
+    const suggestions = provideSuggestions(rules);
+    issues.info.push(...suggestions);
+
+    logicValidation = issues;
+  }
+
+  // Check for impossible filter combinations
+  function checkImpossibleFilters(filters, rules) {
+    const errors = [];
+    const warnings = [];
+
+    function analyze(filterNode, depth = 0) {
+      if (!filterNode || !filterNode.filters) return;
+
+      // Group filters by field to check for contradictions
+      const fieldFilters = {};
+      for (const f of filterNode.filters) {
+        if (f.field) {
+          if (!fieldFilters[f.field]) fieldFilters[f.field] = [];
+          fieldFilters[f.field].push(f);
+        } else if (f.filters) {
+          analyze(f, depth + 1);
+        }
+      }
+
+      // Check for contradictions in AND groups
+      if (filterNode.operator === 'AND') {
+        for (const [field, fieldFiltersList] of Object.entries(fieldFilters)) {
+          // Check for direct contradictions: field=X AND field=Y
+          const eqFilters = fieldFiltersList.filter(f => f.operator === 'eq');
+          const neFilters = fieldFiltersList.filter(f => f.operator === 'ne');
+
+          for (const eq1 of eqFilters) {
+            for (const eq2 of eqFilters) {
+              if (eq1 !== eq2 && eq1.value !== eq2.value) {
+                errors.push(`Impossible filter: ${field} cannot be both "${eq1.value}" AND "${eq2.value}"`);
+              }
+            }
+
+            for (const ne of neFilters) {
+              if (eq1.value === ne.value) {
+                errors.push(`Impossible filter: ${field} cannot be "${eq1.value}" AND not "${ne.value}" at the same time`);
+              }
+            }
+          }
+
+          // Check for in/nin contradictions
+          const inFilters = fieldFiltersList.filter(f => f.operator === 'in');
+          const ninFilters = fieldFiltersList.filter(f => f.operator === 'nin');
+
+          for (const inF of inFilters) {
+            if (Array.isArray(inF.value)) {
+              for (const ninF of ninFilters) {
+                if (Array.isArray(ninF.value)) {
+                  const overlap = inF.value.filter(v => ninF.value.includes(v));
+                  if (overlap.length > 0 && overlap.length === inF.value.length) {
+                    errors.push(`Impossible filter: ${field} must be in ${inF.value.join(', ')} AND not in ${overlap.join(', ')}`);
+                  } else if (overlap.length > 0) {
+                    warnings.push(`Suspicious filter: ${field} filter has overlapping values: ${overlap.join(', ')}`);
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      // Check for redundant OR groups (field=X OR field=X)
+      if (filterNode.operator === 'OR') {
+        for (const [field, fieldFiltersList] of Object.entries(fieldFilters)) {
+          const eqFilters = fieldFiltersList.filter(f => f.operator === 'eq');
+
+          for (let i = 0; i < eqFilters.length; i++) {
+            for (let j = i + 1; j < eqFilters.length; j++) {
+              if (eqFilters[i].value === eqFilters[j].value) {
+                warnings.push(`Redundant filter: ${field}="${eqFilters[i].value}" appears multiple times in OR group`);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    analyze(filters);
+    return { errors, warnings };
+  }
+
+  // Check for redundancies in the definition
+  function checkRedundancies(rules) {
+    const warnings = [];
+    const info = [];
+
+    // Check if satellite_only is redundant when filters already check for satellite
+    if (rules.satellite_only && rules.filters) {
+      const satFilter = findSatelliteFilter(rules.filters);
+      if (satFilter && satFilter.operator === 'eq' && satFilter.value === true) {
+        info.push('satellite_only=true is set, but filters already check for satellite QSOs. The filter is redundant.');
+      }
+    }
+
+    // Check if allowed_bands makes filters redundant
+    if (rules.allowed_bands && rules.allowed_bands.length > 0 && rules.filters) {
+      const bandFilters = extractBandFilters(rules.filters);
+      for (const bf of bandFilters) {
+        if (bf.operator === 'in' && Array.isArray(bf.value)) {
+          const allCovered = bf.value.every(b => rules.allowed_bands.includes(b));
+          if (allCovered) {
+            info.push(`allowed_bands already includes all bands in the filter. Consider removing the filter.`);
+          }
+        }
+      }
+    }
+
+    // Check if displayField matches the default for the entity type
+    if (rules.entityType && rules.displayField) {
+      const defaults = {
+        'dxcc': 'entity',
+        'state': 'state',
+        'grid': 'grid',
+        'callsign': 'callsign'
+      };
+      if (defaults[rules.entityType] === rules.displayField) {
+        info.push(`displayField="${rules.displayField}" is the default for entityType="${rules.entityType}". It can be omitted.`);
+      }
+    }
+
+    return { warnings, info };
+  }
+
+  // Check for logical contradictions
+  function checkContradictions(rules) {
+    const errors = [];
+    const warnings = [];
+
+    // Check satellite_only with HF-only allowed_bands
+    if (rules.satellite_only && rules.allowed_bands) {
+      const hfBands = ['160m', '80m', '60m', '40m', '30m', '20m', '17m', '15m', '12m', '10m'];
+      const hasHfOnly = rules.allowed_bands.length > 0 &&
+        rules.allowed_bands.every(b => hfBands.includes(b));
+
+      if (hasHfOnly) {
+        warnings.push('satellite_only is set but allowed_bands only includes HF bands. Satellite work typically uses VHF/UHF bands.');
+      }
+    }
+
+    // For DOK rules, verify confirmation type
+    if (rules.type === 'dok' && rules.confirmationType && rules.confirmationType !== 'dcl') {
+      warnings.push('DOK awards typically require DCL confirmation (confirmationType="dcl").');
+    }
+
+    // Check for impossible targets
+    if (rules.target) {
+      if (rules.type === 'entity' && rules.entityType === 'dxcc' && rules.target > 340) {
+        warnings.push(`Target (${rules.target}) exceeds the total number of DXCC entities (~340).`);
+      }
+
+      if (rules.type === 'dok' && rules.target > 700) {
+        info.push(`Target (${rules.target}) is high. There are ~700 DOKs in Germany.`);
+      }
+    }
+
+    return { errors, warnings };
+  }
+
+  // Check for edge cases
+  function checkEdgeCases(rules) {
+    const info = [];
+
+    if (rules.filters) {
+      const filterCount = countFilters(rules.filters);
+      if (filterCount > 10) {
+        info.push(`Complex filter structure (${filterCount} filters). Consider simplifying for better performance.`);
+      }
+    }
+
+    if (rules.modeGroups) {
+      const totalModes = Object.values(rules.modeGroups).reduce((sum, modes) => sum + (modes?.length || 0), 0);
+      if (totalModes > 20) {
+        info.push('Many mode groups defined. Make sure users understand the grouping logic.');
+      }
+    }
+
+    if (rules.type === 'points' && rules.stations) {
+      const totalPossiblePoints = rules.stations.reduce((sum, s) => sum + (s.points || 0), 0);
+      if (totalPossiblePoints < rules.target) {
+        info.push(`Even with all stations confirmed, max points (${totalPossiblePoints}) is less than target (${rules.target}). Award is impossible to complete.`);
+      }
+    }
+
+    return info;
+  }
+
+  // Provide helpful suggestions
+  function provideSuggestions(rules) {
+    const info = [];
+
+    // Suggest common award patterns
+    if (rules.type === 'entity' && rules.entityType === 'dxcc' && !rules.allowed_bands) {
+      info.push('Consider adding allowed_bands to restrict to specific bands (e.g., HF only: ["160m", "80m", ...]).');
+    }
+
+    if (rules.type === 'entity' && !rules.modeGroups && ['dxcc', 'dld'].includes(rules.entityType)) {
+      info.push('Consider adding modeGroups to help users filter by mode type (e.g., "Digi-Modes", "Phone-Modes").');
+    }
+
+    if (rules.type === 'dok' && !rules.filters) {
+      info.push('DOK awards can have band/mode filters via the filters property. Consider adding them for specific variations.');
+    }
+
+    return info;
+  }
+
+  // Helper: Find satellite-related filter
+  function findSatelliteFilter(filters, depth = 0) {
+    if (!filters || depth > 5) return null;
+
+    if (filters.field === 'satellite' || filters.field === 'satName') {
+      return filters;
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        const found = findSatelliteFilter(f, depth + 1);
+        if (found) return found;
+      }
+    }
+
+    return null;
+  }
+
+  // Helper: Extract band filters
+  function extractBandFilters(filters, depth = 0) {
+    if (!filters || depth > 5) return [];
+
+    const result = [];
+
+    if (filters.field === 'band') {
+      result.push(filters);
+    }
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        result.push(...extractBandFilters(f, depth + 1));
+      }
+    }
+
+    return result;
+  }
+
+  // Helper: Count total filters
+  function countFilters(filters, depth = 0) {
+    if (!filters || depth > 5) return 0;
+
+    let count = 0;
+
+    if (filters.filters) {
+      for (const f of filters.filters) {
+        if (f.filters) {
+          count += 1 + countFilters(f, depth + 1);
+        } else {
+          count += 1;
+        }
+      }
+    }
+
+    return count;
+  }
+
+  function getSeverityClass(type) {
+    switch (type) {
+      case 'error': return 'severity-error';
+      case 'warning': return 'severity-warning';
+      case 'info': return 'severity-info';
+      default: return '';
+    }
+  }
+</script>
+
+{#if logicValidation || testResult || testError}
+  <div class="modal-overlay" on:click={onClose}>
+    <div class="modal-content large" on:click|stopPropagation>
+      <div class="modal-header">
+        <h2>{testResult ? 'Test Results' : 'Award Validation'}{awardId ? `: ${awardId}` : ''}</h2>
+        <button class="close-btn" on:click={onClose}>×</button>
+      </div>
+
+      <div class="modal-body">
+        <!-- Logic Validation Section -->
+        {#if logicValidation && (logicValidation.errors.length > 0 || logicValidation.warnings.length > 0 || logicValidation.info.length > 0)}
+          <div class="validation-section">
+            <h3>Logic Validation</h3>
+
+            {#if logicValidation.errors.length > 0}
+              <div class="validation-block errors">
+                <h4>Errors (must fix)</h4>
+                <ul>
+                  {#each logicValidation.errors as err}
+                    <li class="severity-error">{err}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if logicValidation.warnings.length > 0}
+              <div class="validation-block warnings">
+                <h4>Warnings</h4>
+                <ul>
+                  {#each logicValidation.warnings as warn}
+                    <li class="severity-warning">{warn}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if logicValidation.info.length > 0}
+              <div class="validation-block info">
+                <h4>Suggestions</h4>
+                <ul>
+                  {#each logicValidation.info as info}
+                    <li class="severity-info">{info}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if logicValidation.errors.length === 0 && logicValidation.warnings.length === 0}
+              <div class="validation-block success">
+                <p>No issues found. The award definition looks good!</p>
+              </div>
+            {/if}
+          </div>
+        {/if}
+
+        <!-- Test Configuration -->
+        <div class="test-config">
+          <h3>Test Calculation</h3>
+          <p class="help-text">Select a user to test the award calculation with their QSO data.</p>
+
+          <div class="user-selector">
+            <label for="test-user">Test with user:</label>
+            <select id="test-user" bind:value={selectedUserId}>
+              <option value="">-- Select a user --</option>
+              {#each users as user}
+                <option value={user.id}>{user.callsign} ({user.email}) - {user.qsoCount || 0} QSOs</option>
+              {/each}
+            </select>
+          </div>
+
+          <button
+            class="btn btn-primary"
+            on:click={runTest}
+            disabled={loading || !selectedUserId || !awardId}
+          >
+            {loading ? 'Testing...' : 'Run Test'}
+          </button>
+        </div>
+
+        <!-- Test Results -->
+        {#if testError}
+          <div class="test-results error">
+            <h4>Test Failed</h4>
+            <p>{testError}</p>
+          </div>
+        {:else if testResult}
+          <div class="test-results success">
+            <h4>Test Results</h4>
+
+            <div class="result-summary">
+              <div class="result-item">
+                <span class="label">Award:</span>
+                <span class="value">{testResult.award?.name || awardId}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Worked:</span>
+                <span class="value">{testResult.worked || 0}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Confirmed:</span>
+                <span class="value confirmed">{testResult.confirmed || 0}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Target:</span>
+                <span class="value">{testResult.target || 0}</span>
+              </div>
+              <div class="result-item">
+                <span class="label">Progress:</span>
+                <span class="value progress">{testResult.percentage || 0}%</span>
+              </div>
+            </div>
+
+            {#if testResult.warnings && testResult.warnings.length > 0}
+              <div class="result-warnings">
+                <h5>Warnings:</h5>
+                <ul>
+                  {#each testResult.warnings as warning}
+                    <li>{warning}</li>
+                  {/each}
+                </ul>
+              </div>
+            {/if}
+
+            {#if testResult.sampleEntities && testResult.sampleEntities.length > 0}
+              <div class="sample-entities">
+                <h5>Sample Matched Entities (first {testResult.sampleEntities.length}):</h5>
+                <div class="entities-list">
+                  {#each testResult.sampleEntities as entity}
+                    <span class="entity-tag">{entity}</span>
+                  {/each}
+                </div>
+              </div>
+            {:else}
+              <div class="no-matches">
+                <p>No entities matched. Check filters and band/mode restrictions.</p>
+              </div>
+            {/if}
+          </div>
+        {/if}
+      </div>
+
+      <div class="modal-footer">
+        <button class="btn btn-secondary" on:click={onClose}>Close</button>
+      </div>
+    </div>
+  </div>
+{/if}
+
+<style>
+  .modal-overlay {
+    position: fixed;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: rgba(0, 0, 0, 0.5);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    z-index: 1000;
+    padding: 1rem;
+  }
+
+  .modal-content {
+    background: var(--bg-card);
+    border-radius: var(--border-radius-lg);
+    max-width: 800px;
+    width: 100%;
+    max-height: 90vh;
+    overflow: hidden;
+    display: flex;
+    flex-direction: column;
+    box-shadow: var(--shadow-md);
+  }
+
+  .modal-content.large {
+    max-width: 900px;
+  }
+
+  .modal-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  .modal-header h2 {
+    margin: 0;
+    color: var(--text-primary);
+  }
+
+  .close-btn {
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    cursor: pointer;
+    color: var(--text-muted);
+    padding: 0;
+    width: 2rem;
+    height: 2rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+  }
+
+  .close-btn:hover {
+    color: var(--text-primary);
+  }
+
+  .modal-body {
+    padding: 1.5rem;
+    overflow-y: auto;
+    flex: 1;
+  }
+
+  .validation-section {
+    margin-bottom: 2rem;
+  }
+
+  .validation-section h3 {
+    margin: 0 0 1rem 0;
+    color: var(--text-primary);
+  }
+
+  .validation-block {
+    padding: 1rem;
+    border-radius: var(--border-radius);
+    margin-bottom: 1rem;
+  }
+
+  .validation-block h4 {
+    margin: 0 0 0.75rem 0;
+    font-size: 1rem;
+    color: var(--text-primary);
+  }
+
+  .validation-block.errors {
+    background-color: var(--color-error-bg);
+    border-left: 4px solid var(--color-error);
+  }
+
+  .validation-block.warnings {
+    background-color: var(--color-warning-bg);
+    border-left: 4px solid var(--color-warning);
+  }
+
+  .validation-block.info {
+    background-color: var(--color-info-bg);
+    border-left: 4px solid var(--color-info);
+  }
+
+  .validation-block.success {
+    background-color: var(--color-success-bg);
+    border-left: 4px solid var(--color-success);
+  }
+
+  .validation-block ul {
+    margin: 0;
+    padding-left: 1.5rem;
+  }
+
+  .validation-block li {
+    margin-bottom: 0.5rem;
+    color: var(--text-primary);
+  }
+
+  .severity-error {
+    color: var(--color-error);
+  }
+
+  .severity-warning {
+    color: var(--color-warning);
+  }
+
+  .severity-info {
+    color: var(--color-info);
+  }
+
+  .test-config {
+    border-top: 1px solid var(--border-color);
+    padding-top: 1.5rem;
+  }
+
+  .test-config h3 {
+    margin: 0 0 0.5rem 0;
+    color: var(--text-primary);
+  }
+
+  .help-text {
+    color: var(--text-secondary);
+    font-size: 0.9rem;
+    margin-bottom: 1rem;
+  }
+
+  .user-selector {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+    margin-bottom: 1rem;
+  }
+
+  .user-selector label {
+    font-weight: 500;
+    color: var(--text-primary);
+  }
+
+  .user-selector select {
+    flex: 1;
+    padding: 0.5rem;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    background: var(--bg-input);
+    color: var(--text-primary);
+  }
+
+  .test-results {
+    margin-top: 1.5rem;
+    padding: 1rem;
+    border-radius: var(--border-radius);
+  }
+
+  .test-results.error {
+    background-color: var(--color-error-bg);
+    border-left: 4px solid var(--color-error);
+  }
+
+  .test-results.success {
+    background-color: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+  }
+
+  .test-results h4 {
+    margin: 0 0 1rem 0;
+    color: var(--text-primary);
+  }
+
+  .result-summary {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 1rem;
+    margin-bottom: 1rem;
+  }
+
+  .result-item {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    padding: 0.75rem;
+    background: var(--bg-card);
+    border-radius: var(--border-radius);
+  }
+
+  .result-item .label {
+    font-size: 0.8rem;
+    color: var(--text-secondary);
+    margin-bottom: 0.25rem;
+  }
+
+  .result-item .value {
+    font-size: 1.25rem;
+    font-weight: bold;
+    color: var(--text-primary);
+  }
+
+  .result-item .value.confirmed {
+    color: var(--color-success);
+  }
+
+  .result-item .value.progress {
+    color: var(--color-primary);
+  }
+
+  .result-warnings {
+    background-color: var(--color-warning-bg);
+    padding: 0.75rem;
+    border-radius: var(--border-radius);
+    margin-bottom: 1rem;
+  }
+
+  .result-warnings h5 {
+    margin: 0 0 0.5rem 0;
+    color: var(--color-warning);
+  }
+
+  .result-warnings ul {
+    margin: 0;
+    padding-left: 1.5rem;
+  }
+
+  .sample-entities {
+    background-color: var(--color-info-bg);
+    padding: 0.75rem;
+    border-radius: var(--border-radius);
+  }
+
+  .sample-entities h5 {
+    margin: 0 0 0.5rem 0;
+    color: var(--color-info);
+  }
+
+  .entities-list {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.5rem;
+  }
+
+  .entity-tag {
+    background-color: var(--bg-card);
+    padding: 0.25rem 0.75rem;
+    border-radius: 12px;
+    font-size: 0.85rem;
+    color: var(--color-info);
+  }
+
+  .no-matches {
+    background-color: var(--color-warning-bg);
+    padding: 0.75rem;
+    border-radius: var(--border-radius);
+    text-align: center;
+    color: var(--color-warning);
+  }
+
+  .modal-footer {
+    padding: 1rem 1.5rem;
+    border-top: 1px solid var(--border-color);
+    display: flex;
+    justify-content: flex-end;
+  }
+
+  .btn {
+    padding: 0.6rem 1.2rem;
+    border: none;
+    border-radius: var(--border-radius);
+    cursor: pointer;
+    font-weight: 500;
+    transition: all 0.2s;
+    color: var(--text-inverted);
+  }
+
+  .btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .btn-primary {
+    background-color: var(--color-primary);
+  }
+
+  .btn-primary:hover:not(:disabled) {
+    background-color: var(--color-primary-hover);
+  }
+
+  .btn-secondary {
+    background-color: #6c757d;
+  }
+
+  .btn-secondary:hover {
+    background-color: #5a6268;
+  }
+
+  @media (max-width: 600px) {
+    .modal-content {
+      height: 100vh;
+      max-height: 100vh;
+      border-radius: 0;
+    }
+
+    .user-selector {
+      flex-direction: column;
+      align-items: stretch;
+    }
+
+    .result-summary {
+      grid-template-columns: 1fr 1fr;
+    }
+  }
+</style>

src/frontend/src/routes/awards/+page.svelte

@@ -180,13 +180,13 @@
 
   h1 {
     font-size: 2.5rem;
-    color: #333;
+    color: var(--text-primary);
     margin-bottom: 0.5rem;
   }
 
   .subtitle {
     font-size: 1.25rem;
-    color: #666;
+    color: var(--text-secondary);
     margin-bottom: 2rem;
   }
 
@@ -205,28 +205,29 @@
 
   .filter-group label {
     font-weight: 600;
-    color: #333;
+    color: var(--text-primary);
     font-size: 0.9rem;
   }
 
   .filter-group select {
     padding: 0.5rem 1rem;
-    border: 1px solid #ccc;
-    border-radius: 4px;
-    background-color: white;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
+    background-color: var(--bg-input);
     font-size: 0.9rem;
     cursor: pointer;
     min-width: 150px;
+    color: var(--text-primary);
   }
 
   .filter-group select:hover {
-    border-color: #4a90e2;
+    border-color: var(--color-primary);
   }
 
   .filter-group select:focus {
     outline: none;
-    border-color: #4a90e2;
-    box-shadow: 0 0 0 2px rgba(74, 144, 226, 0.2);
+    border-color: var(--color-primary);
+    box-shadow: var(--focus-ring);
   }
 
   .loading,
@@ -235,11 +236,11 @@
     text-align: center;
     padding: 3rem;
     font-size: 1.1rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .error {
-    color: #d32f2f;
+    color: var(--color-error);
   }
 
   .awards-grid {
@@ -249,11 +250,11 @@
   }
 
   .award-card {
-    background: white;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
     padding: 1.5rem;
-    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    box-shadow: var(--shadow-sm);
     display: flex;
     flex-direction: column;
   }
@@ -268,16 +269,16 @@
 
   .award-header h2 {
     font-size: 1.5rem;
-    color: #333;
+    color: var(--text-primary);
     margin: 0;
     flex: 1;
   }
 
   .category {
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
     padding: 0.25rem 0.75rem;
-    border-radius: 12px;
+    border-radius: var(--border-radius-pill);
     font-size: 0.75rem;
     font-weight: 600;
     text-transform: uppercase;
@@ -285,7 +286,7 @@
   }
 
   .description {
-    color: #666;
+    color: var(--text-secondary);
     margin-bottom: 1rem;
     flex-grow: 1;
   }
@@ -295,8 +296,8 @@
     gap: 2rem;
     margin-bottom: 1rem;
     padding: 0.75rem;
-    background-color: #f8f9fa;
-    border-radius: 4px;
+    background-color: var(--bg-secondary);
+    border-radius: var(--border-radius);
   }
 
   .info-item {
@@ -307,14 +308,14 @@
 
   .label {
     font-size: 0.75rem;
-    color: #666;
+    color: var(--text-secondary);
     text-transform: uppercase;
     font-weight: 600;
   }
 
   .value {
     font-size: 1rem;
-    color: #333;
+    color: var(--text-primary);
     font-weight: 500;
   }
 
@@ -325,15 +326,15 @@
   .progress-bar {
     width: 100%;
     height: 8px;
-    background-color: #e0e0e0;
-    border-radius: 4px;
+    background-color: var(--border-color);
+    border-radius: var(--border-radius);
     overflow: hidden;
     margin-bottom: 0.5rem;
   }
 
   .progress-fill {
     height: 100%;
-    background: linear-gradient(90deg, #4a90e2 0%, #357abd 100%);
+    background: var(--gradient-primary);
     transition: width 0.3s ease;
   }
 
@@ -348,7 +349,7 @@
     text-align: center;
     font-size: 0.875rem;
     font-weight: 600;
-    color: #4a90e2;
+    color: var(--color-primary);
   }
 
   .worked,
@@ -357,20 +358,20 @@
   }
 
   .worked {
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .confirmed {
-    color: #4a90e2;
+    color: var(--color-primary);
   }
 
   .btn {
     display: inline-block;
     padding: 0.75rem 1.5rem;
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
     text-decoration: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-weight: 500;
     text-align: center;
     transition: background-color 0.2s;
@@ -379,6 +380,6 @@
   }
 
   .btn:hover {
-    background-color: #357abd;
+    background-color: var(--color-primary-hover);
   }
 </style>

src/frontend/src/routes/qsos/+page.svelte

@@ -899,22 +899,22 @@
 
   .header h1 {
     margin: 0;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .back-button {
     padding: 0.5rem 1rem;
-    background-color: #6c757d;
+    background-color: var(--color-secondary);
     color: white;
     text-decoration: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 0.9rem;
     font-weight: 500;
     transition: background-color 0.2s;
   }
 
   .back-button:hover {
-    background-color: #5a6268;
+    background-color: var(--color-secondary-hover);
   }
 
   .header-buttons {
@@ -924,16 +924,16 @@
   }
 
   .filters {
-    background: #f8f9fa;
+    background: var(--bg-secondary);
     padding: 1rem;
-    border-radius: 8px;
+    border-radius: var(--border-radius-lg);
     margin-bottom: 2rem;
   }
 
   .filters h3 {
     margin: 0;
     font-size: 1rem;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .filters-header {
@@ -947,11 +947,11 @@
 
   .filter-count {
     font-size: 0.875rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .filter-count strong {
-    color: #4a90e2;
+    color: var(--color-primary);
     font-weight: 600;
   }
 
@@ -964,24 +964,28 @@
 
   .filter-row select {
     padding: 0.5rem;
-    border: 1px solid #ddd;
-    border-radius: 4px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
     font-size: 0.9rem;
+    background: var(--bg-input);
+    color: var(--text-primary);
   }
 
   .search-input {
     flex: 1;
     min-width: 200px;
     padding: 0.5rem;
-    border: 1px solid #ddd;
-    border-radius: 4px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
     font-size: 0.9rem;
+    background: var(--bg-input);
+    color: var(--text-primary);
   }
 
   .search-input:focus {
     outline: none;
-    border-color: #4a90e2;
-    box-shadow: 0 0 0 2px rgba(74, 144, 226, 0.2);
+    border-color: var(--color-primary);
+    box-shadow: var(--focus-ring);
   }
 
   .checkbox-label {
@@ -994,7 +998,7 @@
   .btn {
     padding: 0.75rem 1.5rem;
     border: none;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 1rem;
     font-weight: 500;
     cursor: pointer;
@@ -1002,12 +1006,12 @@
   }
 
   .btn-primary {
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
   }
 
   .btn-primary:hover:not(:disabled) {
-    background-color: #357abd;
+    background-color: var(--color-primary-hover);
   }
 
   .btn-primary:disabled {
@@ -1016,21 +1020,21 @@
   }
 
   .btn-secondary {
-    background-color: #6c757d;
+    background-color: var(--color-secondary);
     color: white;
   }
 
   .btn-secondary:hover {
-    background-color: #5a6268;
+    background-color: var(--color-secondary-hover);
   }
 
   .btn-danger {
-    background-color: #dc3545;
+    background-color: var(--color-error);
     color: white;
   }
 
   .btn-danger:hover:not(:disabled) {
-    background-color: #c82333;
+    background-color: var(--color-error-hover);
   }
 
   .btn-danger:disabled {
@@ -1043,14 +1047,14 @@
     font-size: 0.875rem;
     background: rgba(255, 255, 255, 0.3);
     border: 1px solid rgba(255, 255, 255, 0.5);
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     cursor: pointer;
     color: inherit;
   }
 
   .alert {
     padding: 1rem;
-    border-radius: 8px;
+    border-radius: var(--border-radius-lg);
     margin-bottom: 2rem;
     display: flex;
     flex-direction: column;
@@ -1058,21 +1062,21 @@
   }
 
   .alert-success {
-    background-color: #d4edda;
-    border: 1px solid #c3e6cb;
-    color: #155724;
+    background-color: var(--color-success-bg);
+    border: 1px solid var(--color-success);
+    color: var(--color-success);
   }
 
   .alert-error {
-    background-color: #f8d7da;
-    border: 1px solid #f5c6cb;
-    color: #721c24;
+    background-color: var(--color-error-bg);
+    border: 1px solid var(--color-error);
+    color: var(--color-error);
   }
 
   .alert-info {
-    background-color: #d1ecf1;
-    border: 1px solid #bee5eb;
-    color: #0c5460;
+    background-color: var(--color-info-bg);
+    border: 1px solid var(--color-info);
+    color: var(--color-info);
   }
 
   .alert h3 {
@@ -1090,11 +1094,13 @@
 
   .delete-input {
     padding: 0.5rem;
-    border: 1px solid #ddd;
-    border-radius: 4px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
     font-size: 1rem;
     margin: 0.5rem 0;
     width: 200px;
+    background: var(--bg-input);
+    color: var(--text-primary);
   }
 
   .delete-buttons {
@@ -1105,8 +1111,8 @@
 
   .qso-table-container {
     overflow-x: auto;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
   }
 
   .qso-table {
@@ -1118,39 +1124,39 @@
   .qso-table td {
     padding: 0.75rem;
     text-align: left;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color);
   }
 
   .qso-table th {
-    background-color: #f8f9fa;
+    background-color: var(--bg-secondary);
     font-weight: 600;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .qso-table tr:hover {
-    background-color: #f8f9fa;
+    background-color: var(--bg-secondary);
   }
 
   .callsign {
     font-weight: 600;
-    color: #4a90e2;
+    color: var(--color-primary);
   }
 
   .badge {
     padding: 0.25rem 0.5rem;
-    border-radius: 4px;
+    border-radius: var(--border-radius);
     font-size: 0.75rem;
     font-weight: 600;
   }
 
   .badge-success {
-    background-color: #d4edda;
-    color: #155724;
+    background-color: var(--color-success-bg);
+    color: var(--color-success);
   }
 
   .badge-pending {
-    background-color: #fff3cd;
-    color: #856404;
+    background-color: var(--badge-pending-bg);
+    color: var(--badge-pending-text);
   }
 
   .confirmation-list {
@@ -1168,29 +1174,29 @@
   .service-type {
     font-size: 0.7rem;
     font-weight: 600;
-    color: #4a90e2;
+    color: var(--color-primary);
     text-transform: uppercase;
     letter-spacing: 0.5px;
   }
 
   .confirmation-date {
     font-size: 0.875rem;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .loading, .error, .empty {
     text-align: center;
     padding: 3rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .error {
-    color: #dc3545;
+    color: var(--color-error);
   }
 
   .showing {
     text-align: center;
-    color: #666;
+    color: var(--text-secondary);
     font-size: 0.875rem;
     margin-top: 1rem;
   }
@@ -1201,14 +1207,14 @@
     align-items: center;
     margin-top: 1.5rem;
     padding: 1rem;
-    background: #f8f9fa;
-    border-radius: 8px;
+    background: var(--bg-secondary);
+    border-radius: var(--border-radius-lg);
     flex-wrap: wrap;
     gap: 1rem;
   }
 
   .pagination-info {
-    color: #666;
+    color: var(--text-secondary);
     font-size: 0.9rem;
   }
 
@@ -1226,7 +1232,7 @@
 
   .page-ellipsis {
     padding: 0 0.5rem;
-    color: #666;
+    color: var(--text-secondary);
   }
 
   .btn-small {
@@ -1241,16 +1247,16 @@
   }
 
   .import-log {
-    background: white;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
     padding: 1.5rem;
     margin-top: 1rem;
   }
 
   .import-log h3 {
     margin: 0 0 1rem 0;
-    color: #333;
+    color: var(--text-primary);
     font-size: 1.25rem;
   }
 
@@ -1264,15 +1270,15 @@
 
   .log-section h4 {
     margin: 0 0 0.75rem 0;
-    color: #555;
+    color: var(--text-secondary);
     font-size: 1rem;
     font-weight: 600;
   }
 
   .log-table-container {
     overflow-x: auto;
-    border: 1px solid #e0e0e0;
-    border-radius: 4px;
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius);
   }
 
   .log-table {
@@ -1285,13 +1291,13 @@
   .log-table td {
     padding: 0.5rem 0.75rem;
     text-align: left;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color);
   }
 
   .log-table th {
-    background-color: #f8f9fa;
+    background-color: var(--bg-secondary);
     font-weight: 600;
-    color: #333;
+    color: var(--text-primary);
     font-size: 0.85rem;
   }
 
@@ -1300,12 +1306,12 @@
   }
 
   .log-table tr:hover {
-    background-color: #f8f9fa;
+    background-color: var(--bg-secondary);
   }
 
   .log-table .callsign {
     font-weight: 600;
-    color: #4a90e2;
+    color: var(--color-primary);
   }
 
   /* QSO Detail Modal Styles */
@@ -1315,11 +1321,11 @@
   }
 
   .qso-row:hover {
-    background-color: #f0f7ff !important;
+    background-color: var(--color-primary-light) !important;
   }
 
   .qso-row:focus {
-    outline: 2px solid #4a90e2;
+    outline: 2px solid var(--color-primary);
     outline-offset: -2px;
   }
 
@@ -1340,13 +1346,13 @@
 
   /* Modal Content */
   .modal-content {
-    background: white;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border-radius: var(--border-radius-lg);
     max-width: 700px;
     width: 100%;
     max-height: 90vh;
     overflow-y: auto;
-    box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+    box-shadow: var(--shadow-md);
   }
 
   /* Modal Header */
@@ -1355,13 +1361,13 @@
     justify-content: space-between;
     align-items: center;
     padding: 1.5rem;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color);
   }
 
   .modal-header h2 {
     margin: 0;
     font-size: 1.5rem;
-    color: #333;
+    color: var(--text-primary);
   }
 
   .modal-close {
@@ -1376,14 +1382,14 @@
     display: flex;
     align-items: center;
     justify-content: center;
-    color: #666;
-    border-radius: 4px;
+    color: var(--text-secondary);
+    border-radius: var(--border-radius);
     transition: all 0.2s;
   }
 
   .modal-close:hover {
-    background-color: #f0f0f0;
-    color: #333;
+    background-color: var(--bg-tertiary);
+    color: var(--text-primary);
   }
 
   /* Modal Body */
@@ -1402,10 +1408,10 @@
 
   .qso-detail-section h3 {
     font-size: 1.1rem;
-    color: #4a90e2;
+    color: var(--color-primary);
     margin: 0 0 1rem 0;
     padding-bottom: 0.5rem;
-    border-bottom: 2px solid #e0e0e0;
+    border-bottom: 2px solid var(--border-color);
   }
 
   /* Detail Grid */
@@ -1423,14 +1429,14 @@
 
   .detail-label {
     font-size: 0.75rem;
-    color: #666;
+    color: var(--text-secondary);
     text-transform: uppercase;
     font-weight: 600;
   }
 
   .detail-value {
     font-size: 0.95rem;
-    color: #333;
+    color: var(--text-primary);
     font-weight: 500;
   }
 
@@ -1443,10 +1449,10 @@
 
   .confirmation-service h4 {
     font-size: 1rem;
-    color: #333;
+    color: var(--text-primary);
     margin: 0 0 1rem 0;
     padding-bottom: 0.5rem;
-    border-bottom: 1px solid #e0e0e0;
+    border-bottom: 1px solid var(--border-color);
   }
 
   .confirmation-status-item {
@@ -1466,19 +1472,19 @@
   }
 
   .status-badge.confirmed {
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
     color: white;
   }
 
   .status-badge.not-confirmed,
   .status-badge.no-data {
-    background-color: #e0e0e0;
-    color: #666;
+    background-color: var(--border-color);
+    color: var(--text-secondary);
   }
 
   .status-badge.unknown {
-    background-color: #fff3cd;
-    color: #856404;
+    background-color: var(--badge-pending-bg);
+    color: var(--badge-pending-text);
   }
 
   /* Meta Info */
@@ -1486,18 +1492,18 @@
     display: flex;
     gap: 2rem;
     padding: 1rem;
-    background-color: #f8f9fa;
-    border-radius: 4px;
+    background-color: var(--bg-secondary);
+    border-radius: var(--border-radius);
     font-size: 0.8rem;
   }
 
   .meta-label {
-    color: #666;
+    color: var(--text-secondary);
     font-weight: 600;
   }
 
   .meta-value {
-    color: #333;
+    color: var(--text-primary);
     font-family: monospace;
   }
 
@@ -1507,15 +1513,15 @@
   }
 
   .modal-content::-webkit-scrollbar-track {
-    background: #f1f1f1;
+    background: var(--bg-secondary);
   }
 
   .modal-content::-webkit-scrollbar-thumb {
-    background: #888;
+    background: var(--text-muted);
     border-radius: 4px;
   }
 
   .modal-content::-webkit-scrollbar-thumb:hover {
-    background: #555;
+    background: var(--text-secondary);
   }
 </style>

src/frontend/src/routes/qsos/components/QSOStats.svelte

@@ -32,9 +32,9 @@
   }
 
   .stat-card {
-    background: white;
-    border: 1px solid #e0e0e0;
-    border-radius: 8px;
+    background: var(--bg-card);
+    border: 1px solid var(--border-color);
+    border-radius: var(--border-radius-lg);
     padding: 1.5rem;
     text-align: center;
   }
@@ -42,11 +42,11 @@
   .stat-value {
     font-size: 2rem;
     font-weight: bold;
-    color: #4a90e2;
+    color: var(--color-primary);
   }
 
   .stat-label {
-    color: #666;
+    color: var(--text-secondary);
     margin-top: 0.5rem;
   }
 </style>

src/frontend/src/routes/qsos/components/SyncButton.svelte

@@ -23,11 +23,11 @@
 
 <style>
   .lotw-btn {
-    background-color: #4a90e2;
+    background-color: var(--color-primary);
   }
 
   .lotw-btn:hover:not(:disabled) {
-    background-color: #357abd;
+    background-color: var(--color-primary-hover);
   }
 
   .dcl-btn {

src/frontend/src/routes/settings/+page.svelte

@@ -1,6 +1,7 @@
 <script>
   import { onMount } from 'svelte';
-  import { authAPI } from '$lib/api.js';
+  import { browser } from '$app/environment';
+  import { authAPI, autoSyncAPI } from '$lib/api.js';
   import { auth } from '$lib/stores.js';
   import { goto } from '$app/navigation';
 
@@ -16,9 +17,23 @@
   let hasLoTWCredentials = false;
   let hasDCLCredentials = false;
 
+  // Auto-sync settings
+  let autoSyncSettings = {
+    lotwEnabled: false,
+    lotwIntervalHours: 24,
+    lotwNextSyncAt: null,
+    dclEnabled: false,
+    dclIntervalHours: 24,
+    dclNextSyncAt: null,
+  };
+  let loadingAutoSync = false;
+  let savingAutoSync = false;
+  let successAutoSync = false;
+
   onMount(async () => {
     // Load user profile to check if credentials exist
     await loadProfile();
+    await loadAutoSyncSettings();
   });
 
   async function loadProfile() {
@@ -40,6 +55,21 @@
     }
   }
 
+  async function loadAutoSyncSettings() {
+    try {
+      loadingAutoSync = true;
+      const response = await autoSyncAPI.getSettings();
+      if (response.settings) {
+        autoSyncSettings = response.settings;
+      }
+    } catch (err) {
+      console.error('Failed to load auto-sync settings:', err);
+      // Don't show error for auto-sync, it's optional
+    } finally {
+      loadingAutoSync = false;
+    }
+  }
+
   async function handleSaveLoTW(e) {
     e.preventDefault();
 
@@ -91,9 +121,46 @@
     }
   }
 
+  async function handleSaveAutoSync(e) {
+    e.preventDefault();
+
+    try {
+      savingAutoSync = true;
+      error = null;
+      successAutoSync = false;
+
+      await autoSyncAPI.updateSettings({
+        lotwEnabled: autoSyncSettings.lotwEnabled,
+        lotwIntervalHours: parseInt(autoSyncSettings.lotwIntervalHours),
+        dclEnabled: autoSyncSettings.dclEnabled,
+        dclIntervalHours: parseInt(autoSyncSettings.dclIntervalHours),
+      });
+
+      console.log('Auto-sync settings saved successfully!');
+
+      // Reload settings to get updated next sync times
+      await loadAutoSyncSettings();
+      successAutoSync = true;
+    } catch (err) {
+      console.error('Auto-sync save failed:', err);
+      error = err.message;
+    } finally {
+      savingAutoSync = false;
+    }
+  }
+
+  function formatNextSyncTime(dateString) {
+    if (!dateString) return 'Not scheduled';
+    const date = new Date(dateString);
+    return date.toLocaleString();
+  }
+
   function handleLogout() {
     auth.logout();
-    goto('/auth/login');
+    // Use hard redirect to ensure proper navigation after logout
+    if (browser) {
+      window.location.href = '/auth/login';
+    }
   }
 </script>
 
@@ -237,6 +304,116 @@
       </p>
     </div>
   </div>
+
+  <div class="settings-section">
+    <h2>Automatic Sync Settings</h2>
+    <p class="help-text">
+      Configure automatic synchronization for LoTW and DCL. The server will automatically
+      sync your QSOs at the specified interval. Credentials must be configured above.
+    </p>
+
+    {#if !hasLoTWCredentials && !hasDCLCredentials}
+      <div class="alert alert-info">
+        <strong>Note:</strong> Configure LoTW or DCL credentials above to enable automatic sync.
+      </div>
+    {/if}
+
+    <form on:submit={handleSaveAutoSync} class="settings-form">
+      {#if error}
+        <div class="alert alert-error">{error}</div>
+      {/if}
+
+      {#if successAutoSync}
+        <div class="alert alert-success">
+          Auto-sync settings saved successfully!
+        </div>
+      {/if}
+
+      <h3>LoTW Auto-Sync</h3>
+
+      <div class="form-row">
+        <div class="form-group checkbox-group">
+          <label>
+            <input
+              type="checkbox"
+              bind:checked={autoSyncSettings.lotwEnabled}
+              disabled={!hasLoTWCredentials || savingAutoSync}
+            />
+            Enable LoTW auto-sync
+          </label>
+          {#if !hasLoTWCredentials}
+            <p class="hint">Configure LoTW credentials above first</p>
+          {/if}
+        </div>
+
+        <div class="form-group">
+          <label for="lotwIntervalHours">Sync interval (hours)</label>
+          <input
+            id="lotwIntervalHours"
+            type="number"
+            min="1"
+            max="720"
+            bind:value={autoSyncSettings.lotwIntervalHours}
+            disabled={!autoSyncSettings.lotwEnabled || savingAutoSync}
+          />
+          <p class="hint">
+            Minimum 1 hour, maximum 720 hours (30 days). Default: 24 hours.
+          </p>
+        </div>
+      </div>
+
+      {#if autoSyncSettings.lotwEnabled && autoSyncSettings.lotwNextSyncAt}
+        <p class="next-sync-info">
+          Next scheduled sync: <strong>{formatNextSyncTime(autoSyncSettings.lotwNextSyncAt)}</strong>
+        </p>
+      {/if}
+
+      <hr class="divider" />
+
+      <h3>DCL Auto-Sync</h3>
+
+      <div class="form-row">
+        <div class="form-group checkbox-group">
+          <label>
+            <input
+              type="checkbox"
+              bind:checked={autoSyncSettings.dclEnabled}
+              disabled={!hasDCLCredentials || savingAutoSync}
+            />
+            Enable DCL auto-sync
+          </label>
+          {#if !hasDCLCredentials}
+            <p class="hint">Configure DCL credentials above first</p>
+          {/if}
+        </div>
+
+        <div class="form-group">
+          <label for="dclIntervalHours">Sync interval (hours)</label>
+          <input
+            id="dclIntervalHours"
+            type="number"
+            min="1"
+            max="720"
+            bind:value={autoSyncSettings.dclIntervalHours}
+            disabled={!autoSyncSettings.dclEnabled || savingAutoSync}
+          />
+          <p class="hint">
+            Minimum 1 hour, maximum 720 hours (30 days). Default: 24 hours.
+          </p>
+        </div>
+      </div>
+
+      {#if autoSyncSettings.dclEnabled && autoSyncSettings.dclNextSyncAt}
+        <p class="next-sync-info">
+          Next scheduled sync: <strong>{formatNextSyncTime(autoSyncSettings.dclNextSyncAt)}</strong>
+        </p>
+      {/if}
+
+      <button type="submit" class="btn btn-primary" disabled={savingAutoSync}>
+        {savingAutoSync ? 'Saving...' : 'Save Auto-Sync Settings'}
+      </button>
+    </form>
+  </div>
 </div>
 
 <style>
@@ -438,4 +615,58 @@
   .info-box a:hover {
     text-decoration: underline;
   }
+
+  /* Auto-sync specific styles */
+  .form-row {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 1.5rem;
+    align-items: start;
+  }
+
+  .checkbox-group {
+    padding-top: 0.75rem;
+  }
+
+  .checkbox-group label {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-weight: 500;
+    cursor: pointer;
+  }
+
+  .checkbox-group input[type="checkbox"] {
+    width: 1.25rem;
+    height: 1.25rem;
+    cursor: pointer;
+  }
+
+  .checkbox-group input[type="checkbox"]:disabled {
+    cursor: not-allowed;
+    opacity: 0.5;
+  }
+
+  .divider {
+    border: none;
+    border-top: 1px solid #e0e0e0;
+    margin: 2rem 0;
+  }
+
+  .next-sync-info {
+    padding: 0.75rem 1rem;
+    background-color: #e3f2fd;
+    border-left: 4px solid #4a90e2;
+    border-radius: 4px;
+    margin-top: 1rem;
+    font-size: 0.9rem;
+    color: #333;
+  }
+
+  @media (max-width: 640px) {
+    .form-row {
+      grid-template-columns: 1fr;
+      gap: 1rem;
+    }
+  }
 </style>