Merge pull request 'Update to v0.7.0' (#30) from dev into main

Reviewed-on: #30

.dockerignore

@@ -1,3 +1,5 @@
+docker-compose.override.yml
+
 # Python cache / compiled
 __pycache__
 *.pyc
@@ -28,6 +30,7 @@ ENV/
 
 # Runtime data (mounted volumes)
 data/
+data-dev/
 
 # Editors / OS junk
 .vscode/

.gitignore

@@ -1,3 +1,16 @@
+# Terra-View Specifics
+# Dev build counter (local only, never commit)
+build_number.txt
+
+# SQLite database files
+*.db
+*.db-journal
+data/
+data-dev/
+.aider*
+.aider*
+docker-compose.override.yml
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[codz]
@@ -206,8 +219,3 @@ marimo/_static/
 marimo/_lsp/
 __marimo__/
 
-# Seismo Fleet Manager
-# SQLite database files
-*.db
-*.db-journal
-data/

CHANGELOG.md

@@ -1,10 +1,161 @@
 # Changelog
 
-All notable changes to Seismo Fleet Manager will be documented in this file.
+All notable changes to Terra-View will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.7.0] - 2026-03-07
+
+### Added
+- **Project Status Management**: Projects can now be placed `on_hold` or `archived`, with automatic cancellation of pending scheduled actions
+- **Hard Delete Projects**: Support for permanently deleting projects, in addition to soft-delete with auto-pruning
+- **Vibration Location Detail**: New dedicated template for vibration project location detail views
+- **Vibration Project Isolation**: Vibration projects no longer show SLM-specific project tabs
+- **Manual SD Card Data Upload**: Upload offline NRL data directly from SD card via ZIP or multi-file select
+  - Accepts `.rnd`/`.rnh` files; parses `.rnh` metadata for session start/stop times, serial number, and store name
+  - Creates `MonitoringSession` and `DataFile` records automatically; no unit assignment required
+  - Upload panel on NRL detail Data Files tab with inline feedback and auto-refresh via HTMX
+- **Standalone SLM Type**: New SLM device mode that operates without a modem (direct IP connection)
+- **NL32 Data Support**: Report generator and web viewer now support NL32 measurement data format
+- **Combined Report Wizard**: Multi-session combined Excel report generation tool
+  - Wizard UI grouped by location with period type badges (day/night)
+  - Each selected session produces one `.xlsx` in a ZIP archive
+  - Period type filtering: day sessions keep last calendar date (7AM–6:59PM); night sessions span both days (7PM–6:59AM)
+- **Combined Report Preview**: Interactive spreadsheet-style preview before generating combined reports
+- **Chart Preview**: Live chart preview in the report generator matching final report styling
+- **SLM Model Schemas**: Per-model configuration schemas for NL32, NL43, NL53 devices
+- **Data Collection Mode**: Projects now store a data collection mode field with UI controls and migration
+
+### Changed
+- **MonitoringSession rename**: `RecordingSession` renamed to `MonitoringSession` throughout codebase; DB table renamed from `recording_sessions` to `monitoring_sessions`
+  - Migration: `backend/migrate_rename_recording_to_monitoring_sessions.py`
+- **Combined Report Split Logic**: Separate days now generate separate `.xlsx` files; NRLs remain one per sheet
+- **Mass Upload Parsing**: Smarter file filtering — no longer imports unneeded Lp files or `.xlsx` files
+- **SLM Start Time Grace Period**: 15-minute grace window added so data starting at session start time is included
+- **NL32 Date Parsing**: Date now read from `start_time` field instead of file metadata
+- **Project Data Labels**: Improved Jinja filters and UI label clarity for project data views
+
+### Fixed
+- **Dev/Prod Separation**: Dev server now uses Docker Compose override; production deployment no longer affected by dev config
+- **SLM Modal**: Bench/deploy toggle now correctly shown in SLM unit modal
+- **Auto-Downloaded Files**: Files downloaded by scheduler now appear in project file listings
+- **Duplicate Download**: Removed duplicate file download that occurred following a scheduled stop
+- **SLMM Environment Variables**: `TCP_IDLE_TTL` and `TCP_MAX_AGE` now correctly passed to SLMM service via docker-compose
+
+### Technical Details
+- `session_label` and `period_type` stored on `monitoring_sessions` table (migration: `migrate_add_session_period_type.py`)
+- `device_model` stored on `monitoring_sessions` table (migration: `migrate_add_session_device_model.py`)
+- Upload endpoint: `POST /api/projects/{project_id}/nrl/{location_id}/upload-data`
+- ZIP filename format: `{session_label}_{project_name}_report.xlsx` (label first)
+
+### Migration Notes
+Run the following migration scripts once per database before deploying:
+```bash
+python backend/migrate_rename_recording_to_monitoring_sessions.py
+python backend/migrate_add_session_period_type.py
+python backend/migrate_add_session_device_model.py
+```
+
+---
+
+## [0.6.1] - 2026-02-16
+
+### Added
+- **One-Off Recording Schedules**: Support for scheduling single recordings with specific start and end datetimes
+- **Bidirectional Pairing Sync**: Pairing a device with a modem now automatically updates both sides, clearing stale pairings when reassigned
+- **Auto-Fill Notes from Modem**: Notes are now copied from modem to paired device when fields are empty
+- **SLMM Download Requests**: New `_download_request` method in SLMM client for binary file downloads with local save
+
+### Fixed
+- **Scheduler Timezone**: One-off scheduler times now use local time instead of UTC
+- **Pairing Consistency**: Old device references are properly cleared when a modem is re-paired to a new device
+
+## [0.6.0] - 2026-02-06
+
+### Added
+- **Calendar & Reservation Mode**: Fleet calendar view with reservation system for scheduling device deployments
+- **Device Pairing Interface**: New two-column pairing page (`/pair-devices`) for linking recorders (seismographs/SLMs) with modems
+  - Visual pairing interface with drag-and-drop style interactions
+  - Fuzzy-search modem pairing for SLMs
+  - Pairing options now accessible from modem page
+  - Improved pair status sharing across views
+- **Modem Dashboard Enhancements**:
+  - Modem model number now a dedicated configuration field with per-model options
+  - Direct link to modem login page from unit detail view
+  - Modem view converted to list format
+- **Seismograph List Improvements**:
+  - Enhanced visibility with better filtering and sorting
+  - Calibration dates now color-coded for quick status assessment
+  - User sets date of previous calibration (not expiry) for clearer workflow
+- **SLMM Device Control Lock**: Prevents command flooding to NL-43 devices
+
+### Changed
+- **Calibration Date UX**: Users now set the date of the previous calibration rather than upcoming expiry dates - more intuitive workflow
+- **Settings Persistence**: Settings save no longer reloads the page
+- **Tab State**: Tab state now persists in URL hash for better navigation
+- **Scheduler Management**: Schedule changes now cascade to individual events
+- **Dashboard Filtering**: Enhanced dashboard with additional filtering options and SLM status sync
+- **SLMM Polling Intervals**: Fixed and improved polling intervals for better responsiveness
+- **24-Hour Scheduler Cycle**: Improved cycle handling to prevent issues with scheduled downloads
+
+### Fixed
+- **SLM Modal Fields**: Modal now only contains correct device-specific fields
+- **IP Address Handling**: IP address correctly passed via modem pairing
+- **Mobile Type Display**: Fixed incorrect device type display in roster and device tables
+- **SLMM Scheduled Downloads**: Fixed issues with scheduled download operations
+
+## [0.5.1] - 2026-01-27
+
+### Added
+- **Dashboard Schedule View**: Today's scheduled actions now display directly on the main dashboard
+  - New "Today's Actions" panel showing upcoming and past scheduled events
+  - Schedule list partial for project-specific schedule views
+  - API endpoint for fetching today's schedule data
+- **New Branding Assets**: Complete logo rework for Terra-View
+  - New Terra-View logos for light and dark themes
+  - Retina-ready (@2x) logo variants
+  - Updated favicons (16px and 32px)
+  - Refreshed PWA icons (72px through 512px)
+
+### Changed
+- **Dashboard Layout**: Reorganized to include schedule information panel
+- **Base Template**: Updated to use new Terra-View logos with theme-aware switching
+
+## [0.5.0] - 2026-01-23
+
+_Note: This version was not formally released; changes were included in v0.5.1._
+
+## [0.4.4] - 2026-01-23
+
+### Added
+- **Recurring schedules**: New scheduler service, recurring schedule APIs, and schedule templates (calendar/interval/list).
+- **Alerts UI + backend**: Alerting service plus dropdown/list templates for surfacing notifications.
+- **Report templates + viewers**: CRUD API for report templates, report preview screen, and RND file viewer.
+- **SLM tooling**: SLM settings modal and SLM project report generator workflow.
+
+### Changed
+- **Project data management**: Unified files view, refreshed FTP browser, and new project header/templates for file/session/unit/assignment lists.
+- **Device/SLM sync**: Standardized SLM device types and tightened SLMM sync paths.
+- **Docs/scripts**: Cleanup pass and expanded device-type documentation.
+
+### Fixed
+- **Scheduler actions**: Strict command definitions so actions run reliably.
+- **Project view title**: Resolved JSON string rendering in project headers.
+
+## [0.4.3] - 2026-01-14
+
+### Added
+- **Sound Level Meter roster tooling**: Roster manager surfaces SLM metadata, supports rename unit flows, and adds return-to-project navigation to keep SLM dashboard users oriented.
+- **Project management templates**: New schedule and unit list templates plus file/session lists show what each project stores before teams dive into deployments.
+
+### Changed
+- **Project view refresh**: FTP browser now downloads folders locally, the countdown timer was rebuilt, and project/device templates gained edit modals for projects and locations so navigation feels smoother.
+- **SLM control sync & accuracy**: Control center groundwork now runs inside the dev UI, configuration edits propagate to SLMM (which caches configs for faster responses), and the SLM live view reads the correct DRD fields after the refactor.
+
+### Fixed
+- **SLM UI syntax bug**: Resolved the unexpected token error that appeared in the refreshed SLM components.
+
 ## [0.4.2] - 2026-01-05
 
 ### Added
@@ -348,6 +499,12 @@ No database migration required for v0.4.0. All new features use existing databas
 - Photo management per unit
 - Automated status categorization (OK/Pending/Missing)
 
+[0.7.0]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.6.1...v0.7.0
+[0.6.0]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.5.1...v0.6.0
+[0.5.1]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.5.0...v0.5.1
+[0.5.0]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.4.4...v0.5.0
+[0.4.4]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.4.3...v0.4.4
+[0.4.3]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.4.2...v0.4.3
 [0.4.2]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.4.1...v0.4.2
 [0.4.1]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.4.0...v0.4.1
 [0.4.0]: https://github.com/serversdwn/seismo-fleet-manager/compare/v0.3.3...v0.4.0

Dockerfile

@@ -1,5 +1,9 @@
 FROM python:3.11-slim
 
+# Build number for dev builds (injected via --build-arg)
+ARG BUILD_NUMBER=0
+ENV BUILD_NUMBER=${BUILD_NUMBER}
+
 # Set working directory
 WORKDIR /app
 

Dockerfile.sfm

@@ -1,26 +0,0 @@
-FROM python:3.11-slim
-
-# Set working directory
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends iputils-ping curl && \
-    rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first for better caching
-COPY requirements.txt .
-
-# Install dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY . .
-
-# Expose SFM port
-EXPOSE 8002
-
-# Run SFM backend (API only)
-# For now: runs same app on different port
-# Future: will run SFM-specific entry point
-CMD ["python3", "-m", "app.main"]

Dockerfile.slm

@@ -1,21 +0,0 @@
-FROM python:3.11-slim
-
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends curl && \
-    rm -rf /var/lib/apt/lists/*
-
-# Copy requirements and install dependencies
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY app /app/app
-
-# Expose port
-EXPOSE 8100
-
-# Run the SLM application
-CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8100"]

Dockerfile.terraview

@@ -1,24 +0,0 @@
-FROM python:3.11-slim
-
-# Set working directory
-WORKDIR /app
-
-# Install system dependencies
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends iputils-ping curl && \
-    rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first for better caching
-COPY requirements.txt .
-
-# Install dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
-COPY . .
-
-# Expose Terra-View UI port
-EXPOSE 8001
-
-# Run Terra-View (UI + orchestration)
-CMD ["python3", "-m", "app.main"]

MIGRATION_BASELINE.md

@@ -1,141 +0,0 @@
-# Terra-View Modular Monolith - Known-Good Baseline
-
-**Date:** 2026-01-09
-**Status:** ✅ IMPORT MIGRATION COMPLETE
-
-## What We've Achieved
-
-Successfully restructured the application into a modular monolith architecture with the new folder structure working end-to-end.
-
-## New Structure
-
-```
-/home/serversdown/sfm/seismo-fleet-manager/
-├── app/
-│   ├── main.py                    # NEW: Entry point with Terra-View branding
-│   ├── core/                      # Shared infrastructure
-│   │   ├── config.py             # NEW: Centralized configuration
-│   │   └── database.py           # Shared DB utilities
-│   ├── ui/                       # UI Layer (device-agnostic)
-│   │   ├── routes.py             # NEW: HTML page routes
-│   │   ├── templates/            # All HTML templates (copied from old location)
-│   │   └── static/               # All static files (copied from old location)
-│   ├── seismo/                   # Seismograph Feature Module
-│   │   ├── models.py             # ✅ Updated to use app.seismo.database
-│   │   ├── database.py           # NEW: Seismo-specific DB connection
-│   │   ├── routers/              # API routers (copied from backend/routers/)
-│   │   └── services/             # Business logic (copied from backend/services/)
-│   ├── slm/                      # Sound Level Meter Feature Module
-│   │   ├── models.py             # NEW: Placeholder for SLM models
-│   │   ├── database.py           # NEW: SLM-specific DB connection
-│   │   └── routers/              # SLM routers (copied from backend/routers/)
-│   └── api/                      # API Aggregation Layer (placeholder)
-│       ├── dashboard.py          # NEW: Future aggregation endpoints
-│       └── roster.py             # NEW: Future aggregation endpoints
-└── data/
-    └── seismo_fleet.db          # Still using shared DB (migration pending)
-```
-
-## What's Working
-
-✅ **Application starts successfully** on port 9999
-✅ **Health endpoint works**: `/health` returns Terra-View v1.0.0
-✅ **UI renders**: Main dashboard loads with proper templates
-✅ **API endpoints work**: `/api/status-snapshot` returns seismograph data
-✅ **Database access works**: Models properly connected
-✅ **Static files serve**: CSS, JS, icons all accessible
-
-## Critical Changes Made
-
-### 1. Fixed Import in models.py
-**File:** `app/seismo/models.py`
-**Change:** `from backend.database import Base` → `from app.seismo.database import Base`
-**Reason:** Avoid duplicate Base instances causing SQLAlchemy errors
-
-### 2. Created New Entry Point
-**File:** `app/main.py`
-**Features:**
-- Terra-View branding (title, version, health check)
-- Imports from new `app.*` structure
-- Registers all seismo and SLM routers
-- Middleware for environment context
-
-### 3. Created UI Routes Module
-**File:** `app/ui/routes.py`
-**Purpose:** Centralize all HTML page routes (device-agnostic)
-
-### 4. Created Module-Specific Databases
-**Files:** `app/seismo/database.py`, `app/slm/database.py`
-**Status:** Both currently point to shared `seismo_fleet.db` (migration pending)
-
-## Recent Updates (2026-01-09)
-
-✅ **ALL imports updated** - Changed all `backend.*` imports to `app.seismo.*` or `app.slm.*`
-✅ **Old structure deleted** - `backend/` and `templates/` directories removed
-✅ **Containers rebuilt** - All three containers (Terra-View, SFM, SLMM) working with new imports
-✅ **Verified working** - Tested health endpoints and UI after migration
-
-## What's NOT Yet Done
-
-❌ **Partial routes missing** - `/partials/*` endpoints not yet added
-❌ **Database not split** - Still using shared `seismo_fleet.db`
-
-## How to Run
-
-```bash
-# Start on custom port to avoid conflicts
-PORT=9999 python3 -m app.main
-
-# Test health endpoint
-curl http://localhost:9999/health
-
-# Test API endpoint
-curl http://localhost:9999/api/status-snapshot
-
-# Access UI
-open http://localhost:9999/
-```
-
-## Next Steps (Recommended Order)
-
-1. **Add partial routes** to app/main.py or create separate router
-2. **Test all endpoints thoroughly** - Verify roster CRUD, photos, settings
-3. **Split databases** (Phase 2 of plan)
-4. **Implement API aggregation layer** (Phase 3 of plan)
-
-## Known Issues
-
-None currently - app starts and serves requests successfully!
-
-## Testing Checklist
-
-- [x] App starts without errors
-- [x] Health endpoint returns correct version
-- [x] Main dashboard loads
-- [x] Status snapshot API works
-- [ ] All seismo endpoints work
-- [ ] All SLM endpoints work
-- [ ] Roster CRUD operations work
-- [ ] Photos upload/download works
-- [ ] Settings page works
-
-## Rollback Instructions
-
-~~The old structure has been deleted.~~ To rollback, restore from your backup:
-
-```bash
-# Restore from your backup
-# The old backend/ and templates/ directories were removed on 2026-01-09
-```
-
-## Important Notes
-
-- **MIGRATION COMPLETE**: Old `backend/` and `templates/` directories removed
-- **ALL IMPORTS UPDATED**: All Python files now use `app.*` imports
-- **NO DATA LOSS**: Database untouched, only code structure changed
-- **CONTAINERS WORKING**: All three containers (Terra-View, SFM, SLMM) healthy
-- **FULLY SELF-CONTAINED**: Application runs entirely from `app/` directory
-
----
-
-**Congratulations!** 🎉 Import migration complete! The modular monolith is now self-contained and production-ready.

README.md

@@ -1,4 +1,4 @@
-# Seismo Fleet Manager v0.4.2
+# Terra-View v0.7.0
 Backend API and HTMX-powered web interface for managing a mixed fleet of seismographs and field modems. Track deployments, monitor health in real time, merge roster intent with incoming telemetry, and control your fleet through a unified database and dashboard.
 
 ## Features
@@ -308,7 +308,7 @@ print(response.json())
 |-------|------|-------------|
 | id | string | Unit identifier (primary key) |
 | unit_type | string | Hardware model name (default: `series3`) |
-| device_type | string | `seismograph` or `modem` discriminator |
+| device_type | string | Device type: `"seismograph"`, `"modem"`, or `"slm"` (sound level meter) |
 | deployed | boolean | Whether the unit is in the field |
 | retired | boolean | Removes the unit from deployments but preserves history |
 | note | string | Notes about the unit |
@@ -334,6 +334,39 @@ print(response.json())
 | phone_number | string | Cellular number for the modem |
 | hardware_model | string | Modem hardware reference |
 
+**Sound Level Meter (SLM) fields**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| slm_host | string | Direct IP address for SLM (if not using modem) |
+| slm_tcp_port | integer | TCP control port (default: 2255) |
+| slm_ftp_port | integer | FTP file transfer port (default: 21) |
+| slm_model | string | Device model (NL-43, NL-53) |
+| slm_serial_number | string | Manufacturer serial number |
+| slm_frequency_weighting | string | Frequency weighting setting (A, C, Z) |
+| slm_time_weighting | string | Time weighting setting (F=Fast, S=Slow) |
+| slm_measurement_range | string | Measurement range setting |
+| slm_last_check | datetime | Last status check timestamp |
+| deployed_with_modem_id | string | Modem pairing (shared with seismographs) |
+
+### Device Type Schema
+
+Terra-View supports three device types with the following standardized `device_type` values:
+
+- **`"seismograph"`** (default) - Seismic monitoring devices (Series 3, Series 4, Micromate)
+  - Uses: calibration dates, modem pairing
+  - Examples: BE1234, UM12345 (Series 3/4 units)
+
+- **`"modem"`** - Field modems and network equipment
+  - Uses: IP address, phone number, hardware model
+  - Examples: MDM001, MODEM-2025-01
+
+- **`"slm"`** - Sound level meters (Rion NL-43/NL-53)
+  - Uses: TCP/FTP configuration, measurement settings, modem pairing
+  - Examples: SLM-43-01, NL43-001
+
+**Important**: All `device_type` values must be lowercase. The legacy value `"sound_level_meter"` has been deprecated in favor of the shorter `"slm"`. Run `backend/migrate_standardize_device_types.py` to update existing databases.
+
 ### Emitter Table (Device Check-ins)
 
 | Field | Type | Description |
@@ -463,6 +496,35 @@ docker compose down -v
 
 ## Release Highlights
 
+### v0.7.0 — 2026-03-07
+- **Project Status Management**: On-hold and archived project states with automatic cancellation of pending actions
+- **Manual SD Card Upload**: Upload offline NRL/SLM data directly from SD card (ZIP or multi-file); auto-creates monitoring sessions from `.rnh` metadata
+- **Combined Report Wizard**: Multi-session Excel report generation with location grouping, period type filtering, and ZIP download
+- **NL32 Support**: Report generator and web viewer now handle NL32 measurement data
+- **Chart Preview**: Live chart preview in the report generator matching final output styling
+- **Standalone SLM Mode**: SLMs can now be configured without a paired modem (direct IP)
+- **Vibration Project Isolation**: Vibration project views no longer show SLM-specific tabs
+- **MonitoringSession Rename**: `RecordingSession` renamed to `MonitoringSession` throughout; run migration before deploying
+
+### v0.6.1 — 2026-02-16
+- **One-Off Recording Schedules**: Schedule single recordings with specific start/end datetimes
+- **Bidirectional Pairing Sync**: Device-modem pairing now updates both sides automatically
+- **Scheduler Timezone Fix**: One-off schedule times use local time instead of UTC
+
+### v0.6.0 — 2026-02-06
+- **Calendar & Reservation Mode**: Fleet calendar view with device deployment scheduling and reservation system
+- **Device Pairing Interface**: New `/pair-devices` page with two-column layout for linking recorders with modems, fuzzy-search, and visual pairing workflow
+- **Calibration UX Overhaul**: Users now set date of previous calibration (not expiry); seismograph list enhanced with color-coded calibration status, filtering, and sorting
+- **Modem Dashboard**: Model number as dedicated config, modem login links, list view format, and pairing options accessible from modem page
+- **SLMM Improvements**: Device control lock prevents command flooding, fixed polling intervals and scheduled downloads
+- **UI Polish**: Tab state persists in URL hash, settings save without reload, scheduler changes cascade to events, fixed mobile type display
+
+### v0.4.3 — 2026-01-14
+- **Sound Level Meter workflow**: Roster manager surfaces SLM metadata, supports rename actions, and adds return-to-project navigation plus schedule/unit templates for project planning.
+- **Project insight panels**: Project dashboards now expose file and session lists so teams can see what each project stores before diving into units.
+- **Project view polish**: FTP browser supports folder downloads, the timer display was reimplemented, and the project/device templates gained edit modals for projects and locations to streamline navigation.
+- **SLM sync & accuracy**: Configuration edits now propagate to SLMM (which caches configs for faster responses) and the live view uses the correct DRD fields so telemetry aligns with the control center.
+
 ### v0.4.0 — 2025-12-16
 - **Database Management System**: Complete backup and restore functionality with manual snapshots, restore operations, and upload/download capabilities
 - **Remote Database Cloning**: New `clone_db_to_dev.py` script for copying production database to remote dev servers over WAN
@@ -532,9 +594,25 @@ MIT
 
 ## Version
 
-**Current: 0.4.0** — Database management system with backup/restore and remote cloning (2025-12-16)
+**Current: 0.7.0** — Project status management, manual SD card upload, combined report wizard, NL32 support, MonitoringSession rename (2026-03-07)
 
-Previous: 0.3.3 — Mobile navigation improvements and better status visibility (2025-12-12)
+Previous: 0.6.1 — One-off recording schedules, bidirectional pairing sync, scheduler timezone fix (2026-02-16)
+
+0.6.0 — Calendar & reservation mode, device pairing interface, calibration UX overhaul, modem dashboard enhancements (2026-02-06)
+
+0.5.1 — Dashboard schedule view with today's actions panel, new Terra-View branding and logo rework (2026-01-27)
+
+0.4.4 — Recurring schedules, alerting UI, report templates + RND viewer, and SLM workflow polish (2026-01-23)
+
+0.4.3 — SLM roster/project view refresh, project insight panels, FTP browser folder downloads, and SLMM sync (2026-01-14)
+
+0.4.2 — SLM configuration interface with TCP/FTP controls, modem diagnostics, and dashboard endpoints for Sound Level Meters (2026-01-05)
+
+0.4.1 — Sound Level Meter integration with full management UI for SLM units (2026-01-05)
+
+0.4.0 — Database management system with backup/restore and remote cloning (2025-12-16)
+
+0.3.3 — Mobile navigation improvements and better status visibility (2025-12-12)
 
 0.3.2 — Progressive Web App with mobile optimization (2025-12-12)
 

app/api/dashboard.py

@@ -1,13 +0,0 @@
-"""
-API Aggregation Layer - Dashboard endpoints
-Composes data from multiple feature modules
-"""
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/api/dashboard", tags=["dashboard-aggregation"])
-
-# TODO: Implement aggregation endpoints that combine data from
-# app.seismo and app.slm modules
-
-# For now, individual feature modules expose their own APIs directly
-# Future: Add cross-feature aggregation here

app/api/roster.py

@@ -1,13 +0,0 @@
-"""
-API Aggregation Layer - Roster endpoints
-Aggregates roster data from all feature modules
-"""
-from fastapi import APIRouter
-
-router = APIRouter(prefix="/api/roster-aggregation", tags=["roster-aggregation"])
-
-# TODO: Implement unified roster endpoints that combine data from
-# app.seismo and app.slm modules
-
-# For now, individual feature modules expose their own roster APIs
-# Future: Add cross-feature roster aggregation here

app/core/config.py

@@ -1,20 +0,0 @@
-"""
-Core configuration for Terra-View application
-"""
-import os
-
-# Application
-APP_NAME = "Terra-View"
-VERSION = "1.0.0"
-ENVIRONMENT = os.getenv("ENVIRONMENT", "production")
-
-# Ports
-PORT = int(os.getenv("PORT", 8001))
-
-# External Services
-SLMM_API_URL = os.getenv("SLMM_API_URL", "http://localhost:8100")
-
-# Database URLs (feature-specific)
-SEISMO_DATABASE_URL = "sqlite:///./data/seismo.db"
-SLM_DATABASE_URL = "sqlite:///./data/slm.db"
-MODEM_DATABASE_URL = "sqlite:///./data/modem.db"

app/main.py

@@ -1,205 +0,0 @@
-"""
-Terra-View - Unified monitoring platform for device fleets
-Modular monolith architecture with strict feature boundaries
-"""
-import os
-import logging
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import JSONResponse
-from fastapi.exceptions import RequestValidationError
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-# Import configuration
-from app.core.config import APP_NAME, VERSION, ENVIRONMENT
-
-# Import UI routes
-from app.ui import routes as ui_routes
-
-# Import feature module routers (seismo)
-from app.seismo.routers import (
-    roster as seismo_roster,
-    units as seismo_units,
-    photos as seismo_photos,
-    roster_edit as seismo_roster_edit,
-    dashboard as seismo_dashboard,
-    dashboard_tabs as seismo_dashboard_tabs,
-    activity as seismo_activity,
-    seismo_dashboard as seismo_seismo_dashboard,
-    settings as seismo_settings,
-)
-from app.seismo import routes as seismo_legacy_routes
-
-# Import feature module routers (SLM)
-from app.slm.routers import router as slm_router
-
-# Import API aggregation layer (placeholder for now)
-from app.api import dashboard as api_dashboard
-from app.api import roster as api_roster
-
-# Initialize database tables
-from app.seismo.database import engine as seismo_engine, Base as SeismoBase
-SeismoBase.metadata.create_all(bind=seismo_engine)
-
-# Initialize FastAPI app
-app = FastAPI(
-    title=APP_NAME,
-    description="Unified monitoring platform for seismograph, modem, and sound level meter fleets",
-    version=VERSION
-)
-
-# Add validation error handler to log details
-@app.exception_handler(RequestValidationError)
-async def validation_exception_handler(request: Request, exc: RequestValidationError):
-    logger.error(f"Validation error on {request.url}: {exc.errors()}")
-    logger.error(f"Body: {await request.body()}")
-    return JSONResponse(
-        status_code=400,
-        content={"detail": exc.errors()}
-    )
-
-# Configure CORS
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Mount static files
-app.mount("/static", StaticFiles(directory="app/ui/static"), name="static")
-
-# Middleware to add environment to request state
-@app.middleware("http")
-async def add_environment_to_context(request: Request, call_next):
-    """Middleware to add environment variable to request state"""
-    request.state.environment = ENVIRONMENT
-    response = await call_next(request)
-    return response
-
-# ===== INCLUDE ROUTERS =====
-
-# UI Layer (HTML pages)
-app.include_router(ui_routes.router)
-
-# Seismograph Feature Module APIs
-app.include_router(seismo_roster.router)
-app.include_router(seismo_units.router)
-app.include_router(seismo_photos.router)
-app.include_router(seismo_roster_edit.router)
-app.include_router(seismo_dashboard.router)
-app.include_router(seismo_dashboard_tabs.router)
-app.include_router(seismo_activity.router)
-app.include_router(seismo_seismo_dashboard.router)
-app.include_router(seismo_settings.router)
-app.include_router(seismo_legacy_routes.router)
-
-# SLM Feature Module APIs
-app.include_router(slm_router)
-
-# API Aggregation Layer (future cross-feature endpoints)
-# app.include_router(api_dashboard.router)  # TODO: Implement aggregation
-# app.include_router(api_roster.router)     # TODO: Implement aggregation
-
-# ===== ADDITIONAL ROUTES FROM OLD MAIN.PY =====
-# These will need to be migrated to appropriate modules
-
-from fastapi.templating import Jinja2Templates
-from typing import List, Dict
-from pydantic import BaseModel
-from sqlalchemy.orm import Session
-from fastapi import Depends
-
-from app.seismo.database import get_db
-from app.seismo.services.snapshot import emit_status_snapshot
-from app.seismo.models import IgnoredUnit
-
-# TODO: Move these to appropriate feature modules or UI layer
-
-@app.post("/api/sync-edits")
-async def sync_edits(request: dict, db: Session = Depends(get_db)):
-    """Process offline edit queue and sync to database"""
-    # TODO: Move to seismo module
-    from app.seismo.models import RosterUnit
-
-    class EditItem(BaseModel):
-        id: int
-        unitId: str
-        changes: Dict
-        timestamp: int
-
-    class SyncEditsRequest(BaseModel):
-        edits: List[EditItem]
-
-    sync_request = SyncEditsRequest(**request)
-    results = []
-    synced_ids = []
-
-    for edit in sync_request.edits:
-        try:
-            unit = db.query(RosterUnit).filter_by(id=edit.unitId).first()
-
-            if not unit:
-                results.append({
-                    "id": edit.id,
-                    "status": "error",
-                    "reason": f"Unit {edit.unitId} not found"
-                })
-                continue
-
-            for key, value in edit.changes.items():
-                if hasattr(unit, key):
-                    if key in ['deployed', 'retired']:
-                        setattr(unit, key, value in ['true', True, 'True', '1', 1])
-                    else:
-                        setattr(unit, key, value if value != '' else None)
-
-            db.commit()
-
-            results.append({
-                "id": edit.id,
-                "status": "success"
-            })
-            synced_ids.append(edit.id)
-
-        except Exception as e:
-            db.rollback()
-            results.append({
-                "id": edit.id,
-                "status": "error",
-                "reason": str(e)
-            })
-
-    synced_count = len(synced_ids)
-
-    return JSONResponse({
-        "synced": synced_count,
-        "total": len(sync_request.edits),
-        "synced_ids": synced_ids,
-        "results": results
-    })
-
-
-@app.get("/health")
-def health_check():
-    """Health check endpoint"""
-    return {
-        "message": f"{APP_NAME} v{VERSION}",
-        "status": "running",
-        "version": VERSION,
-        "modules": ["seismo", "slm"]
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-    from app.core.config import PORT
-    uvicorn.run(app, host="0.0.0.0", port=PORT)

app/seismo/database.py

@@ -1,36 +0,0 @@
-"""
-Seismograph feature module database connection
-"""
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-import os
-
-# Ensure data directory exists
-os.makedirs("data", exist_ok=True)
-
-# For now, we'll use the old database (seismo_fleet.db) until we migrate
-# TODO: Migrate to seismo.db
-SQLALCHEMY_DATABASE_URL = "sqlite:///./data/seismo_fleet.db"
-
-engine = create_engine(
-    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
-)
-
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-
-Base = declarative_base()
-
-
-def get_db():
-    """Dependency for database sessions"""
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-
-def get_db_session():
-    """Get a database session directly (not as a dependency)"""
-    return SessionLocal()

app/seismo/models.py

@@ -1,110 +0,0 @@
-from sqlalchemy import Column, String, DateTime, Boolean, Text, Date, Integer
-from datetime import datetime
-from app.seismo.database import Base
-
-
-class Emitter(Base):
-    __tablename__ = "emitters"
-
-    id = Column(String, primary_key=True, index=True)
-    unit_type = Column(String, nullable=False)
-    last_seen = Column(DateTime, default=datetime.utcnow)
-    last_file = Column(String, nullable=False)
-    status = Column(String, nullable=False)
-    notes = Column(String, nullable=True)
-
-
-class RosterUnit(Base):
-    """
-    Roster table: represents our *intended assignment* of a unit.
-    This is editable from the GUI.
-
-    Supports multiple device types (seismograph, modem, sound_level_meter) with type-specific fields.
-    """
-    __tablename__ = "roster"
-
-    # Core fields (all device types)
-    id = Column(String, primary_key=True, index=True)
-    unit_type = Column(String, default="series3")  # Backward compatibility
-    device_type = Column(String, default="seismograph")  # "seismograph" | "modem" | "sound_level_meter"
-    deployed = Column(Boolean, default=True)
-    retired = Column(Boolean, default=False)
-    note = Column(String, nullable=True)
-    project_id = Column(String, nullable=True)
-    location = Column(String, nullable=True)  # Legacy field - use address/coordinates instead
-    address = Column(String, nullable=True)  # Human-readable address
-    coordinates = Column(String, nullable=True)  # Lat,Lon format: "34.0522,-118.2437"
-    last_updated = Column(DateTime, default=datetime.utcnow)
-
-    # Seismograph-specific fields (nullable for modems and SLMs)
-    last_calibrated = Column(Date, nullable=True)
-    next_calibration_due = Column(Date, nullable=True)
-
-    # Modem assignment (shared by seismographs and SLMs)
-    deployed_with_modem_id = Column(String, nullable=True)  # FK to another RosterUnit (device_type=modem)
-
-    # Modem-specific fields (nullable for seismographs and SLMs)
-    ip_address = Column(String, nullable=True)
-    phone_number = Column(String, nullable=True)
-    hardware_model = Column(String, nullable=True)
-
-    # Sound Level Meter-specific fields (nullable for seismographs and modems)
-    slm_host = Column(String, nullable=True)  # Device IP or hostname
-    slm_tcp_port = Column(Integer, nullable=True)  # TCP control port (default 2255)
-    slm_ftp_port = Column(Integer, nullable=True)  # FTP data retrieval port (default 21)
-    slm_model = Column(String, nullable=True)  # NL-43, NL-53, etc.
-    slm_serial_number = Column(String, nullable=True)  # Device serial number
-    slm_frequency_weighting = Column(String, nullable=True)  # A, C, Z
-    slm_time_weighting = Column(String, nullable=True)  # F (Fast), S (Slow), I (Impulse)
-    slm_measurement_range = Column(String, nullable=True)  # e.g., "30-130 dB"
-    slm_last_check = Column(DateTime, nullable=True)  # Last communication check
-
-
-class IgnoredUnit(Base):
-    """
-    Ignored units: units that report but should be filtered out from unknown emitters.
-    Used to suppress noise from old projects.
-    """
-    __tablename__ = "ignored_units"
-
-    id = Column(String, primary_key=True, index=True)
-    reason = Column(String, nullable=True)
-    ignored_at = Column(DateTime, default=datetime.utcnow)
-
-
-class UnitHistory(Base):
-    """
-    Unit history: complete timeline of changes to each unit.
-    Tracks note changes, status changes, deployment/benched events, and more.
-    """
-    __tablename__ = "unit_history"
-
-    id = Column(Integer, primary_key=True, autoincrement=True)
-    unit_id = Column(String, nullable=False, index=True)  # FK to RosterUnit.id
-    change_type = Column(String, nullable=False)  # note_change, deployed_change, retired_change, etc.
-    field_name = Column(String, nullable=True)  # Which field changed
-    old_value = Column(Text, nullable=True)  # Previous value
-    new_value = Column(Text, nullable=True)  # New value
-    changed_at = Column(DateTime, default=datetime.utcnow, nullable=False, index=True)
-    source = Column(String, default="manual")  # manual, csv_import, telemetry, offline_sync
-    notes = Column(Text, nullable=True)  # Optional reason/context for the change
-
-
-class UserPreferences(Base):
-    """
-    User preferences: persistent storage for application settings.
-    Single-row table (id=1) to store global user preferences.
-    """
-    __tablename__ = "user_preferences"
-
-    id = Column(Integer, primary_key=True, default=1)
-    timezone = Column(String, default="America/New_York")
-    theme = Column(String, default="auto")  # auto, light, dark
-    auto_refresh_interval = Column(Integer, default=10)  # seconds
-    date_format = Column(String, default="MM/DD/YYYY")
-    table_rows_per_page = Column(Integer, default=25)
-    calibration_interval_days = Column(Integer, default=365)
-    calibration_warning_days = Column(Integer, default=30)
-    status_ok_threshold_hours = Column(Integer, default=12)
-    status_pending_threshold_hours = Column(Integer, default=24)
-    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

app/seismo/routers/dashboard.py

@@ -1,25 +0,0 @@
-from fastapi import APIRouter, Request, Depends
-from fastapi.templating import Jinja2Templates
-
-from app.seismo.services.snapshot import emit_status_snapshot
-
-router = APIRouter()
-templates = Jinja2Templates(directory="templates")
-
-
-@router.get("/dashboard/active")
-def dashboard_active(request: Request):
-    snapshot = emit_status_snapshot()
-    return templates.TemplateResponse(
-        "partials/active_table.html",
-        {"request": request, "units": snapshot["active"]}
-    )
-
-
-@router.get("/dashboard/benched")
-def dashboard_benched(request: Request):
-    snapshot = emit_status_snapshot()
-    return templates.TemplateResponse(
-        "partials/benched_table.html",
-        {"request": request, "units": snapshot["benched"]}
-    )

app/seismo/routers/roster_edit.py

@@ -1,720 +0,0 @@
-from fastapi import APIRouter, Depends, HTTPException, Form, UploadFile, File, Request
-from fastapi.exceptions import RequestValidationError
-from sqlalchemy.orm import Session
-from datetime import datetime, date
-import csv
-import io
-import logging
-import httpx
-import os
-
-from app.seismo.database import get_db
-from app.seismo.models import RosterUnit, IgnoredUnit, Emitter, UnitHistory
-
-router = APIRouter(prefix="/api/roster", tags=["roster-edit"])
-logger = logging.getLogger(__name__)
-
-# SLMM backend URL for syncing device configs to cache
-SLMM_BASE_URL = os.getenv("SLMM_BASE_URL", "http://localhost:8100")
-
-
-def record_history(db: Session, unit_id: str, change_type: str, field_name: str = None,
-                   old_value: str = None, new_value: str = None, source: str = "manual", notes: str = None):
-    """Helper function to record a change in unit history"""
-    history_entry = UnitHistory(
-        unit_id=unit_id,
-        change_type=change_type,
-        field_name=field_name,
-        old_value=old_value,
-        new_value=new_value,
-        changed_at=datetime.utcnow(),
-        source=source,
-        notes=notes
-    )
-    db.add(history_entry)
-    # Note: caller is responsible for db.commit()
-
-
-def get_or_create_roster_unit(db: Session, unit_id: str):
-    unit = db.query(RosterUnit).filter(RosterUnit.id == unit_id).first()
-    if not unit:
-        unit = RosterUnit(id=unit_id)
-        db.add(unit)
-        db.commit()
-        db.refresh(unit)
-    return unit
-
-
-async def sync_slm_to_slmm_cache(
-    unit_id: str,
-    host: str = None,
-    tcp_port: int = None,
-    ftp_port: int = None,
-    ftp_username: str = None,
-    ftp_password: str = None,
-    deployed_with_modem_id: str = None,
-    db: Session = None
-) -> dict:
-    """
-    Sync SLM device configuration to SLMM backend cache.
-
-    Terra-View is the source of truth for device configs. This function updates
-    SLMM's config cache (NL43Config table) so SLMM can look up device connection
-    info by unit_id without Terra-View passing host:port with every request.
-
-    Args:
-        unit_id: Unique identifier for the SLM device
-        host: Direct IP address/hostname OR will be resolved from modem
-        tcp_port: TCP control port (default: 2255)
-        ftp_port: FTP port (default: 21)
-        ftp_username: FTP username (optional)
-        ftp_password: FTP password (optional)
-        deployed_with_modem_id: If set, resolve modem IP as host
-        db: Database session for modem lookup
-
-    Returns:
-        dict: {"success": bool, "message": str}
-    """
-    # Resolve host from modem if assigned
-    if deployed_with_modem_id and db:
-        modem = db.query(RosterUnit).filter_by(
-            id=deployed_with_modem_id,
-            device_type="modem"
-        ).first()
-        if modem and modem.ip_address:
-            host = modem.ip_address
-            logger.info(f"Resolved host from modem {deployed_with_modem_id}: {host}")
-
-    # Validate required fields
-    if not host:
-        logger.warning(f"Cannot sync SLM {unit_id} to SLMM: no host/IP address provided")
-        return {"success": False, "message": "No host IP address available"}
-
-    # Set defaults
-    tcp_port = tcp_port or 2255
-    ftp_port = ftp_port or 21
-
-    # Build SLMM cache payload
-    config_payload = {
-        "host": host,
-        "tcp_port": tcp_port,
-        "tcp_enabled": True,
-        "ftp_enabled": bool(ftp_username and ftp_password),
-        "web_enabled": False
-    }
-
-    if ftp_username and ftp_password:
-        config_payload["ftp_username"] = ftp_username
-        config_payload["ftp_password"] = ftp_password
-
-    # Call SLMM cache update API
-    slmm_url = f"{SLMM_BASE_URL}/api/nl43/{unit_id}/config"
-
-    try:
-        async with httpx.AsyncClient(timeout=10.0) as client:
-            response = await client.put(slmm_url, json=config_payload)
-
-            if response.status_code in [200, 201]:
-                logger.info(f"Successfully synced SLM {unit_id} to SLMM cache")
-                return {"success": True, "message": "Device config cached in SLMM"}
-            else:
-                logger.error(f"SLMM cache sync failed for {unit_id}: HTTP {response.status_code}")
-                return {"success": False, "message": f"SLMM returned status {response.status_code}"}
-
-    except httpx.ConnectError:
-        logger.error(f"Cannot connect to SLMM service at {SLMM_BASE_URL}")
-        return {"success": False, "message": "SLMM service unavailable"}
-
-    except Exception as e:
-        logger.error(f"Error syncing SLM {unit_id} to SLMM: {e}")
-        return {"success": False, "message": str(e)}
-
-
-@router.post("/add")
-async def add_roster_unit(
-    id: str = Form(...),
-    device_type: str = Form("seismograph"),
-    unit_type: str = Form("series3"),
-    deployed: str = Form(None),
-    retired: str = Form(None),
-    note: str = Form(""),
-    project_id: str = Form(None),
-    location: str = Form(None),
-    address: str = Form(None),
-    coordinates: str = Form(None),
-    # Seismograph-specific fields
-    last_calibrated: str = Form(None),
-    next_calibration_due: str = Form(None),
-    deployed_with_modem_id: str = Form(None),
-    # Modem-specific fields
-    ip_address: str = Form(None),
-    phone_number: str = Form(None),
-    hardware_model: str = Form(None),
-    # Sound Level Meter-specific fields
-    slm_host: str = Form(None),
-    slm_tcp_port: str = Form(None),
-    slm_ftp_port: str = Form(None),
-    slm_model: str = Form(None),
-    slm_serial_number: str = Form(None),
-    slm_frequency_weighting: str = Form(None),
-    slm_time_weighting: str = Form(None),
-    slm_measurement_range: str = Form(None),
-    db: Session = Depends(get_db)
-):
-    logger.info(f"Adding unit: id={id}, device_type={device_type}, deployed={deployed}, retired={retired}")
-
-    # Convert boolean strings to actual booleans
-    deployed_bool = deployed in ['true', 'True', '1', 'yes'] if deployed else False
-    retired_bool = retired in ['true', 'True', '1', 'yes'] if retired else False
-
-    # Convert port strings to integers
-    slm_tcp_port_int = int(slm_tcp_port) if slm_tcp_port and slm_tcp_port.strip() else None
-    slm_ftp_port_int = int(slm_ftp_port) if slm_ftp_port and slm_ftp_port.strip() else None
-
-    if db.query(RosterUnit).filter(RosterUnit.id == id).first():
-        raise HTTPException(status_code=400, detail="Unit already exists")
-
-    # Parse date fields if provided
-    last_cal_date = None
-    if last_calibrated:
-        try:
-            last_cal_date = datetime.strptime(last_calibrated, "%Y-%m-%d").date()
-        except ValueError:
-            raise HTTPException(status_code=400, detail="Invalid last_calibrated date format. Use YYYY-MM-DD")
-
-    next_cal_date = None
-    if next_calibration_due:
-        try:
-            next_cal_date = datetime.strptime(next_calibration_due, "%Y-%m-%d").date()
-        except ValueError:
-            raise HTTPException(status_code=400, detail="Invalid next_calibration_due date format. Use YYYY-MM-DD")
-
-    unit = RosterUnit(
-        id=id,
-        device_type=device_type,
-        unit_type=unit_type,
-        deployed=deployed_bool,
-        retired=retired_bool,
-        note=note,
-        project_id=project_id,
-        location=location,
-        address=address,
-        coordinates=coordinates,
-        last_updated=datetime.utcnow(),
-        # Seismograph-specific fields
-        last_calibrated=last_cal_date,
-        next_calibration_due=next_cal_date,
-        deployed_with_modem_id=deployed_with_modem_id if deployed_with_modem_id else None,
-        # Modem-specific fields
-        ip_address=ip_address if ip_address else None,
-        phone_number=phone_number if phone_number else None,
-        hardware_model=hardware_model if hardware_model else None,
-        # Sound Level Meter-specific fields
-        slm_host=slm_host if slm_host else None,
-        slm_tcp_port=slm_tcp_port_int,
-        slm_ftp_port=slm_ftp_port_int,
-        slm_model=slm_model if slm_model else None,
-        slm_serial_number=slm_serial_number if slm_serial_number else None,
-        slm_frequency_weighting=slm_frequency_weighting if slm_frequency_weighting else None,
-        slm_time_weighting=slm_time_weighting if slm_time_weighting else None,
-        slm_measurement_range=slm_measurement_range if slm_measurement_range else None,
-    )
-    db.add(unit)
-    db.commit()
-
-    # If sound level meter, sync config to SLMM cache
-    if device_type == "sound_level_meter":
-        logger.info(f"Syncing SLM {id} config to SLMM cache...")
-        result = await sync_slm_to_slmm_cache(
-            unit_id=id,
-            host=slm_host,
-            tcp_port=slm_tcp_port_int,
-            ftp_port=slm_ftp_port_int,
-            deployed_with_modem_id=deployed_with_modem_id,
-            db=db
-        )
-
-        if not result["success"]:
-            logger.warning(f"SLMM cache sync warning for {id}: {result['message']}")
-            # Don't fail the operation - device is still added to Terra-View roster
-            # User can manually sync later or SLMM will be synced on next config update
-
-    return {"message": "Unit added", "id": id, "device_type": device_type}
-
-
-@router.get("/modems")
-def get_modems_list(db: Session = Depends(get_db)):
-    """Get list of all modem units for dropdown selection"""
-    modems = db.query(RosterUnit).filter_by(device_type="modem", retired=False).order_by(RosterUnit.id).all()
-
-    return [
-        {
-            "id": modem.id,
-            "ip_address": modem.ip_address,
-            "phone_number": modem.phone_number,
-            "hardware_model": modem.hardware_model,
-            "deployed": modem.deployed
-        }
-        for modem in modems
-    ]
-
-
-@router.get("/{unit_id}")
-def get_roster_unit(unit_id: str, db: Session = Depends(get_db)):
-    """Get a single roster unit by ID"""
-    unit = db.query(RosterUnit).filter(RosterUnit.id == unit_id).first()
-    if not unit:
-        raise HTTPException(status_code=404, detail="Unit not found")
-
-    return {
-        "id": unit.id,
-        "device_type": unit.device_type or "seismograph",
-        "unit_type": unit.unit_type,
-        "deployed": unit.deployed,
-        "retired": unit.retired,
-        "note": unit.note or "",
-        "project_id": unit.project_id or "",
-        "location": unit.location or "",
-        "address": unit.address or "",
-        "coordinates": unit.coordinates or "",
-        "last_calibrated": unit.last_calibrated.isoformat() if unit.last_calibrated else "",
-        "next_calibration_due": unit.next_calibration_due.isoformat() if unit.next_calibration_due else "",
-        "deployed_with_modem_id": unit.deployed_with_modem_id or "",
-        "ip_address": unit.ip_address or "",
-        "phone_number": unit.phone_number or "",
-        "hardware_model": unit.hardware_model or "",
-        "slm_host": unit.slm_host or "",
-        "slm_tcp_port": unit.slm_tcp_port or "",
-        "slm_ftp_port": unit.slm_ftp_port or "",
-        "slm_model": unit.slm_model or "",
-        "slm_serial_number": unit.slm_serial_number or "",
-        "slm_frequency_weighting": unit.slm_frequency_weighting or "",
-        "slm_time_weighting": unit.slm_time_weighting or "",
-        "slm_measurement_range": unit.slm_measurement_range or "",
-    }
-
-
-@router.post("/edit/{unit_id}")
-def edit_roster_unit(
-    unit_id: str,
-    device_type: str = Form("seismograph"),
-    unit_type: str = Form("series3"),
-    deployed: str = Form(None),
-    retired: str = Form(None),
-    note: str = Form(""),
-    project_id: str = Form(None),
-    location: str = Form(None),
-    address: str = Form(None),
-    coordinates: str = Form(None),
-    # Seismograph-specific fields
-    last_calibrated: str = Form(None),
-    next_calibration_due: str = Form(None),
-    deployed_with_modem_id: str = Form(None),
-    # Modem-specific fields
-    ip_address: str = Form(None),
-    phone_number: str = Form(None),
-    hardware_model: str = Form(None),
-    # Sound Level Meter-specific fields
-    slm_host: str = Form(None),
-    slm_tcp_port: str = Form(None),
-    slm_ftp_port: str = Form(None),
-    slm_model: str = Form(None),
-    slm_serial_number: str = Form(None),
-    slm_frequency_weighting: str = Form(None),
-    slm_time_weighting: str = Form(None),
-    slm_measurement_range: str = Form(None),
-    db: Session = Depends(get_db)
-):
-    unit = db.query(RosterUnit).filter(RosterUnit.id == unit_id).first()
-    if not unit:
-        raise HTTPException(status_code=404, detail="Unit not found")
-
-    # Convert boolean strings to actual booleans
-    deployed_bool = deployed in ['true', 'True', '1', 'yes'] if deployed else False
-    retired_bool = retired in ['true', 'True', '1', 'yes'] if retired else False
-
-    # Convert port strings to integers
-    slm_tcp_port_int = int(slm_tcp_port) if slm_tcp_port and slm_tcp_port.strip() else None
-    slm_ftp_port_int = int(slm_ftp_port) if slm_ftp_port and slm_ftp_port.strip() else None
-
-    # Parse date fields if provided
-    last_cal_date = None
-    if last_calibrated:
-        try:
-            last_cal_date = datetime.strptime(last_calibrated, "%Y-%m-%d").date()
-        except ValueError:
-            raise HTTPException(status_code=400, detail="Invalid last_calibrated date format. Use YYYY-MM-DD")
-
-    next_cal_date = None
-    if next_calibration_due:
-        try:
-            next_cal_date = datetime.strptime(next_calibration_due, "%Y-%m-%d").date()
-        except ValueError:
-            raise HTTPException(status_code=400, detail="Invalid next_calibration_due date format. Use YYYY-MM-DD")
-
-    # Track changes for history
-    old_note = unit.note
-    old_deployed = unit.deployed
-    old_retired = unit.retired
-
-    # Update all fields
-    unit.device_type = device_type
-    unit.unit_type = unit_type
-    unit.deployed = deployed_bool
-    unit.retired = retired_bool
-    unit.note = note
-    unit.project_id = project_id
-    unit.location = location
-    unit.address = address
-    unit.coordinates = coordinates
-    unit.last_updated = datetime.utcnow()
-
-    # Seismograph-specific fields
-    unit.last_calibrated = last_cal_date
-    unit.next_calibration_due = next_cal_date
-    unit.deployed_with_modem_id = deployed_with_modem_id if deployed_with_modem_id else None
-
-    # Modem-specific fields
-    unit.ip_address = ip_address if ip_address else None
-    unit.phone_number = phone_number if phone_number else None
-    unit.hardware_model = hardware_model if hardware_model else None
-
-    # Sound Level Meter-specific fields
-    unit.slm_host = slm_host if slm_host else None
-    unit.slm_tcp_port = slm_tcp_port_int
-    unit.slm_ftp_port = slm_ftp_port_int
-    unit.slm_model = slm_model if slm_model else None
-    unit.slm_serial_number = slm_serial_number if slm_serial_number else None
-    unit.slm_frequency_weighting = slm_frequency_weighting if slm_frequency_weighting else None
-    unit.slm_time_weighting = slm_time_weighting if slm_time_weighting else None
-    unit.slm_measurement_range = slm_measurement_range if slm_measurement_range else None
-
-    # Record history entries for changed fields
-    if old_note != note:
-        record_history(db, unit_id, "note_change", "note", old_note, note, "manual")
-
-    if old_deployed != deployed:
-        status_text = "deployed" if deployed else "benched"
-        old_status_text = "deployed" if old_deployed else "benched"
-        record_history(db, unit_id, "deployed_change", "deployed", old_status_text, status_text, "manual")
-
-    if old_retired != retired:
-        status_text = "retired" if retired else "active"
-        old_status_text = "retired" if old_retired else "active"
-        record_history(db, unit_id, "retired_change", "retired", old_status_text, status_text, "manual")
-
-    db.commit()
-    return {"message": "Unit updated", "id": unit_id, "device_type": device_type}
-
-
-@router.post("/set-deployed/{unit_id}")
-def set_deployed(unit_id: str, deployed: bool = Form(...), db: Session = Depends(get_db)):
-    unit = get_or_create_roster_unit(db, unit_id)
-    old_deployed = unit.deployed
-    unit.deployed = deployed
-    unit.last_updated = datetime.utcnow()
-
-    # Record history entry for deployed status change
-    if old_deployed != deployed:
-        status_text = "deployed" if deployed else "benched"
-        old_status_text = "deployed" if old_deployed else "benched"
-        record_history(
-            db=db,
-            unit_id=unit_id,
-            change_type="deployed_change",
-            field_name="deployed",
-            old_value=old_status_text,
-            new_value=status_text,
-            source="manual"
-        )
-
-    db.commit()
-    return {"message": "Updated", "id": unit_id, "deployed": deployed}
-
-
-@router.post("/set-retired/{unit_id}")
-def set_retired(unit_id: str, retired: bool = Form(...), db: Session = Depends(get_db)):
-    unit = get_or_create_roster_unit(db, unit_id)
-    old_retired = unit.retired
-    unit.retired = retired
-    unit.last_updated = datetime.utcnow()
-
-    # Record history entry for retired status change
-    if old_retired != retired:
-        status_text = "retired" if retired else "active"
-        old_status_text = "retired" if old_retired else "active"
-        record_history(
-            db=db,
-            unit_id=unit_id,
-            change_type="retired_change",
-            field_name="retired",
-            old_value=old_status_text,
-            new_value=status_text,
-            source="manual"
-        )
-
-    db.commit()
-    return {"message": "Updated", "id": unit_id, "retired": retired}
-
-
-@router.delete("/{unit_id}")
-def delete_roster_unit(unit_id: str, db: Session = Depends(get_db)):
-    """
-    Permanently delete a unit from the database.
-    Checks roster, emitters, and ignored_units tables and deletes from any table where the unit exists.
-    """
-    deleted = False
-
-    # Try to delete from roster table
-    roster_unit = db.query(RosterUnit).filter(RosterUnit.id == unit_id).first()
-    if roster_unit:
-        db.delete(roster_unit)
-        deleted = True
-
-    # Try to delete from emitters table
-    emitter = db.query(Emitter).filter(Emitter.id == unit_id).first()
-    if emitter:
-        db.delete(emitter)
-        deleted = True
-
-    # Try to delete from ignored_units table
-    ignored_unit = db.query(IgnoredUnit).filter(IgnoredUnit.id == unit_id).first()
-    if ignored_unit:
-        db.delete(ignored_unit)
-        deleted = True
-
-    # If not found in any table, return error
-    if not deleted:
-        raise HTTPException(status_code=404, detail="Unit not found")
-
-    db.commit()
-    return {"message": "Unit deleted", "id": unit_id}
-
-
-@router.post("/set-note/{unit_id}")
-def set_note(unit_id: str, note: str = Form(""), db: Session = Depends(get_db)):
-    unit = get_or_create_roster_unit(db, unit_id)
-    old_note = unit.note
-    unit.note = note
-    unit.last_updated = datetime.utcnow()
-
-    # Record history entry for note change
-    if old_note != note:
-        record_history(
-            db=db,
-            unit_id=unit_id,
-            change_type="note_change",
-            field_name="note",
-            old_value=old_note,
-            new_value=note,
-            source="manual"
-        )
-
-    db.commit()
-    return {"message": "Updated", "id": unit_id, "note": note}
-
-
-@router.post("/import-csv")
-async def import_csv(
-    file: UploadFile = File(...),
-    update_existing: bool = Form(True),
-    db: Session = Depends(get_db)
-):
-    """
-    Import roster units from CSV file.
-
-    Expected CSV columns (unit_id is required, others are optional):
-    - unit_id: Unique identifier for the unit
-    - unit_type: Type of unit (default: "series3")
-    - deployed: Boolean for deployment status (default: False)
-    - retired: Boolean for retirement status (default: False)
-    - note: Notes about the unit
-    - project_id: Project identifier
-    - location: Location description
-
-    Args:
-        file: CSV file upload
-        update_existing: If True, update existing units; if False, skip them
-    """
-
-    if not file.filename.endswith('.csv'):
-        raise HTTPException(status_code=400, detail="File must be a CSV")
-
-    # Read file content
-    contents = await file.read()
-    csv_text = contents.decode('utf-8')
-    csv_reader = csv.DictReader(io.StringIO(csv_text))
-
-    results = {
-        "added": [],
-        "updated": [],
-        "skipped": [],
-        "errors": []
-    }
-
-    for row_num, row in enumerate(csv_reader, start=2):  # Start at 2 to account for header
-        try:
-            # Validate required field
-            unit_id = row.get('unit_id', '').strip()
-            if not unit_id:
-                results["errors"].append({
-                    "row": row_num,
-                    "error": "Missing required field: unit_id"
-                })
-                continue
-
-            # Check if unit exists
-            existing_unit = db.query(RosterUnit).filter(RosterUnit.id == unit_id).first()
-
-            if existing_unit:
-                if not update_existing:
-                    results["skipped"].append(unit_id)
-                    continue
-
-                # Update existing unit
-                existing_unit.unit_type = row.get('unit_type', existing_unit.unit_type or 'series3')
-                existing_unit.deployed = row.get('deployed', '').lower() in ('true', '1', 'yes') if row.get('deployed') else existing_unit.deployed
-                existing_unit.retired = row.get('retired', '').lower() in ('true', '1', 'yes') if row.get('retired') else existing_unit.retired
-                existing_unit.note = row.get('note', existing_unit.note or '')
-                existing_unit.project_id = row.get('project_id', existing_unit.project_id)
-                existing_unit.location = row.get('location', existing_unit.location)
-                existing_unit.address = row.get('address', existing_unit.address)
-                existing_unit.coordinates = row.get('coordinates', existing_unit.coordinates)
-                existing_unit.last_updated = datetime.utcnow()
-
-                results["updated"].append(unit_id)
-            else:
-                # Create new unit
-                new_unit = RosterUnit(
-                    id=unit_id,
-                    unit_type=row.get('unit_type', 'series3'),
-                    deployed=row.get('deployed', '').lower() in ('true', '1', 'yes'),
-                    retired=row.get('retired', '').lower() in ('true', '1', 'yes'),
-                    note=row.get('note', ''),
-                    project_id=row.get('project_id'),
-                    location=row.get('location'),
-                    address=row.get('address'),
-                    coordinates=row.get('coordinates'),
-                    last_updated=datetime.utcnow()
-                )
-                db.add(new_unit)
-                results["added"].append(unit_id)
-
-        except Exception as e:
-            results["errors"].append({
-                "row": row_num,
-                "unit_id": row.get('unit_id', 'unknown'),
-                "error": str(e)
-            })
-
-    # Commit all changes
-    try:
-        db.commit()
-    except Exception as e:
-        db.rollback()
-        raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
-
-    return {
-        "message": "CSV import completed",
-        "summary": {
-            "added": len(results["added"]),
-            "updated": len(results["updated"]),
-            "skipped": len(results["skipped"]),
-            "errors": len(results["errors"])
-        },
-        "details": results
-    }
-
-
-@router.post("/ignore/{unit_id}")
-def ignore_unit(unit_id: str, reason: str = Form(""), db: Session = Depends(get_db)):
-    """
-    Add a unit to the ignore list to suppress it from unknown emitters.
-    """
-    # Check if already ignored
-    if db.query(IgnoredUnit).filter(IgnoredUnit.id == unit_id).first():
-        raise HTTPException(status_code=400, detail="Unit already ignored")
-
-    ignored = IgnoredUnit(
-        id=unit_id,
-        reason=reason,
-        ignored_at=datetime.utcnow()
-    )
-    db.add(ignored)
-    db.commit()
-    return {"message": "Unit ignored", "id": unit_id}
-
-
-@router.delete("/ignore/{unit_id}")
-def unignore_unit(unit_id: str, db: Session = Depends(get_db)):
-    """
-    Remove a unit from the ignore list.
-    """
-    ignored = db.query(IgnoredUnit).filter(IgnoredUnit.id == unit_id).first()
-    if not ignored:
-        raise HTTPException(status_code=404, detail="Unit not in ignore list")
-
-    db.delete(ignored)
-    db.commit()
-    return {"message": "Unit unignored", "id": unit_id}
-
-
-@router.get("/ignored")
-def list_ignored_units(db: Session = Depends(get_db)):
-    """
-    Get list of all ignored units.
-    """
-    ignored_units = db.query(IgnoredUnit).all()
-    return {
-        "ignored": [
-            {
-                "id": unit.id,
-                "reason": unit.reason,
-                "ignored_at": unit.ignored_at.isoformat()
-            }
-            for unit in ignored_units
-        ]
-    }
-
-
-@router.get("/history/{unit_id}")
-def get_unit_history(unit_id: str, db: Session = Depends(get_db)):
-    """
-    Get complete history timeline for a unit.
-    Returns all historical changes ordered by most recent first.
-    """
-    history_entries = db.query(UnitHistory).filter(
-        UnitHistory.unit_id == unit_id
-    ).order_by(UnitHistory.changed_at.desc()).all()
-
-    return {
-        "unit_id": unit_id,
-        "history": [
-            {
-                "id": entry.id,
-                "change_type": entry.change_type,
-                "field_name": entry.field_name,
-                "old_value": entry.old_value,
-                "new_value": entry.new_value,
-                "changed_at": entry.changed_at.isoformat(),
-                "source": entry.source,
-                "notes": entry.notes
-            }
-            for entry in history_entries
-        ]
-    }
-
-
-@router.delete("/history/{history_id}")
-def delete_history_entry(history_id: int, db: Session = Depends(get_db)):
-    """
-    Delete a specific history entry by ID.
-    Allows manual cleanup of old history entries.
-    """
-    history_entry = db.query(UnitHistory).filter(UnitHistory.id == history_id).first()
-    if not history_entry:
-        raise HTTPException(status_code=404, detail="History entry not found")
-
-    db.delete(history_entry)
-    db.commit()
-    return {"message": "History entry deleted", "id": history_id}

app/slm/__init__.py

@@ -1 +0,0 @@
-# SLMM addon package for NL43 integration.

app/slm/database.py

@@ -1,27 +0,0 @@
-from sqlalchemy import create_engine
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-import os
-
-# Ensure data directory exists for the SLMM addon
-os.makedirs("data", exist_ok=True)
-
-SQLALCHEMY_DATABASE_URL = "sqlite:///./data/slmm.db"
-
-engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
-
-
-def get_db():
-    """Dependency for database sessions."""
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-
-def get_db_session():
-    """Get a database session directly (not as a dependency)."""
-    return SessionLocal()

app/slm/main.py

@@ -1,116 +0,0 @@
-import os
-import logging
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import HTMLResponse
-from fastapi.templating import Jinja2Templates
-
-from app.slm.database import Base, engine
-from app.slm import routers
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-    handlers=[
-        logging.StreamHandler(),
-        logging.FileHandler("data/slmm.log"),
-    ],
-)
-logger = logging.getLogger(__name__)
-
-# Ensure database tables exist for the addon
-Base.metadata.create_all(bind=engine)
-logger.info("Database tables initialized")
-
-app = FastAPI(
-    title="SLMM NL43 Addon",
-    description="Standalone module for NL43 configuration and status APIs",
-    version="0.1.0",
-)
-
-# CORS configuration - use environment variable for allowed origins
-# Default to "*" for development, but should be restricted in production
-allowed_origins = os.getenv("CORS_ORIGINS", "*").split(",")
-logger.info(f"CORS allowed origins: {allowed_origins}")
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=allowed_origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-templates = Jinja2Templates(directory="templates")
-
-app.include_router(routers.router)
-
-
-@app.get("/", response_class=HTMLResponse)
-def index(request: Request):
-    return templates.TemplateResponse("index.html", {"request": request})
-
-
-@app.get("/health")
-async def health():
-    """Basic health check endpoint."""
-    return {"status": "ok", "service": "slmm-nl43-addon"}
-
-
-@app.get("/health/devices")
-async def health_devices():
-    """Enhanced health check that tests device connectivity."""
-    from sqlalchemy.orm import Session
-    from app.slm.database import SessionLocal
-    from app.slm.services import NL43Client
-    from app.slm.models import NL43Config
-
-    db: Session = SessionLocal()
-    device_status = []
-
-    try:
-        configs = db.query(NL43Config).filter_by(tcp_enabled=True).all()
-
-        for cfg in configs:
-            client = NL43Client(cfg.host, cfg.tcp_port, timeout=2.0, ftp_username=cfg.ftp_username, ftp_password=cfg.ftp_password)
-            status = {
-                "unit_id": cfg.unit_id,
-                "host": cfg.host,
-                "port": cfg.tcp_port,
-                "reachable": False,
-                "error": None,
-            }
-
-            try:
-                # Try to connect (don't send command to avoid rate limiting issues)
-                import asyncio
-                reader, writer = await asyncio.wait_for(
-                    asyncio.open_connection(cfg.host, cfg.tcp_port), timeout=2.0
-                )
-                writer.close()
-                await writer.wait_closed()
-                status["reachable"] = True
-            except Exception as e:
-                status["error"] = str(type(e).__name__)
-                logger.warning(f"Device {cfg.unit_id} health check failed: {e}")
-
-            device_status.append(status)
-
-    finally:
-        db.close()
-
-    all_reachable = all(d["reachable"] for d in device_status) if device_status else True
-
-    return {
-        "status": "ok" if all_reachable else "degraded",
-        "devices": device_status,
-        "total_devices": len(device_status),
-        "reachable_devices": sum(1 for d in device_status if d["reachable"]),
-    }
-
-
-if __name__ == "__main__":
-    import uvicorn
-
-    uvicorn.run("app.main:app", host="0.0.0.0", port=int(os.getenv("PORT", "8100")), reload=True)

app/slm/models.py

@@ -1,43 +0,0 @@
-from sqlalchemy import Column, String, DateTime, Boolean, Integer, Text, func
-from app.slm.database import Base
-
-
-class NL43Config(Base):
-    """
-    NL43 connection/config metadata for the standalone SLMM addon.
-    """
-
-    __tablename__ = "nl43_config"
-
-    unit_id = Column(String, primary_key=True, index=True)
-    host = Column(String, default="127.0.0.1")
-    tcp_port = Column(Integer, default=80)  # NL43 TCP control port (via RX55)
-    tcp_enabled = Column(Boolean, default=True)
-    ftp_enabled = Column(Boolean, default=False)
-    ftp_username = Column(String, nullable=True)  # FTP login username
-    ftp_password = Column(String, nullable=True)  # FTP login password
-    web_enabled = Column(Boolean, default=False)
-
-
-class NL43Status(Base):
-    """
-    Latest NL43 status snapshot for quick dashboard/API access.
-    """
-
-    __tablename__ = "nl43_status"
-
-    unit_id = Column(String, primary_key=True, index=True)
-    last_seen = Column(DateTime, default=func.now())
-    measurement_state = Column(String, default="unknown")  # Measure/Stop
-    measurement_start_time = Column(DateTime, nullable=True)  # When measurement started (UTC)
-    counter = Column(String, nullable=True)  # d0: Measurement interval counter (1-600)
-    lp = Column(String, nullable=True)    # Instantaneous sound pressure level
-    leq = Column(String, nullable=True)   # Equivalent continuous sound level
-    lmax = Column(String, nullable=True)  # Maximum level
-    lmin = Column(String, nullable=True)  # Minimum level
-    lpeak = Column(String, nullable=True)  # Peak level
-    battery_level = Column(String, nullable=True)
-    power_source = Column(String, nullable=True)
-    sd_remaining_mb = Column(String, nullable=True)
-    sd_free_ratio = Column(String, nullable=True)
-    raw_payload = Column(Text, nullable=True)

app/slm/services.py

@@ -1,828 +0,0 @@
-"""
-NL43 TCP connector and snapshot persistence.
-
-Implements simple per-request TCP calls to avoid long-lived socket complexity.
-Extend to pooled connections/DRD streaming later.
-"""
-
-import asyncio
-import contextlib
-import logging
-import time
-from dataclasses import dataclass
-from datetime import datetime
-from typing import Optional, List
-from sqlalchemy.orm import Session
-from ftplib import FTP
-from pathlib import Path
-
-from app.slm.models import NL43Status
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class NL43Snapshot:
-    unit_id: str
-    measurement_state: str = "unknown"
-    counter: Optional[str] = None  # d0: Measurement interval counter (1-600)
-    lp: Optional[str] = None    # Instantaneous sound pressure level
-    leq: Optional[str] = None   # Equivalent continuous sound level
-    lmax: Optional[str] = None  # Maximum level
-    lmin: Optional[str] = None  # Minimum level
-    lpeak: Optional[str] = None  # Peak level
-    battery_level: Optional[str] = None
-    power_source: Optional[str] = None
-    sd_remaining_mb: Optional[str] = None
-    sd_free_ratio: Optional[str] = None
-    raw_payload: Optional[str] = None
-
-
-def persist_snapshot(s: NL43Snapshot, db: Session):
-    """Persist the latest snapshot for API/dashboard use."""
-    try:
-        row = db.query(NL43Status).filter_by(unit_id=s.unit_id).first()
-        if not row:
-            row = NL43Status(unit_id=s.unit_id)
-            db.add(row)
-
-        row.last_seen = datetime.utcnow()
-
-        # Track measurement start time by detecting state transition
-        previous_state = row.measurement_state
-        new_state = s.measurement_state
-
-        logger.info(f"State transition check for {s.unit_id}: '{previous_state}' -> '{new_state}'")
-
-        # Device returns "Start" when measuring, "Stop" when stopped
-        # Normalize to previous behavior for backward compatibility
-        is_measuring = new_state == "Start"
-        was_measuring = previous_state == "Start"
-
-        if not was_measuring and is_measuring:
-            # Measurement just started - record the start time
-            row.measurement_start_time = datetime.utcnow()
-            logger.info(f"✓ Measurement started on {s.unit_id} at {row.measurement_start_time}")
-        elif was_measuring and not is_measuring:
-            # Measurement stopped - clear the start time
-            row.measurement_start_time = None
-            logger.info(f"✓ Measurement stopped on {s.unit_id}")
-
-        row.measurement_state = new_state
-        row.counter = s.counter
-        row.lp = s.lp
-        row.leq = s.leq
-        row.lmax = s.lmax
-        row.lmin = s.lmin
-        row.lpeak = s.lpeak
-        row.battery_level = s.battery_level
-        row.power_source = s.power_source
-        row.sd_remaining_mb = s.sd_remaining_mb
-        row.sd_free_ratio = s.sd_free_ratio
-        row.raw_payload = s.raw_payload
-
-        db.commit()
-    except Exception as e:
-        db.rollback()
-        logger.error(f"Failed to persist snapshot for unit {s.unit_id}: {e}")
-        raise
-
-
-# Rate limiting: NL43 requires ≥1 second between commands
-_last_command_time = {}
-_rate_limit_lock = asyncio.Lock()
-
-
-class NL43Client:
-    def __init__(self, host: str, port: int, timeout: float = 5.0, ftp_username: str = None, ftp_password: str = None):
-        self.host = host
-        self.port = port
-        self.timeout = timeout
-        self.ftp_username = ftp_username or "anonymous"
-        self.ftp_password = ftp_password or ""
-        self.device_key = f"{host}:{port}"
-
-    async def _enforce_rate_limit(self):
-        """Ensure ≥1 second between commands to the same device."""
-        async with _rate_limit_lock:
-            last_time = _last_command_time.get(self.device_key, 0)
-            elapsed = time.time() - last_time
-            if elapsed < 1.0:
-                wait_time = 1.0 - elapsed
-                logger.debug(f"Rate limiting: waiting {wait_time:.2f}s for {self.device_key}")
-                await asyncio.sleep(wait_time)
-            _last_command_time[self.device_key] = time.time()
-
-    async def _send_command(self, cmd: str) -> str:
-        """Send ASCII command to NL43 device via TCP.
-
-        NL43 protocol returns two lines for query commands:
-        Line 1: Result code (R+0000 for success, error codes otherwise)
-        Line 2: Actual data (for query commands ending with '?')
-        """
-        await self._enforce_rate_limit()
-
-        logger.info(f"Sending command to {self.device_key}: {cmd.strip()}")
-
-        try:
-            reader, writer = await asyncio.wait_for(
-                asyncio.open_connection(self.host, self.port), timeout=self.timeout
-            )
-        except asyncio.TimeoutError:
-            logger.error(f"Connection timeout to {self.device_key}")
-            raise ConnectionError(f"Failed to connect to device at {self.host}:{self.port}")
-        except Exception as e:
-            logger.error(f"Connection failed to {self.device_key}: {e}")
-            raise ConnectionError(f"Failed to connect to device: {str(e)}")
-
-        try:
-            writer.write(cmd.encode("ascii"))
-            await writer.drain()
-
-            # Read first line (result code)
-            first_line_data = await asyncio.wait_for(reader.readuntil(b"\n"), timeout=self.timeout)
-            result_code = first_line_data.decode(errors="ignore").strip()
-
-            # Remove leading $ prompt if present
-            if result_code.startswith("$"):
-                result_code = result_code[1:].strip()
-
-            logger.info(f"Result code from {self.device_key}: {result_code}")
-
-            # Check result code
-            if result_code == "R+0000":
-                # Success - for query commands, read the second line with actual data
-                is_query = cmd.strip().endswith("?")
-                if is_query:
-                    data_line = await asyncio.wait_for(reader.readuntil(b"\n"), timeout=self.timeout)
-                    response = data_line.decode(errors="ignore").strip()
-                    logger.debug(f"Data line from {self.device_key}: {response}")
-                    return response
-                else:
-                    # Setting command - return success code
-                    return result_code
-            elif result_code == "R+0001":
-                raise ValueError("Command error - device did not recognize command")
-            elif result_code == "R+0002":
-                raise ValueError("Parameter error - invalid parameter value")
-            elif result_code == "R+0003":
-                raise ValueError("Spec/type error - command not supported by this device model")
-            elif result_code == "R+0004":
-                raise ValueError("Status error - device is in wrong state for this command")
-            else:
-                raise ValueError(f"Unknown result code: {result_code}")
-
-        except asyncio.TimeoutError:
-            logger.error(f"Response timeout from {self.device_key}")
-            raise TimeoutError(f"Device did not respond within {self.timeout}s")
-        except Exception as e:
-            logger.error(f"Communication error with {self.device_key}: {e}")
-            raise
-        finally:
-            writer.close()
-            with contextlib.suppress(Exception):
-                await writer.wait_closed()
-
-    async def request_dod(self) -> NL43Snapshot:
-        """Request DOD (Data Output Display) snapshot from device.
-
-        Returns parsed measurement data from the device display.
-        """
-        # _send_command now handles result code validation and returns the data line
-        resp = await self._send_command("DOD?\r\n")
-
-        # Validate response format
-        if not resp:
-            logger.warning(f"Empty data response from DOD command on {self.device_key}")
-            raise ValueError("Device returned empty data for DOD? command")
-
-        # Remove leading $ prompt if present (shouldn't be there after _send_command, but be safe)
-        if resp.startswith("$"):
-            resp = resp[1:].strip()
-
-        parts = [p.strip() for p in resp.split(",") if p.strip() != ""]
-
-        # DOD should return at least some data points
-        if len(parts) < 2:
-            logger.error(f"Malformed DOD data from {self.device_key}: {resp}")
-            raise ValueError(f"Malformed DOD data: expected comma-separated values, got: {resp}")
-
-        logger.info(f"Parsed {len(parts)} data points from DOD response")
-
-        # Query actual measurement state (DOD doesn't include this information)
-        try:
-            measurement_state = await self.get_measurement_state()
-        except Exception as e:
-            logger.warning(f"Failed to get measurement state, defaulting to 'Measure': {e}")
-            measurement_state = "Measure"
-
-        snap = NL43Snapshot(unit_id="", raw_payload=resp, measurement_state=measurement_state)
-
-        # Parse known positions (based on NL43 communication guide - DRD format)
-        # DRD format: d0=counter, d1=Lp, d2=Leq, d3=Lmax, d4=Lmin, d5=Lpeak, d6=LIeq, ...
-        try:
-            # Capture d0 (counter) for timer synchronization
-            if len(parts) >= 1:
-                snap.counter = parts[0]  # d0: Measurement interval counter (1-600)
-            if len(parts) >= 2:
-                snap.lp = parts[1]     # d1: Instantaneous sound pressure level
-            if len(parts) >= 3:
-                snap.leq = parts[2]    # d2: Equivalent continuous sound level
-            if len(parts) >= 4:
-                snap.lmax = parts[3]   # d3: Maximum level
-            if len(parts) >= 5:
-                snap.lmin = parts[4]   # d4: Minimum level
-            if len(parts) >= 6:
-                snap.lpeak = parts[5]  # d5: Peak level
-        except (IndexError, ValueError) as e:
-            logger.warning(f"Error parsing DOD data points: {e}")
-
-        return snap
-
-    async def start(self):
-        """Start measurement on the device.
-
-        According to NL43 protocol: Measure,Start (no $ prefix, capitalized param)
-        """
-        await self._send_command("Measure,Start\r\n")
-
-    async def stop(self):
-        """Stop measurement on the device.
-
-        According to NL43 protocol: Measure,Stop (no $ prefix, capitalized param)
-        """
-        await self._send_command("Measure,Stop\r\n")
-
-    async def set_store_mode_manual(self):
-        """Set the device to Manual Store mode.
-
-        According to NL43 protocol: Store Mode,Manual sets manual storage mode
-        """
-        await self._send_command("Store Mode,Manual\r\n")
-        logger.info(f"Store mode set to Manual on {self.device_key}")
-
-    async def manual_store(self):
-        """Manually store the current measurement data.
-
-        According to NL43 protocol: Manual Store,Start executes storing
-        Parameter p1="Start" executes the storage operation
-        Device must be in Manual Store mode first
-        """
-        await self._send_command("Manual Store,Start\r\n")
-        logger.info(f"Manual store executed on {self.device_key}")
-
-    async def pause(self):
-        """Pause the current measurement."""
-        await self._send_command("Pause,On\r\n")
-        logger.info(f"Measurement paused on {self.device_key}")
-
-    async def resume(self):
-        """Resume a paused measurement."""
-        await self._send_command("Pause,Off\r\n")
-        logger.info(f"Measurement resumed on {self.device_key}")
-
-    async def reset(self):
-        """Reset the measurement data."""
-        await self._send_command("Reset\r\n")
-        logger.info(f"Measurement data reset on {self.device_key}")
-
-    async def get_measurement_state(self) -> str:
-        """Get the current measurement state.
-
-        Returns: "Start" if measuring, "Stop" if stopped
-        """
-        resp = await self._send_command("Measure?\r\n")
-        state = resp.strip()
-        logger.info(f"Measurement state on {self.device_key}: {state}")
-        return state
-
-    async def get_battery_level(self) -> str:
-        """Get the battery level."""
-        resp = await self._send_command("Battery Level?\r\n")
-        logger.info(f"Battery level on {self.device_key}: {resp}")
-        return resp.strip()
-
-    async def get_clock(self) -> str:
-        """Get the device clock time."""
-        resp = await self._send_command("Clock?\r\n")
-        logger.info(f"Clock on {self.device_key}: {resp}")
-        return resp.strip()
-
-    async def set_clock(self, datetime_str: str):
-        """Set the device clock time.
-
-        Args:
-            datetime_str: Time in format YYYY/MM/DD,HH:MM:SS or YYYY/MM/DD HH:MM:SS
-        """
-        # Device expects format: Clock,YYYY/MM/DD HH:MM:SS (space between date and time)
-        # Replace comma with space if present to normalize format
-        normalized = datetime_str.replace(',', ' ', 1)
-        await self._send_command(f"Clock,{normalized}\r\n")
-        logger.info(f"Clock set on {self.device_key} to {normalized}")
-
-    async def get_frequency_weighting(self, channel: str = "Main") -> str:
-        """Get frequency weighting (A, C, Z, etc.).
-
-        Args:
-            channel: Main, Sub1, Sub2, or Sub3
-        """
-        resp = await self._send_command(f"Frequency Weighting ({channel})?\r\n")
-        logger.info(f"Frequency weighting ({channel}) on {self.device_key}: {resp}")
-        return resp.strip()
-
-    async def set_frequency_weighting(self, weighting: str, channel: str = "Main"):
-        """Set frequency weighting.
-
-        Args:
-            weighting: A, C, or Z
-            channel: Main, Sub1, Sub2, or Sub3
-        """
-        await self._send_command(f"Frequency Weighting ({channel}),{weighting}\r\n")
-        logger.info(f"Frequency weighting ({channel}) set to {weighting} on {self.device_key}")
-
-    async def get_time_weighting(self, channel: str = "Main") -> str:
-        """Get time weighting (F, S, I).
-
-        Args:
-            channel: Main, Sub1, Sub2, or Sub3
-        """
-        resp = await self._send_command(f"Time Weighting ({channel})?\r\n")
-        logger.info(f"Time weighting ({channel}) on {self.device_key}: {resp}")
-        return resp.strip()
-
-    async def set_time_weighting(self, weighting: str, channel: str = "Main"):
-        """Set time weighting.
-
-        Args:
-            weighting: F (Fast), S (Slow), or I (Impulse)
-            channel: Main, Sub1, Sub2, or Sub3
-        """
-        await self._send_command(f"Time Weighting ({channel}),{weighting}\r\n")
-        logger.info(f"Time weighting ({channel}) set to {weighting} on {self.device_key}")
-
-    async def request_dlc(self) -> dict:
-        """Request DLC (Data Last Calculation) - final stored measurement results.
-
-        This retrieves the complete calculation results from the last/current measurement,
-        including all statistical data. Similar to DOD but for final results.
-
-        Returns:
-            Dict with parsed DLC data
-        """
-        resp = await self._send_command("DLC?\r\n")
-        logger.info(f"DLC data received from {self.device_key}: {resp[:100]}...")
-
-        # Parse DLC response - similar format to DOD
-        # The exact format depends on device configuration
-        # For now, return raw data - can be enhanced based on actual response format
-        return {
-            "raw_data": resp.strip(),
-            "device_key": self.device_key,
-        }
-
-    async def sleep(self):
-        """Put the device into sleep mode to conserve battery.
-
-        Sleep mode is useful for battery conservation between scheduled measurements.
-        Device can be woken up remotely via TCP command or by pressing a button.
-        """
-        await self._send_command("Sleep Mode,On\r\n")
-        logger.info(f"Device {self.device_key} entering sleep mode")
-
-    async def wake(self):
-        """Wake the device from sleep mode.
-
-        Note: This may not work if the device is in deep sleep.
-        Physical button press might be required in some cases.
-        """
-        await self._send_command("Sleep Mode,Off\r\n")
-        logger.info(f"Device {self.device_key} waking from sleep mode")
-
-    async def get_sleep_status(self) -> str:
-        """Get the current sleep mode status."""
-        resp = await self._send_command("Sleep Mode?\r\n")
-        logger.info(f"Sleep mode status on {self.device_key}: {resp}")
-        return resp.strip()
-
-    async def stream_drd(self, callback):
-        """Stream continuous DRD output from the device.
-
-        Opens a persistent connection and streams DRD data lines.
-        Calls the provided callback function with each parsed snapshot.
-
-        Args:
-            callback: Async function that receives NL43Snapshot objects
-
-        The stream continues until an exception occurs or the connection is closed.
-        Send SUB character (0x1A) to stop the stream.
-        """
-        await self._enforce_rate_limit()
-
-        logger.info(f"Starting DRD stream for {self.device_key}")
-
-        try:
-            reader, writer = await asyncio.wait_for(
-                asyncio.open_connection(self.host, self.port), timeout=self.timeout
-            )
-        except asyncio.TimeoutError:
-            logger.error(f"DRD stream connection timeout to {self.device_key}")
-            raise ConnectionError(f"Failed to connect to device at {self.host}:{self.port}")
-        except Exception as e:
-            logger.error(f"DRD stream connection failed to {self.device_key}: {e}")
-            raise ConnectionError(f"Failed to connect to device: {str(e)}")
-
-        try:
-            # Start DRD streaming
-            writer.write(b"DRD?\r\n")
-            await writer.drain()
-
-            # Read initial result code
-            first_line_data = await asyncio.wait_for(reader.readuntil(b"\n"), timeout=self.timeout)
-            result_code = first_line_data.decode(errors="ignore").strip()
-
-            if result_code.startswith("$"):
-                result_code = result_code[1:].strip()
-
-            logger.debug(f"DRD stream result code from {self.device_key}: {result_code}")
-
-            if result_code != "R+0000":
-                raise ValueError(f"DRD stream failed to start: {result_code}")
-
-            logger.info(f"DRD stream started successfully for {self.device_key}")
-
-            # Continuously read data lines
-            while True:
-                try:
-                    line_data = await asyncio.wait_for(reader.readuntil(b"\n"), timeout=30.0)
-                    line = line_data.decode(errors="ignore").strip()
-
-                    if not line:
-                        continue
-
-                    # Remove leading $ if present
-                    if line.startswith("$"):
-                        line = line[1:].strip()
-
-                    # Parse the DRD data (same format as DOD)
-                    parts = [p.strip() for p in line.split(",") if p.strip() != ""]
-
-                    if len(parts) < 2:
-                        logger.warning(f"Malformed DRD data from {self.device_key}: {line}")
-                        continue
-
-                    snap = NL43Snapshot(unit_id="", raw_payload=line, measurement_state="Measure")
-
-                    # Parse known positions (DRD format - same as DOD)
-                    # DRD format: d0=counter, d1=Lp, d2=Leq, d3=Lmax, d4=Lmin, d5=Lpeak, d6=LIeq, ...
-                    try:
-                        # Capture d0 (counter) for timer synchronization
-                        if len(parts) >= 1:
-                            snap.counter = parts[0]  # d0: Measurement interval counter (1-600)
-                        if len(parts) >= 2:
-                            snap.lp = parts[1]     # d1: Instantaneous sound pressure level
-                        if len(parts) >= 3:
-                            snap.leq = parts[2]    # d2: Equivalent continuous sound level
-                        if len(parts) >= 4:
-                            snap.lmax = parts[3]   # d3: Maximum level
-                        if len(parts) >= 5:
-                            snap.lmin = parts[4]   # d4: Minimum level
-                        if len(parts) >= 6:
-                            snap.lpeak = parts[5]  # d5: Peak level
-                    except (IndexError, ValueError) as e:
-                        logger.warning(f"Error parsing DRD data points: {e}")
-
-                    # Call the callback with the snapshot
-                    await callback(snap)
-
-                except asyncio.TimeoutError:
-                    logger.warning(f"DRD stream timeout (no data for 30s) from {self.device_key}")
-                    break
-                except asyncio.IncompleteReadError:
-                    logger.info(f"DRD stream closed by device {self.device_key}")
-                    break
-
-        finally:
-            # Send SUB character to stop streaming
-            try:
-                writer.write(b"\x1A")
-                await writer.drain()
-            except Exception:
-                pass
-
-            writer.close()
-            with contextlib.suppress(Exception):
-                await writer.wait_closed()
-
-            logger.info(f"DRD stream ended for {self.device_key}")
-
-    async def set_measurement_time(self, preset: str):
-        """Set measurement time preset.
-
-        Args:
-            preset: Time preset (10s, 1m, 5m, 10m, 15m, 30m, 1h, 8h, 24h, or custom like "00:05:30")
-        """
-        await self._send_command(f"Measurement Time Preset Manual,{preset}\r\n")
-        logger.info(f"Set measurement time to {preset} on {self.device_key}")
-
-    async def get_measurement_time(self) -> str:
-        """Get current measurement time preset.
-
-        Returns: Current time preset setting
-        """
-        resp = await self._send_command("Measurement Time Preset Manual?\r\n")
-        return resp.strip()
-
-    async def set_leq_interval(self, preset: str):
-        """Set Leq calculation interval preset.
-
-        Args:
-            preset: Interval preset (Off, 10s, 1m, 5m, 10m, 15m, 30m, 1h, 8h, 24h, or custom like "00:05:30")
-        """
-        await self._send_command(f"Leq Calculation Interval Preset,{preset}\r\n")
-        logger.info(f"Set Leq interval to {preset} on {self.device_key}")
-
-    async def get_leq_interval(self) -> str:
-        """Get current Leq calculation interval preset.
-
-        Returns: Current interval preset setting
-        """
-        resp = await self._send_command("Leq Calculation Interval Preset?\r\n")
-        return resp.strip()
-
-    async def set_lp_interval(self, preset: str):
-        """Set Lp store interval.
-
-        Args:
-            preset: Store interval (Off, 10ms, 25ms, 100ms, 200ms, 1s)
-        """
-        await self._send_command(f"Lp Store Interval,{preset}\r\n")
-        logger.info(f"Set Lp interval to {preset} on {self.device_key}")
-
-    async def get_lp_interval(self) -> str:
-        """Get current Lp store interval.
-
-        Returns: Current store interval setting
-        """
-        resp = await self._send_command("Lp Store Interval?\r\n")
-        return resp.strip()
-
-    async def set_index_number(self, index: int):
-        """Set index number for file numbering (Store Name).
-
-        Args:
-            index: Index number (0000-9999)
-        """
-        if not 0 <= index <= 9999:
-            raise ValueError("Index must be between 0000 and 9999")
-        await self._send_command(f"Store Name,{index:04d}\r\n")
-        logger.info(f"Set store name (index) to {index:04d} on {self.device_key}")
-
-    async def get_index_number(self) -> str:
-        """Get current index number (Store Name).
-
-        Returns: Current index number
-        """
-        resp = await self._send_command("Store Name?\r\n")
-        return resp.strip()
-
-    async def get_overwrite_status(self) -> str:
-        """Check if saved data exists at current store target.
-
-        This command checks whether saved data exists in the set store target
-        (store mode / store name / store address). Use this before storing
-        to prevent accidentally overwriting data.
-
-        Returns:
-            "None" - No data exists (safe to store)
-            "Exist" - Data exists (would overwrite)
-        """
-        resp = await self._send_command("Overwrite?\r\n")
-        return resp.strip()
-
-    async def get_all_settings(self) -> dict:
-        """Query all device settings for verification.
-
-        Returns: Dictionary with all current device settings
-        """
-        settings = {}
-
-        # Measurement settings
-        try:
-            settings["measurement_state"] = await self.get_measurement_state()
-        except Exception as e:
-            settings["measurement_state"] = f"Error: {e}"
-
-        try:
-            settings["frequency_weighting"] = await self.get_frequency_weighting()
-        except Exception as e:
-            settings["frequency_weighting"] = f"Error: {e}"
-
-        try:
-            settings["time_weighting"] = await self.get_time_weighting()
-        except Exception as e:
-            settings["time_weighting"] = f"Error: {e}"
-
-        # Timing/interval settings
-        try:
-            settings["measurement_time"] = await self.get_measurement_time()
-        except Exception as e:
-            settings["measurement_time"] = f"Error: {e}"
-
-        try:
-            settings["leq_interval"] = await self.get_leq_interval()
-        except Exception as e:
-            settings["leq_interval"] = f"Error: {e}"
-
-        try:
-            settings["lp_interval"] = await self.get_lp_interval()
-        except Exception as e:
-            settings["lp_interval"] = f"Error: {e}"
-
-        try:
-            settings["index_number"] = await self.get_index_number()
-        except Exception as e:
-            settings["index_number"] = f"Error: {e}"
-
-        # Device info
-        try:
-            settings["battery_level"] = await self.get_battery_level()
-        except Exception as e:
-            settings["battery_level"] = f"Error: {e}"
-
-        try:
-            settings["clock"] = await self.get_clock()
-        except Exception as e:
-            settings["clock"] = f"Error: {e}"
-
-        # Sleep mode
-        try:
-            settings["sleep_mode"] = await self.get_sleep_status()
-        except Exception as e:
-            settings["sleep_mode"] = f"Error: {e}"
-
-        # FTP status
-        try:
-            settings["ftp_status"] = await self.get_ftp_status()
-        except Exception as e:
-            settings["ftp_status"] = f"Error: {e}"
-
-        logger.info(f"Retrieved all settings for {self.device_key}")
-        return settings
-
-    async def enable_ftp(self):
-        """Enable FTP server on the device.
-
-        According to NL43 protocol: FTP,On enables the FTP server
-        """
-        await self._send_command("FTP,On\r\n")
-        logger.info(f"FTP enabled on {self.device_key}")
-
-    async def disable_ftp(self):
-        """Disable FTP server on the device.
-
-        According to NL43 protocol: FTP,Off disables the FTP server
-        """
-        await self._send_command("FTP,Off\r\n")
-        logger.info(f"FTP disabled on {self.device_key}")
-
-    async def get_ftp_status(self) -> str:
-        """Query FTP server status on the device.
-
-        Returns: "On" or "Off"
-        """
-        resp = await self._send_command("FTP?\r\n")
-        logger.info(f"FTP status on {self.device_key}: {resp}")
-        return resp.strip()
-
-    async def list_ftp_files(self, remote_path: str = "/") -> List[dict]:
-        """List files on the device via FTP.
-
-        Args:
-            remote_path: Directory path on the device (default: root)
-
-        Returns:
-            List of file info dicts with 'name', 'size', 'modified', 'is_dir'
-        """
-        logger.info(f"Listing FTP files on {self.device_key} at {remote_path}")
-
-        def _list_ftp_sync():
-            """Synchronous FTP listing using ftplib (supports active mode)."""
-            ftp = FTP()
-            ftp.set_debuglevel(0)
-            try:
-                # Connect and login
-                ftp.connect(self.host, 21, timeout=10)
-                ftp.login(self.ftp_username, self.ftp_password)
-                ftp.set_pasv(False)  # Force active mode
-
-                # Change to target directory
-                if remote_path != "/":
-                    ftp.cwd(remote_path)
-
-                # Get directory listing with details
-                files = []
-                lines = []
-                ftp.retrlines('LIST', lines.append)
-
-                for line in lines:
-                    # Parse Unix-style ls output
-                    parts = line.split(None, 8)
-                    if len(parts) < 9:
-                        continue
-
-                    is_dir = parts[0].startswith('d')
-                    size = int(parts[4]) if not is_dir else 0
-                    name = parts[8]
-
-                    # Skip . and ..
-                    if name in ('.', '..'):
-                        continue
-
-                    # Parse modification time
-                    # Format: "Jan 07 14:23" or "Dec 25 2025"
-                    modified_str = f"{parts[5]} {parts[6]} {parts[7]}"
-                    modified_timestamp = None
-                    try:
-                        from datetime import datetime
-                        # Try parsing with time (recent files: "Jan 07 14:23")
-                        try:
-                            dt = datetime.strptime(modified_str, "%b %d %H:%M")
-                            # Add current year since it's not in the format
-                            dt = dt.replace(year=datetime.now().year)
-
-                            # If the resulting date is in the future, it's actually from last year
-                            if dt > datetime.now():
-                                dt = dt.replace(year=dt.year - 1)
-
-                            modified_timestamp = dt.isoformat()
-                        except ValueError:
-                            # Try parsing with year (older files: "Dec 25 2025")
-                            dt = datetime.strptime(modified_str, "%b %d %Y")
-                            modified_timestamp = dt.isoformat()
-                    except Exception as e:
-                        logger.warning(f"Failed to parse timestamp '{modified_str}': {e}")
-
-                    file_info = {
-                        "name": name,
-                        "path": f"{remote_path.rstrip('/')}/{name}",
-                        "size": size,
-                        "modified": modified_str,  # Keep original string
-                        "modified_timestamp": modified_timestamp,  # Add parsed timestamp
-                        "is_dir": is_dir,
-                    }
-                    files.append(file_info)
-                    logger.debug(f"Found file: {file_info}")
-
-                logger.info(f"Found {len(files)} files/directories on {self.device_key}")
-                return files
-
-            finally:
-                try:
-                    ftp.quit()
-                except:
-                    pass
-
-        try:
-            # Run synchronous FTP in thread pool
-            return await asyncio.to_thread(_list_ftp_sync)
-        except Exception as e:
-            logger.error(f"Failed to list FTP files on {self.device_key}: {e}")
-            raise ConnectionError(f"FTP connection failed: {str(e)}")
-
-    async def download_ftp_file(self, remote_path: str, local_path: str):
-        """Download a file from the device via FTP.
-
-        Args:
-            remote_path: Full path to file on the device
-            local_path: Local path where file will be saved
-        """
-        logger.info(f"Downloading {remote_path} from {self.device_key} to {local_path}")
-
-        def _download_ftp_sync():
-            """Synchronous FTP download using ftplib (supports active mode)."""
-            ftp = FTP()
-            ftp.set_debuglevel(0)
-            try:
-                # Connect and login
-                ftp.connect(self.host, 21, timeout=10)
-                ftp.login(self.ftp_username, self.ftp_password)
-                ftp.set_pasv(False)  # Force active mode
-
-                # Download file
-                with open(local_path, 'wb') as f:
-                    ftp.retrbinary(f'RETR {remote_path}', f.write)
-
-                logger.info(f"Successfully downloaded {remote_path} to {local_path}")
-
-            finally:
-                try:
-                    ftp.quit()
-                except:
-                    pass
-
-        try:
-            # Run synchronous FTP in thread pool
-            await asyncio.to_thread(_download_ftp_sync)
-        except Exception as e:
-            logger.error(f"Failed to download {remote_path} from {self.device_key}: {e}")
-            raise ConnectionError(f"FTP download failed: {str(e)}")

app/ui/routes.py

@@ -1,92 +0,0 @@
-"""
-UI Layer Routes - HTML page routes only (no business logic)
-"""
-from fastapi import APIRouter, Request
-from fastapi.responses import HTMLResponse, FileResponse
-from fastapi.templating import Jinja2Templates
-import os
-
-router = APIRouter()
-
-# Setup Jinja2 templates
-templates = Jinja2Templates(directory="app/ui/templates")
-
-# Read environment (development or production)
-ENVIRONMENT = os.getenv("ENVIRONMENT", "production")
-VERSION = "1.0.0"  # Terra-View version
-
-# Override TemplateResponse to include environment and version in context
-original_template_response = templates.TemplateResponse
-def custom_template_response(name, context=None, *args, **kwargs):
-    if context is None:
-        context = {}
-    context["environment"] = ENVIRONMENT
-    context["version"] = VERSION
-    return original_template_response(name, context, *args, **kwargs)
-templates.TemplateResponse = custom_template_response
-
-
-# ===== HTML PAGE ROUTES =====
-
-@router.get("/", response_class=HTMLResponse)
-async def dashboard(request: Request):
-    """Dashboard home page"""
-    return templates.TemplateResponse("dashboard.html", {"request": request})
-
-
-@router.get("/roster", response_class=HTMLResponse)
-async def roster_page(request: Request):
-    """Fleet roster page"""
-    return templates.TemplateResponse("roster.html", {"request": request})
-
-
-@router.get("/unit/{unit_id}", response_class=HTMLResponse)
-async def unit_detail_page(request: Request, unit_id: str):
-    """Unit detail page"""
-    return templates.TemplateResponse("unit_detail.html", {
-        "request": request,
-        "unit_id": unit_id
-    })
-
-
-@router.get("/settings", response_class=HTMLResponse)
-async def settings_page(request: Request):
-    """Settings page for roster management"""
-    return templates.TemplateResponse("settings.html", {"request": request})
-
-
-@router.get("/sound-level-meters", response_class=HTMLResponse)
-async def sound_level_meters_page(request: Request):
-    """Sound Level Meters management dashboard"""
-    return templates.TemplateResponse("sound_level_meters.html", {"request": request})
-
-
-@router.get("/seismographs", response_class=HTMLResponse)
-async def seismographs_page(request: Request):
-    """Seismographs management dashboard"""
-    return templates.TemplateResponse("seismographs.html", {"request": request})
-
-
-# ===== PWA ROUTES =====
-
-@router.get("/sw.js")
-async def service_worker():
-    """Serve service worker with proper headers for PWA"""
-    return FileResponse(
-        "app/ui/static/sw.js",
-        media_type="application/javascript",
-        headers={
-            "Service-Worker-Allowed": "/",
-            "Cache-Control": "no-cache"
-        }
-    )
-
-
-@router.get("/offline-db.js")
-async def offline_db_script():
-    """Serve offline database script"""
-    return FileResponse(
-        "app/ui/static/offline-db.js",
-        media_type="application/javascript",
-        headers={"Cache-Control": "no-cache"}
-    )

app/ui/templates/partials/seismo_unit_list.html

@@ -1,97 +0,0 @@
-{% if units %}
-<div class="overflow-x-auto">
-    <table class="w-full">
-        <thead class="bg-gray-50 dark:bg-slate-700 border-b border-gray-200 dark:border-gray-600">
-            <tr>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-700 dark:text-gray-300 uppercase tracking-wider">Unit ID</th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-700 dark:text-gray-300 uppercase tracking-wider">Status</th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-700 dark:text-gray-300 uppercase tracking-wider">Modem</th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-700 dark:text-gray-300 uppercase tracking-wider">Location</th>
-                <th class="px-4 py-3 text-left text-xs font-medium text-gray-700 dark:text-gray-300 uppercase tracking-wider">Notes</th>
-                <th class="px-4 py-3 text-right text-xs font-medium text-gray-700 dark:text-gray-300 uppercase tracking-wider">Actions</th>
-            </tr>
-        </thead>
-        <tbody class="divide-y divide-gray-200 dark:divide-gray-700">
-            {% for unit in units %}
-            <tr class="hover:bg-gray-50 dark:hover:bg-slate-700 transition-colors">
-                <td class="px-4 py-3 whitespace-nowrap">
-                    <a href="/unit/{{ unit.id }}" class="font-medium text-blue-600 dark:text-blue-400 hover:underline">
-                        {{ unit.id }}
-                    </a>
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap">
-                    {% if unit.deployed %}
-                    <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200">
-                        <svg class="w-3 h-3 mr-1" fill="currentColor" viewBox="0 0 20 20">
-                            <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd"></path>
-                        </svg>
-                        Deployed
-                    </span>
-                    {% else %}
-                    <span class="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-300">
-                        <svg class="w-3 h-3 mr-1" fill="currentColor" viewBox="0 0 20 20">
-                            <path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8 7a1 1 0 00-1 1v4a1 1 0 001 1h4a1 1 0 001-1V8a1 1 0 00-1-1H8z" clip-rule="evenodd"></path>
-                        </svg>
-                        Benched
-                    </span>
-                    {% endif %}
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap text-sm text-gray-900 dark:text-gray-300">
-                    {% if unit.deployed_with_modem_id %}
-                    <a href="/unit/{{ unit.deployed_with_modem_id }}" class="text-blue-600 dark:text-blue-400 hover:underline">
-                        {{ unit.deployed_with_modem_id }}
-                    </a>
-                    {% else %}
-                    <span class="text-gray-400 dark:text-gray-600">None</span>
-                    {% endif %}
-                </td>
-                <td class="px-4 py-3 text-sm text-gray-900 dark:text-gray-300">
-                    {% if unit.address %}
-                    <span class="truncate max-w-xs inline-block" title="{{ unit.address }}">{{ unit.address }}</span>
-                    {% elif unit.coordinates %}
-                    <span class="text-gray-500 dark:text-gray-400">{{ unit.coordinates }}</span>
-                    {% else %}
-                    <span class="text-gray-400 dark:text-gray-600">—</span>
-                    {% endif %}
-                </td>
-                <td class="px-4 py-3 text-sm text-gray-700 dark:text-gray-400">
-                    {% if unit.note %}
-                    <span class="truncate max-w-xs inline-block" title="{{ unit.note }}">{{ unit.note }}</span>
-                    {% else %}
-                    <span class="text-gray-400 dark:text-gray-600">—</span>
-                    {% endif %}
-                </td>
-                <td class="px-4 py-3 whitespace-nowrap text-right text-sm">
-                    <a href="/unit/{{ unit.id }}" class="text-blue-600 dark:text-blue-400 hover:underline">
-                        View Details →
-                    </a>
-                </td>
-            </tr>
-            {% endfor %}
-        </tbody>
-    </table>
-</div>
-
-{% if search %}
-<div class="mt-4 text-sm text-gray-600 dark:text-gray-400">
-    Found {{ units|length }} seismograph(s) matching "{{ search }}"
-</div>
-{% endif %}
-
-{% else %}
-<div class="text-center py-12">
-    <svg class="mx-auto h-12 w-12 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z"></path>
-    </svg>
-    <h3 class="mt-2 text-sm font-medium text-gray-900 dark:text-white">No seismographs found</h3>
-    {% if search %}
-    <p class="mt-1 text-sm text-gray-500 dark:text-gray-400">No seismographs match "{{ search }}"</p>
-    <button onclick="document.getElementById('seismo-search').value = ''; htmx.trigger('#seismo-search', 'keyup');"
-            class="mt-3 text-blue-600 dark:text-blue-400 hover:underline">
-        Clear search
-    </button>
-    {% else %}
-    <p class="mt-1 text-sm text-gray-500 dark:text-gray-400">Get started by adding a seismograph unit from the roster page.</p>
-    {% endif %}
-</div>
-{% endif %}

app/ui/templates/seismographs.html

@@ -1,76 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Seismographs - Seismo Fleet Manager{% endblock %}
-
-{% block content %}
-<div class="mb-8">
-    <h1 class="text-3xl font-bold text-gray-900 dark:text-white">Seismographs</h1>
-    <p class="text-gray-600 dark:text-gray-400 mt-1">Manage and monitor seismograph units</p>
-</div>
-
-<!-- Auto-refresh stats every 30 seconds -->
-<div hx-get="/api/seismo-dashboard/stats"
-     hx-trigger="load, every 30s"
-     hx-swap="innerHTML"
-     class="mb-8">
-    <div class="grid grid-cols-1 md:grid-cols-4 gap-4">
-        <div class="rounded-lg shadow bg-white dark:bg-slate-800 p-6">
-            <div class="flex items-center justify-between">
-                <div>
-                    <p class="text-gray-600 dark:text-gray-400 text-sm">Loading...</p>
-                    <p class="text-3xl font-bold text-gray-900 dark:text-white mt-2">--</p>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Seismograph List -->
-<div class="rounded-xl shadow-lg bg-white dark:bg-slate-800 p-6">
-    <div class="mb-4 flex flex-col sm:flex-row sm:items-center sm:justify-between gap-4">
-        <h2 class="text-xl font-semibold text-gray-900 dark:text-white">All Seismographs</h2>
-
-        <!-- Search Box -->
-        <div class="relative">
-            <input
-                type="text"
-                id="seismo-search"
-                placeholder="Search seismographs..."
-                class="w-full sm:w-64 px-4 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-slate-700 text-gray-900 dark:text-white focus:ring-2 focus:ring-blue-500 focus:border-transparent"
-                hx-get="/api/seismo-dashboard/units"
-                hx-trigger="keyup changed delay:300ms"
-                hx-target="#seismo-units-list"
-                hx-include="[name='search']"
-                name="search"
-            />
-            <svg class="absolute right-3 top-2.5 w-5 h-5 text-gray-400" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z"></path>
-            </svg>
-        </div>
-    </div>
-
-    <!-- Units List (loaded via HTMX) -->
-    <div id="seismo-units-list"
-         hx-get="/api/seismo-dashboard/units"
-         hx-trigger="load"
-         hx-swap="innerHTML">
-        <p class="text-gray-500 dark:text-gray-400">Loading seismographs...</p>
-    </div>
-</div>
-
-<script>
-// Clear search input on escape key
-document.addEventListener('DOMContentLoaded', function() {
-    const searchInput = document.getElementById('seismo-search');
-    if (searchInput) {
-        searchInput.addEventListener('keydown', function(e) {
-            if (e.key === 'Escape') {
-                this.value = '';
-                htmx.trigger(this, 'keyup');
-            }
-        });
-    }
-});
-</script>
-
-{% endblock %}

app/ui/templates/slm_detail.html

@@ -1,195 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}{{ unit_id }} - Sound Level Meter{% endblock %}
-
-{% block content %}
-<div class="mb-6">
-    <a href="/roster" class="text-seismo-orange hover:text-seismo-orange-dark flex items-center">
-        <svg class="w-4 h-4 mr-1" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15 19l-7-7 7-7"></path>
-        </svg>
-        Back to Roster
-    </a>
-</div>
-
-<div class="mb-8">
-    <div class="flex justify-between items-start">
-        <div>
-            <h1 class="text-3xl font-bold text-gray-900 dark:text-white flex items-center">
-                <svg class="w-8 h-8 mr-3 text-seismo-orange" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
-                          d="M9 19V6l12-3v13M9 19c0 1.105-1.343 2-3 2s-3-.895-3-2 1.343-2 3-2 3 .895 3 2zm12-3c0 1.105-1.343 2-3 2s-3-.895-3-2 1.343-2 3-2 3 .895 3 2zM9 10l12-3">
-                    </path>
-                </svg>
-                {{ unit_id }}
-            </h1>
-            <p class="text-gray-600 dark:text-gray-400 mt-1">
-                {{ unit.slm_model or 'NL-43' }} Sound Level Meter
-            </p>
-        </div>
-        <div class="flex gap-2">
-            <span class="px-3 py-1 rounded-full text-sm font-medium
-                         {% if unit.deployed %}bg-blue-100 text-blue-800 dark:bg-blue-900 dark:text-blue-200
-                         {% else %}bg-gray-100 text-gray-800 dark:bg-gray-700 dark:text-gray-200{% endif %}">
-                {% if unit.deployed %}Deployed{% else %}Benched{% endif %}
-            </span>
-        </div>
-    </div>
-</div>
-
-<!-- Control Panel -->
-<div class="mb-8">
-    <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Control Panel</h2>
-    <div hx-get="/slm/partials/{{ unit_id }}/controls"
-         hx-trigger="load, every 5s"
-         hx-swap="innerHTML">
-        <div class="text-center py-8 text-gray-500">Loading controls...</div>
-    </div>
-</div>
-
-<!-- Real-time Data Stream -->
-<div class="mb-8">
-    <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Real-time Measurements</h2>
-    <div class="bg-white dark:bg-slate-800 rounded-xl shadow-lg p-6">
-        <div id="slm-stream-container">
-            <div class="text-center py-8">
-                <button onclick="startStream()"
-                        id="stream-start-btn"
-                        class="px-6 py-3 bg-seismo-orange text-white rounded-lg hover:bg-seismo-orange-dark transition-colors">
-                    Start Real-time Stream
-                </button>
-                <p class="text-sm text-gray-500 mt-2">Click to begin streaming live measurement data</p>
-            </div>
-            <div id="stream-data" class="hidden">
-                <div class="grid grid-cols-2 md:grid-cols-4 gap-4 mb-4">
-                    <div class="bg-gray-50 dark:bg-gray-900 rounded-lg p-4">
-                        <div class="text-sm text-gray-600 dark:text-gray-400 mb-1">Lp (Instant)</div>
-                        <div id="stream-lp" class="text-3xl font-bold text-gray-900 dark:text-white">--</div>
-                        <div class="text-xs text-gray-500">dB</div>
-                    </div>
-                    <div class="bg-gray-50 dark:bg-gray-900 rounded-lg p-4">
-                        <div class="text-sm text-gray-600 dark:text-gray-400 mb-1">Leq (Average)</div>
-                        <div id="stream-leq" class="text-3xl font-bold text-blue-600 dark:text-blue-400">--</div>
-                        <div class="text-xs text-gray-500">dB</div>
-                    </div>
-                    <div class="bg-gray-50 dark:bg-gray-900 rounded-lg p-4">
-                        <div class="text-sm text-gray-600 dark:text-gray-400 mb-1">Lmax</div>
-                        <div id="stream-lmax" class="text-3xl font-bold text-red-600 dark:text-red-400">--</div>
-                        <div class="text-xs text-gray-500">dB</div>
-                    </div>
-                    <div class="bg-gray-50 dark:bg-gray-900 rounded-lg p-4">
-                        <div class="text-sm text-gray-600 dark:text-gray-400 mb-1">Lmin</div>
-                        <div id="stream-lmin" class="text-3xl font-bold text-green-600 dark:text-green-400">--</div>
-                        <div class="text-xs text-gray-500">dB</div>
-                    </div>
-                </div>
-                <div class="flex justify-between items-center">
-                    <div class="text-xs text-gray-500">
-                        <span class="inline-block w-2 h-2 bg-green-500 rounded-full mr-2 animate-pulse"></span>
-                        Streaming
-                    </div>
-                    <button onclick="stopStream()"
-                            class="px-4 py-2 bg-red-600 text-white text-sm rounded-lg hover:bg-red-700 transition-colors">
-                        Stop Stream
-                    </button>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Device Information -->
-<div class="mb-8">
-    <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Device Information</h2>
-    <div class="bg-white dark:bg-slate-800 rounded-xl shadow-lg p-6">
-        <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
-            <div>
-                <div class="text-sm text-gray-600 dark:text-gray-400">Model</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.slm_model or 'NL-43' }}</div>
-            </div>
-            <div>
-                <div class="text-sm text-gray-600 dark:text-gray-400">Serial Number</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.slm_serial_number or 'N/A' }}</div>
-            </div>
-            <div>
-                <div class="text-sm text-gray-600 dark:text-gray-400">Host</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.slm_host or 'Not configured' }}</div>
-            </div>
-            <div>
-                <div class="text-sm text-gray-600 dark:text-gray-400">TCP Port</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.slm_tcp_port or 'N/A' }}</div>
-            </div>
-            <div>
-                <div class="text-sm text-gray-600 dark:text-gray-400">Frequency Weighting</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.slm_frequency_weighting or 'A' }}</div>
-            </div>
-            <div>
-                <div class="text-sm text-gray-600 dark:text-gray-400">Time Weighting</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.slm_time_weighting or 'F (Fast)' }}</div>
-            </div>
-            <div class="md:col-span-2">
-                <div class="text-sm text-gray-600 dark:text-gray-400">Location</div>
-                <div class="text-lg font-medium text-gray-900 dark:text-white">{{ unit.address or unit.location or 'Not specified' }}</div>
-            </div>
-            {% if unit.note %}
-            <div class="md:col-span-2">
-                <div class="text-sm text-gray-600 dark:text-gray-400">Notes</div>
-                <div class="text-gray-900 dark:text-white">{{ unit.note }}</div>
-            </div>
-            {% endif %}
-        </div>
-    </div>
-</div>
-
-<script>
-let ws = null;
-
-function startStream() {
-    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const wsUrl = `${protocol}//${window.location.host}/api/slmm/{{ unit_id }}/stream`;
-
-    ws = new WebSocket(wsUrl);
-
-    ws.onopen = () => {
-        document.getElementById('stream-start-btn').classList.add('hidden');
-        document.getElementById('stream-data').classList.remove('hidden');
-        console.log('WebSocket connected');
-    };
-
-    ws.onmessage = (event) => {
-        const data = JSON.parse(event.data);
-
-        if (data.error) {
-            console.error('Stream error:', data.error);
-            stopStream();
-            alert('Error: ' + data.error);
-            return;
-        }
-
-        // Update values
-        document.getElementById('stream-lp').textContent = data.lp || '--';
-        document.getElementById('stream-leq').textContent = data.leq || '--';
-        document.getElementById('stream-lmax').textContent = data.lmax || '--';
-        document.getElementById('stream-lmin').textContent = data.lmin || '--';
-    };
-
-    ws.onerror = (error) => {
-        console.error('WebSocket error:', error);
-        stopStream();
-    };
-
-    ws.onclose = () => {
-        console.log('WebSocket closed');
-    };
-}
-
-function stopStream() {
-    if (ws) {
-        ws.close();
-        ws = null;
-    }
-    document.getElementById('stream-start-btn').classList.remove('hidden');
-    document.getElementById('stream-data').classList.add('hidden');
-}
-</script>
-{% endblock %}

app/ui/templates/sound_level_meters.html

@@ -1,249 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Sound Level Meters - Seismo Fleet Manager{% endblock %}
-
-{% block content %}
-<div class="mb-8">
-    <h1 class="text-3xl font-bold text-gray-900 dark:text-white">Sound Level Meters</h1>
-    <p class="text-gray-600 dark:text-gray-400 mt-1">Monitor and manage sound level measurement devices</p>
-</div>
-
-<!-- Summary Stats -->
-<div class="grid grid-cols-1 md:grid-cols-4 gap-6 mb-8"
-     hx-get="/api/slm-dashboard/stats"
-     hx-trigger="load, every 10s"
-     hx-swap="innerHTML">
-    <!-- Stats will be loaded here -->
-    <div class="animate-pulse bg-gray-200 dark:bg-gray-700 h-24 rounded-xl"></div>
-    <div class="animate-pulse bg-gray-200 dark:bg-gray-700 h-24 rounded-xl"></div>
-    <div class="animate-pulse bg-gray-200 dark:bg-gray-700 h-24 rounded-xl"></div>
-    <div class="animate-pulse bg-gray-200 dark:bg-gray-700 h-24 rounded-xl"></div>
-</div>
-
-<!-- Main Content Grid -->
-<div class="grid grid-cols-1 lg:grid-cols-3 gap-6">
-    <!-- SLM List -->
-    <div class="lg:col-span-1">
-        <div class="bg-white dark:bg-slate-800 rounded-xl shadow-lg p-6">
-            <h2 class="text-xl font-semibold text-gray-900 dark:text-white mb-4">Active Units</h2>
-
-            <!-- Search/Filter -->
-            <div class="mb-4">
-                <input type="text"
-                       placeholder="Search units..."
-                       class="w-full px-4 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-700 text-gray-900 dark:text-white"
-                       hx-get="/api/slm-dashboard/units"
-                       hx-trigger="keyup changed delay:300ms"
-                       hx-target="#slm-list"
-                       hx-include="this"
-                       name="search">
-            </div>
-
-            <!-- SLM List -->
-            <div id="slm-list"
-                 class="space-y-2 max-h-[600px] overflow-y-auto"
-                 hx-get="/api/slm-dashboard/units"
-                 hx-trigger="load, every 10s"
-                 hx-swap="innerHTML">
-                <!-- Loading skeleton -->
-                <div class="animate-pulse space-y-2">
-                    <div class="bg-gray-200 dark:bg-gray-700 h-20 rounded-lg"></div>
-                    <div class="bg-gray-200 dark:bg-gray-700 h-20 rounded-lg"></div>
-                    <div class="bg-gray-200 dark:bg-gray-700 h-20 rounded-lg"></div>
-                </div>
-            </div>
-        </div>
-    </div>
-
-    <!-- Live View Panel -->
-    <div class="lg:col-span-2">
-        <div id="live-view-panel" class="bg-white dark:bg-slate-800 rounded-xl shadow-lg p-6">
-            <!-- Initial state - no unit selected -->
-            <div class="flex flex-col items-center justify-center h-[600px] text-gray-400 dark:text-gray-500">
-                <svg class="w-24 h-24 mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M15.536 8.464a5 5 0 010 7.072m2.828-9.9a9 9 0 010 12.728M5.586 15H4a1 1 0 01-1-1v-4a1 1 0 011-1h1.586l4.707-4.707C10.923 3.663 12 4.109 12 5v14c0 .891-1.077 1.337-1.707.707L5.586 15z"></path>
-                </svg>
-                <p class="text-lg font-medium">No unit selected</p>
-                <p class="text-sm mt-2">Select a sound level meter from the list to view live data</p>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- Configuration Modal -->
-<div id="config-modal" class="hidden fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
-    <div class="bg-white dark:bg-slate-800 rounded-xl p-6 max-w-2xl w-full mx-4 max-h-[90vh] overflow-y-auto">
-        <div class="flex items-center justify-between mb-6">
-            <h3 class="text-2xl font-bold text-gray-900 dark:text-white">Configure SLM</h3>
-            <button onclick="closeConfigModal()" class="text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-200">
-                <svg class="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M6 18L18 6M6 6l12 12"></path>
-                </svg>
-            </button>
-        </div>
-
-        <div id="config-modal-content">
-            <!-- Content loaded via HTMX -->
-            <div class="animate-pulse space-y-4">
-                <div class="h-4 bg-gray-200 dark:bg-gray-700 rounded w-3/4"></div>
-                <div class="h-4 bg-gray-200 dark:bg-gray-700 rounded"></div>
-                <div class="h-4 bg-gray-200 dark:bg-gray-700 rounded w-5/6"></div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<script>
-// Function to select a unit and load live view
-function selectUnit(unitId) {
-    // Remove active state from all items
-    document.querySelectorAll('.slm-unit-item').forEach(item => {
-        item.classList.remove('bg-seismo-orange', 'text-white');
-        item.classList.add('bg-gray-100', 'dark:bg-gray-700');
-    });
-
-    // Add active state to clicked item
-    event.currentTarget.classList.remove('bg-gray-100', 'dark:bg-gray-700');
-    event.currentTarget.classList.add('bg-seismo-orange', 'text-white');
-
-    // Load live view for this unit
-    htmx.ajax('GET', `/api/slm-dashboard/live-view/${unitId}`, {
-        target: '#live-view-panel',
-        swap: 'innerHTML'
-    });
-}
-
-// Configuration modal functions
-function openConfigModal(unitId) {
-    const modal = document.getElementById('config-modal');
-    modal.classList.remove('hidden');
-    
-    // Load configuration form via HTMX
-    htmx.ajax('GET', `/api/slm-dashboard/config/${unitId}`, {
-        target: '#config-modal-content',
-        swap: 'innerHTML'
-    });
-}
-
-function closeConfigModal() {
-    document.getElementById('config-modal').classList.add('hidden');
-}
-
-// Close modal on escape key
-document.addEventListener('keydown', function(e) {
-    if (e.key === 'Escape') {
-        closeConfigModal();
-    }
-});
-
-// Close modal when clicking outside
-document.getElementById('config-modal')?.addEventListener('click', function(e) {
-    if (e.target === this) {
-        closeConfigModal();
-    }
-});
-
-// Initialize WebSocket for selected unit
-let currentWebSocket = null;
-
-function initLiveDataStream(unitId) {
-    // Close existing connection if any
-    if (currentWebSocket) {
-        currentWebSocket.close();
-    }
-
-    // WebSocket URL for SLMM backend via proxy
-    const wsProtocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
-    const wsUrl = `${wsProtocol}//${window.location.host}/api/slmm/${unitId}/live`;
-
-    currentWebSocket = new WebSocket(wsUrl);
-
-    currentWebSocket.onopen = function() {
-        console.log('WebSocket connected');
-        // Toggle button visibility
-        const startBtn = document.getElementById('start-stream-btn');
-        const stopBtn = document.getElementById('stop-stream-btn');
-        if (startBtn) startBtn.style.display = 'none';
-        if (stopBtn) stopBtn.style.display = 'flex';
-    };
-
-    currentWebSocket.onmessage = function(event) {
-        const data = JSON.parse(event.data);
-        updateLiveChart(data);
-        updateLiveMetrics(data);
-    };
-
-    currentWebSocket.onerror = function(error) {
-        console.error('WebSocket error:', error);
-    };
-
-    currentWebSocket.onclose = function() {
-        console.log('WebSocket closed');
-        // Toggle button visibility
-        const startBtn = document.getElementById('start-stream-btn');
-        const stopBtn = document.getElementById('stop-stream-btn');
-        if (startBtn) startBtn.style.display = 'flex';
-        if (stopBtn) stopBtn.style.display = 'none';
-    };
-}
-
-function stopLiveDataStream() {
-    if (currentWebSocket) {
-        currentWebSocket.close();
-        currentWebSocket = null;
-    }
-}
-
-// Update live chart with new data point
-let chartData = {
-    timestamps: [],
-    lp: [],
-    leq: []
-};
-
-function updateLiveChart(data) {
-    const now = new Date();
-    chartData.timestamps.push(now.toLocaleTimeString());
-    chartData.lp.push(parseFloat(data.lp || 0));
-    chartData.leq.push(parseFloat(data.leq || 0));
-
-    // Keep only last 60 data points (1 minute at 1 sample/sec)
-    if (chartData.timestamps.length > 60) {
-        chartData.timestamps.shift();
-        chartData.lp.shift();
-        chartData.leq.shift();
-    }
-
-    // Update chart (using Chart.js if available)
-    if (window.liveChart) {
-        window.liveChart.data.labels = chartData.timestamps;
-        window.liveChart.data.datasets[0].data = chartData.lp;
-        window.liveChart.data.datasets[1].data = chartData.leq;
-        window.liveChart.update('none'); // Update without animation for smooth real-time
-    }
-}
-
-function updateLiveMetrics(data) {
-    // Update metric displays
-    if (document.getElementById('live-lp')) {
-        document.getElementById('live-lp').textContent = data.lp || '--';
-    }
-    if (document.getElementById('live-leq')) {
-        document.getElementById('live-leq').textContent = data.leq || '--';
-    }
-    if (document.getElementById('live-lmax')) {
-        document.getElementById('live-lmax').textContent = data.lmax || '--';
-    }
-    if (document.getElementById('live-lmin')) {
-        document.getElementById('live-lmin').textContent = data.lmin || '--';
-    }
-}
-
-// Cleanup on page unload
-window.addEventListener('beforeunload', function() {
-    if (currentWebSocket) {
-        currentWebSocket.close();
-    }
-});
-</script>
-{% endblock %}

backend/init_projects_db.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Database initialization script for Projects system.
+
+This script creates the new project management tables and populates
+the project_types table with default templates.
+
+Usage:
+    python -m backend.init_projects_db
+"""
+
+from sqlalchemy.orm import Session
+from backend.database import engine, SessionLocal
+from backend.models import (
+    Base,
+    ProjectType,
+    Project,
+    MonitoringLocation,
+    UnitAssignment,
+    ScheduledAction,
+    MonitoringSession,
+    DataFile,
+)
+from datetime import datetime
+
+
+def init_project_types(db: Session):
+    """Initialize default project types."""
+    project_types = [
+        {
+            "id": "sound_monitoring",
+            "name": "Sound Monitoring",
+            "description": "Noise monitoring projects with sound level meters and NRLs (Noise Recording Locations)",
+            "icon": "volume-2",  # Lucide icon name
+            "supports_sound": True,
+            "supports_vibration": False,
+        },
+        {
+            "id": "vibration_monitoring",
+            "name": "Vibration Monitoring",
+            "description": "Seismic/vibration monitoring projects with seismographs and monitoring points",
+            "icon": "activity",  # Lucide icon name
+            "supports_sound": False,
+            "supports_vibration": True,
+        },
+        {
+            "id": "combined",
+            "name": "Combined Monitoring",
+            "description": "Full-spectrum monitoring with both sound and vibration capabilities",
+            "icon": "layers",  # Lucide icon name
+            "supports_sound": True,
+            "supports_vibration": True,
+        },
+    ]
+
+    for pt_data in project_types:
+        existing = db.query(ProjectType).filter_by(id=pt_data["id"]).first()
+        if not existing:
+            pt = ProjectType(**pt_data)
+            db.add(pt)
+            print(f"✓ Created project type: {pt_data['name']}")
+        else:
+            print(f"  Project type already exists: {pt_data['name']}")
+
+    db.commit()
+
+
+def create_tables():
+    """Create all tables defined in models."""
+    print("Creating project management tables...")
+    Base.metadata.create_all(bind=engine)
+    print("✓ Tables created successfully")
+
+
+def main():
+    print("=" * 60)
+    print("Terra-View Projects System - Database Initialization")
+    print("=" * 60)
+    print()
+
+    # Create tables
+    create_tables()
+    print()
+
+    # Initialize project types
+    db = SessionLocal()
+    try:
+        print("Initializing project types...")
+        init_project_types(db)
+        print()
+        print("=" * 60)
+        print("✓ Database initialization complete!")
+        print("=" * 60)
+        print()
+        print("Next steps:")
+        print("  1. Restart Terra-View to load new routes")
+        print("  2. Navigate to /projects to create your first project")
+        print("  3. Check documentation for API endpoints")
+    except Exception as e:
+        print(f"✗ Error during initialization: {e}")
+        db.rollback()
+        raise
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    main()

backend/main.py

@@ -0,0 +1,783 @@
+import os
+import logging
+from fastapi import FastAPI, Request, Depends, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+from fastapi.exceptions import RequestValidationError
+from sqlalchemy.orm import Session
+from typing import List, Dict, Optional
+from pydantic import BaseModel
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+from backend.database import engine, Base, get_db
+from backend.routers import roster, units, photos, roster_edit, roster_rename, dashboard, dashboard_tabs, activity, slmm, slm_ui, slm_dashboard, seismo_dashboard, projects, project_locations, scheduler, modem_dashboard
+from backend.services.snapshot import emit_status_snapshot
+from backend.models import IgnoredUnit
+from backend.utils.timezone import get_user_timezone
+
+# Create database tables
+Base.metadata.create_all(bind=engine)
+
+# Read environment (development or production)
+ENVIRONMENT = os.getenv("ENVIRONMENT", "production")
+
+# Initialize FastAPI app
+VERSION = "0.7.0"
+if ENVIRONMENT == "development":
+    _build = os.getenv("BUILD_NUMBER", "0")
+    if _build and _build != "0":
+        VERSION = f"{VERSION}-{_build}"
+app = FastAPI(
+    title="Seismo Fleet Manager",
+    description="Backend API for managing seismograph fleet status",
+    version=VERSION
+)
+
+# Add validation error handler to log details
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    logger.error(f"Validation error on {request.url}: {exc.errors()}")
+    logger.error(f"Body: {await request.body()}")
+    return JSONResponse(
+        status_code=400,
+        content={"detail": exc.errors()}
+    )
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="backend/static"), name="static")
+
+# Use shared templates configuration with timezone filters
+from backend.templates_config import templates
+
+# Add custom context processor to inject environment variable into all templates
+@app.middleware("http")
+async def add_environment_to_context(request: Request, call_next):
+    """Middleware to add environment variable to request state"""
+    request.state.environment = ENVIRONMENT
+    response = await call_next(request)
+    return response
+
+# Override TemplateResponse to include environment and version in context
+original_template_response = templates.TemplateResponse
+def custom_template_response(name, context=None, *args, **kwargs):
+    if context is None:
+        context = {}
+    context["environment"] = ENVIRONMENT
+    context["version"] = VERSION
+    return original_template_response(name, context, *args, **kwargs)
+templates.TemplateResponse = custom_template_response
+
+# Include API routers
+app.include_router(roster.router)
+app.include_router(units.router)
+app.include_router(photos.router)
+app.include_router(roster_edit.router)
+app.include_router(roster_rename.router)
+app.include_router(dashboard.router)
+app.include_router(dashboard_tabs.router)
+app.include_router(activity.router)
+app.include_router(slmm.router)
+app.include_router(slm_ui.router)
+app.include_router(slm_dashboard.router)
+app.include_router(seismo_dashboard.router)
+app.include_router(modem_dashboard.router)
+
+from backend.routers import settings
+app.include_router(settings.router)
+
+# Projects system routers
+app.include_router(projects.router)
+app.include_router(project_locations.router)
+app.include_router(scheduler.router)
+
+# Report templates router
+from backend.routers import report_templates
+app.include_router(report_templates.router)
+
+# Alerts router
+from backend.routers import alerts
+app.include_router(alerts.router)
+
+# Recurring schedules router
+from backend.routers import recurring_schedules
+app.include_router(recurring_schedules.router)
+
+# Fleet Calendar router
+from backend.routers import fleet_calendar
+app.include_router(fleet_calendar.router)
+
+# Start scheduler service and device status monitor on application startup
+from backend.services.scheduler import start_scheduler, stop_scheduler
+from backend.services.device_status_monitor import start_device_status_monitor, stop_device_status_monitor
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize services on app startup"""
+    logger.info("Starting scheduler service...")
+    await start_scheduler()
+    logger.info("Scheduler service started")
+
+    logger.info("Starting device status monitor...")
+    await start_device_status_monitor()
+    logger.info("Device status monitor started")
+
+@app.on_event("shutdown")
+def shutdown_event():
+    """Clean up services on app shutdown"""
+    logger.info("Stopping device status monitor...")
+    stop_device_status_monitor()
+    logger.info("Device status monitor stopped")
+
+    logger.info("Stopping scheduler service...")
+    stop_scheduler()
+    logger.info("Scheduler service stopped")
+
+
+# Legacy routes from the original backend
+from backend import routes as legacy_routes
+app.include_router(legacy_routes.router)
+
+
+# HTML page routes
+@app.get("/", response_class=HTMLResponse)
+async def dashboard(request: Request):
+    """Dashboard home page"""
+    return templates.TemplateResponse("dashboard.html", {"request": request})
+
+
+@app.get("/roster", response_class=HTMLResponse)
+async def roster_page(request: Request):
+    """Fleet roster page"""
+    return templates.TemplateResponse("roster.html", {"request": request})
+
+
+@app.get("/unit/{unit_id}", response_class=HTMLResponse)
+async def unit_detail_page(request: Request, unit_id: str):
+    """Unit detail page"""
+    return templates.TemplateResponse("unit_detail.html", {
+        "request": request,
+        "unit_id": unit_id
+    })
+
+
+@app.get("/settings", response_class=HTMLResponse)
+async def settings_page(request: Request):
+    """Settings page for roster management"""
+    return templates.TemplateResponse("settings.html", {"request": request})
+
+
+@app.get("/sound-level-meters", response_class=HTMLResponse)
+async def sound_level_meters_page(request: Request):
+    """Sound Level Meters management dashboard"""
+    return templates.TemplateResponse("sound_level_meters.html", {"request": request})
+
+
+@app.get("/slm/{unit_id}", response_class=HTMLResponse)
+async def slm_legacy_dashboard(
+    request: Request,
+    unit_id: str,
+    from_project: Optional[str] = None,
+    from_nrl: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
+    """Legacy SLM control center dashboard for a specific unit"""
+    # Get project details if from_project is provided
+    project = None
+    if from_project:
+        from backend.models import Project
+        project = db.query(Project).filter_by(id=from_project).first()
+
+    # Get NRL location details if from_nrl is provided
+    nrl_location = None
+    if from_nrl:
+        from backend.models import NRLLocation
+        nrl_location = db.query(NRLLocation).filter_by(id=from_nrl).first()
+
+    return templates.TemplateResponse("slm_legacy_dashboard.html", {
+        "request": request,
+        "unit_id": unit_id,
+        "from_project": from_project,
+        "from_nrl": from_nrl,
+        "project": project,
+        "nrl_location": nrl_location
+    })
+
+
+@app.get("/seismographs", response_class=HTMLResponse)
+async def seismographs_page(request: Request):
+    """Seismographs management dashboard"""
+    return templates.TemplateResponse("seismographs.html", {"request": request})
+
+
+@app.get("/modems", response_class=HTMLResponse)
+async def modems_page(request: Request):
+    """Field modems management dashboard"""
+    return templates.TemplateResponse("modems.html", {"request": request})
+
+
+@app.get("/pair-devices", response_class=HTMLResponse)
+async def pair_devices_page(request: Request, db: Session = Depends(get_db)):
+    """
+    Device pairing page - two-column layout for pairing recorders with modems.
+    """
+    from backend.models import RosterUnit
+
+    # Get all non-retired recorders (seismographs and SLMs)
+    recorders = db.query(RosterUnit).filter(
+        RosterUnit.retired == False,
+        RosterUnit.device_type.in_(["seismograph", "slm", None])  # None defaults to seismograph
+    ).order_by(RosterUnit.id).all()
+
+    # Get all non-retired modems
+    modems = db.query(RosterUnit).filter(
+        RosterUnit.retired == False,
+        RosterUnit.device_type == "modem"
+    ).order_by(RosterUnit.id).all()
+
+    # Build existing pairings list
+    pairings = []
+    for recorder in recorders:
+        if recorder.deployed_with_modem_id:
+            modem = next((m for m in modems if m.id == recorder.deployed_with_modem_id), None)
+            pairings.append({
+                "recorder_id": recorder.id,
+                "recorder_type": (recorder.device_type or "seismograph").upper(),
+                "modem_id": recorder.deployed_with_modem_id,
+                "modem_ip": modem.ip_address if modem else None
+            })
+
+    # Convert to dicts for template
+    recorders_data = [
+        {
+            "id": r.id,
+            "device_type": r.device_type or "seismograph",
+            "deployed": r.deployed,
+            "deployed_with_modem_id": r.deployed_with_modem_id
+        }
+        for r in recorders
+    ]
+
+    modems_data = [
+        {
+            "id": m.id,
+            "deployed": m.deployed,
+            "deployed_with_unit_id": m.deployed_with_unit_id,
+            "ip_address": m.ip_address,
+            "phone_number": m.phone_number
+        }
+        for m in modems
+    ]
+
+    return templates.TemplateResponse("pair_devices.html", {
+        "request": request,
+        "recorders": recorders_data,
+        "modems": modems_data,
+        "pairings": pairings
+    })
+
+
+@app.get("/projects", response_class=HTMLResponse)
+async def projects_page(request: Request):
+    """Projects management and overview"""
+    return templates.TemplateResponse("projects/overview.html", {"request": request})
+
+
+@app.get("/projects/{project_id}", response_class=HTMLResponse)
+async def project_detail_page(request: Request, project_id: str):
+    """Project detail dashboard"""
+    return templates.TemplateResponse("projects/detail.html", {
+        "request": request,
+        "project_id": project_id
+    })
+
+
+@app.get("/projects/{project_id}/nrl/{location_id}", response_class=HTMLResponse)
+async def nrl_detail_page(
+    request: Request,
+    project_id: str,
+    location_id: str,
+    db: Session = Depends(get_db)
+):
+    """NRL (Noise Recording Location) detail page with tabs"""
+    from backend.models import Project, MonitoringLocation, UnitAssignment, RosterUnit, MonitoringSession, DataFile
+    from sqlalchemy import and_
+
+    # Get project
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        return templates.TemplateResponse("404.html", {
+            "request": request,
+            "message": "Project not found"
+        }, status_code=404)
+
+    # Get location
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id
+    ).first()
+
+    if not location:
+        return templates.TemplateResponse("404.html", {
+            "request": request,
+            "message": "Location not found"
+        }, status_code=404)
+
+    # Get active assignment
+    assignment = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.location_id == location_id,
+            UnitAssignment.status == "active"
+        )
+    ).first()
+
+    assigned_unit = None
+    if assignment:
+        assigned_unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+
+    # Get session count
+    session_count = db.query(MonitoringSession).filter_by(location_id=location_id).count()
+
+    # Get file count (DataFile links to session, not directly to location)
+    file_count = db.query(DataFile).join(
+        MonitoringSession,
+        DataFile.session_id == MonitoringSession.id
+    ).filter(MonitoringSession.location_id == location_id).count()
+
+    # Check for active session
+    active_session = db.query(MonitoringSession).filter(
+        and_(
+            MonitoringSession.location_id == location_id,
+            MonitoringSession.status == "recording"
+        )
+    ).first()
+
+    # Parse connection_mode from location_metadata JSON
+    import json as _json
+    connection_mode = "connected"
+    try:
+        meta = _json.loads(location.location_metadata or "{}")
+        connection_mode = meta.get("connection_mode", "connected")
+    except Exception:
+        pass
+
+    template = "vibration_location_detail.html" if location.location_type == "vibration" else "nrl_detail.html"
+    return templates.TemplateResponse(template, {
+        "request": request,
+        "project_id": project_id,
+        "location_id": location_id,
+        "project": project,
+        "location": location,
+        "assignment": assignment,
+        "assigned_unit": assigned_unit,
+        "session_count": session_count,
+        "file_count": file_count,
+        "active_session": active_session,
+        "connection_mode": connection_mode,
+    })
+
+
+# ===== PWA ROUTES =====
+
+@app.get("/sw.js")
+async def service_worker():
+    """Serve service worker with proper headers for PWA"""
+    return FileResponse(
+        "backend/static/sw.js",
+        media_type="application/javascript",
+        headers={
+            "Service-Worker-Allowed": "/",
+            "Cache-Control": "no-cache"
+        }
+    )
+
+
+@app.get("/offline-db.js")
+async def offline_db_script():
+    """Serve offline database script"""
+    return FileResponse(
+        "backend/static/offline-db.js",
+        media_type="application/javascript",
+        headers={"Cache-Control": "no-cache"}
+    )
+
+
+# Pydantic model for sync edits
+class EditItem(BaseModel):
+    id: int
+    unitId: str
+    changes: Dict
+    timestamp: int
+
+
+class SyncEditsRequest(BaseModel):
+    edits: List[EditItem]
+
+
+@app.post("/api/sync-edits")
+async def sync_edits(request: SyncEditsRequest, db: Session = Depends(get_db)):
+    """Process offline edit queue and sync to database"""
+    from backend.models import RosterUnit
+
+    results = []
+    synced_ids = []
+
+    for edit in request.edits:
+        try:
+            # Find the unit
+            unit = db.query(RosterUnit).filter_by(id=edit.unitId).first()
+
+            if not unit:
+                results.append({
+                    "id": edit.id,
+                    "status": "error",
+                    "reason": f"Unit {edit.unitId} not found"
+                })
+                continue
+
+            # Apply changes
+            for key, value in edit.changes.items():
+                if hasattr(unit, key):
+                    # Handle boolean conversions
+                    if key in ['deployed', 'retired']:
+                        setattr(unit, key, value in ['true', True, 'True', '1', 1])
+                    else:
+                        setattr(unit, key, value if value != '' else None)
+
+            db.commit()
+
+            results.append({
+                "id": edit.id,
+                "status": "success"
+            })
+            synced_ids.append(edit.id)
+
+        except Exception as e:
+            db.rollback()
+            results.append({
+                "id": edit.id,
+                "status": "error",
+                "reason": str(e)
+            })
+
+    synced_count = len(synced_ids)
+
+    return JSONResponse({
+        "synced": synced_count,
+        "total": len(request.edits),
+        "synced_ids": synced_ids,
+        "results": results
+    })
+
+
+@app.get("/partials/roster-deployed", response_class=HTMLResponse)
+async def roster_deployed_partial(request: Request):
+    """Partial template for deployed units tab"""
+    from datetime import datetime
+    snapshot = emit_status_snapshot()
+
+    units_list = []
+    for unit_id, unit_data in snapshot["active"].items():
+        units_list.append({
+            "id": unit_id,
+            "status": unit_data.get("status", "Unknown"),
+            "age": unit_data.get("age", "N/A"),
+            "last_seen": unit_data.get("last", "Never"),
+            "deployed": unit_data.get("deployed", False),
+            "note": unit_data.get("note", ""),
+            "device_type": unit_data.get("device_type", "seismograph"),
+            "address": unit_data.get("address", ""),
+            "coordinates": unit_data.get("coordinates", ""),
+            "project_id": unit_data.get("project_id", ""),
+            "last_calibrated": unit_data.get("last_calibrated"),
+            "next_calibration_due": unit_data.get("next_calibration_due"),
+            "deployed_with_modem_id": unit_data.get("deployed_with_modem_id"),
+            "ip_address": unit_data.get("ip_address"),
+            "phone_number": unit_data.get("phone_number"),
+            "hardware_model": unit_data.get("hardware_model"),
+        })
+
+    # Sort by status priority (Missing > Pending > OK) then by ID
+    status_priority = {"Missing": 0, "Pending": 1, "OK": 2}
+    units_list.sort(key=lambda x: (status_priority.get(x["status"], 3), x["id"]))
+
+    return templates.TemplateResponse("partials/roster_table.html", {
+        "request": request,
+        "units": units_list,
+        "timestamp": datetime.now().strftime("%H:%M:%S")
+    })
+
+
+@app.get("/partials/roster-benched", response_class=HTMLResponse)
+async def roster_benched_partial(request: Request):
+    """Partial template for benched units tab"""
+    from datetime import datetime
+    snapshot = emit_status_snapshot()
+
+    units_list = []
+    for unit_id, unit_data in snapshot["benched"].items():
+        units_list.append({
+            "id": unit_id,
+            "status": unit_data.get("status", "N/A"),
+            "age": unit_data.get("age", "N/A"),
+            "last_seen": unit_data.get("last", "Never"),
+            "deployed": unit_data.get("deployed", False),
+            "note": unit_data.get("note", ""),
+            "device_type": unit_data.get("device_type", "seismograph"),
+            "address": unit_data.get("address", ""),
+            "coordinates": unit_data.get("coordinates", ""),
+            "project_id": unit_data.get("project_id", ""),
+            "last_calibrated": unit_data.get("last_calibrated"),
+            "next_calibration_due": unit_data.get("next_calibration_due"),
+            "deployed_with_modem_id": unit_data.get("deployed_with_modem_id"),
+            "ip_address": unit_data.get("ip_address"),
+            "phone_number": unit_data.get("phone_number"),
+            "hardware_model": unit_data.get("hardware_model"),
+        })
+
+    # Sort by ID
+    units_list.sort(key=lambda x: x["id"])
+
+    return templates.TemplateResponse("partials/roster_table.html", {
+        "request": request,
+        "units": units_list,
+        "timestamp": datetime.now().strftime("%H:%M:%S")
+    })
+
+
+@app.get("/partials/roster-retired", response_class=HTMLResponse)
+async def roster_retired_partial(request: Request):
+    """Partial template for retired units tab"""
+    from datetime import datetime
+    snapshot = emit_status_snapshot()
+
+    units_list = []
+    for unit_id, unit_data in snapshot["retired"].items():
+        units_list.append({
+            "id": unit_id,
+            "status": unit_data["status"],
+            "age": unit_data["age"],
+            "last_seen": unit_data["last"],
+            "deployed": unit_data["deployed"],
+            "note": unit_data.get("note", ""),
+            "device_type": unit_data.get("device_type", "seismograph"),
+            "last_calibrated": unit_data.get("last_calibrated"),
+            "next_calibration_due": unit_data.get("next_calibration_due"),
+            "deployed_with_modem_id": unit_data.get("deployed_with_modem_id"),
+            "ip_address": unit_data.get("ip_address"),
+            "phone_number": unit_data.get("phone_number"),
+            "hardware_model": unit_data.get("hardware_model"),
+        })
+
+    # Sort by ID
+    units_list.sort(key=lambda x: x["id"])
+
+    return templates.TemplateResponse("partials/retired_table.html", {
+        "request": request,
+        "units": units_list,
+        "timestamp": datetime.now().strftime("%H:%M:%S")
+    })
+
+
+@app.get("/partials/roster-ignored", response_class=HTMLResponse)
+async def roster_ignored_partial(request: Request, db: Session = Depends(get_db)):
+    """Partial template for ignored units tab"""
+    from datetime import datetime
+
+    ignored = db.query(IgnoredUnit).all()
+    ignored_list = []
+    for unit in ignored:
+        ignored_list.append({
+            "id": unit.id,
+            "reason": unit.reason or "",
+            "ignored_at": unit.ignored_at.strftime("%Y-%m-%d %H:%M:%S") if unit.ignored_at else "Unknown"
+        })
+
+    # Sort by ID
+    ignored_list.sort(key=lambda x: x["id"])
+
+    return templates.TemplateResponse("partials/ignored_table.html", {
+        "request": request,
+        "ignored_units": ignored_list,
+        "timestamp": datetime.now().strftime("%H:%M:%S")
+    })
+
+
+@app.get("/partials/unknown-emitters", response_class=HTMLResponse)
+async def unknown_emitters_partial(request: Request):
+    """Partial template for unknown emitters (HTMX)"""
+    snapshot = emit_status_snapshot()
+
+    unknown_list = []
+    for unit_id, unit_data in snapshot.get("unknown", {}).items():
+        unknown_list.append({
+            "id": unit_id,
+            "status": unit_data["status"],
+            "age": unit_data["age"],
+            "fname": unit_data.get("fname", ""),
+        })
+
+    # Sort by ID
+    unknown_list.sort(key=lambda x: x["id"])
+
+    return templates.TemplateResponse("partials/unknown_emitters.html", {
+        "request": request,
+        "unknown_units": unknown_list
+    })
+
+
+@app.get("/partials/devices-all", response_class=HTMLResponse)
+async def devices_all_partial(request: Request):
+    """Unified partial template for ALL devices with comprehensive filtering support"""
+    from datetime import datetime
+    snapshot = emit_status_snapshot()
+
+    units_list = []
+
+    # Add deployed/active units
+    for unit_id, unit_data in snapshot["active"].items():
+        units_list.append({
+            "id": unit_id,
+            "status": unit_data.get("status", "Unknown"),
+            "age": unit_data.get("age", "N/A"),
+            "last_seen": unit_data.get("last", "Never"),
+            "deployed": True,
+            "retired": False,
+            "ignored": False,
+            "note": unit_data.get("note", ""),
+            "device_type": unit_data.get("device_type", "seismograph"),
+            "address": unit_data.get("address", ""),
+            "coordinates": unit_data.get("coordinates", ""),
+            "project_id": unit_data.get("project_id", ""),
+            "last_calibrated": unit_data.get("last_calibrated"),
+            "next_calibration_due": unit_data.get("next_calibration_due"),
+            "deployed_with_modem_id": unit_data.get("deployed_with_modem_id"),
+            "deployed_with_unit_id": unit_data.get("deployed_with_unit_id"),
+            "ip_address": unit_data.get("ip_address"),
+            "phone_number": unit_data.get("phone_number"),
+            "hardware_model": unit_data.get("hardware_model"),
+        })
+
+    # Add benched units
+    for unit_id, unit_data in snapshot["benched"].items():
+        units_list.append({
+            "id": unit_id,
+            "status": unit_data.get("status", "N/A"),
+            "age": unit_data.get("age", "N/A"),
+            "last_seen": unit_data.get("last", "Never"),
+            "deployed": False,
+            "retired": False,
+            "ignored": False,
+            "note": unit_data.get("note", ""),
+            "device_type": unit_data.get("device_type", "seismograph"),
+            "address": unit_data.get("address", ""),
+            "coordinates": unit_data.get("coordinates", ""),
+            "project_id": unit_data.get("project_id", ""),
+            "last_calibrated": unit_data.get("last_calibrated"),
+            "next_calibration_due": unit_data.get("next_calibration_due"),
+            "deployed_with_modem_id": unit_data.get("deployed_with_modem_id"),
+            "deployed_with_unit_id": unit_data.get("deployed_with_unit_id"),
+            "ip_address": unit_data.get("ip_address"),
+            "phone_number": unit_data.get("phone_number"),
+            "hardware_model": unit_data.get("hardware_model"),
+        })
+
+    # Add retired units
+    for unit_id, unit_data in snapshot["retired"].items():
+        units_list.append({
+            "id": unit_id,
+            "status": "Retired",
+            "age": "N/A",
+            "last_seen": "N/A",
+            "deployed": False,
+            "retired": True,
+            "ignored": False,
+            "note": unit_data.get("note", ""),
+            "device_type": unit_data.get("device_type", "seismograph"),
+            "address": unit_data.get("address", ""),
+            "coordinates": unit_data.get("coordinates", ""),
+            "project_id": unit_data.get("project_id", ""),
+            "last_calibrated": unit_data.get("last_calibrated"),
+            "next_calibration_due": unit_data.get("next_calibration_due"),
+            "deployed_with_modem_id": unit_data.get("deployed_with_modem_id"),
+            "deployed_with_unit_id": unit_data.get("deployed_with_unit_id"),
+            "ip_address": unit_data.get("ip_address"),
+            "phone_number": unit_data.get("phone_number"),
+            "hardware_model": unit_data.get("hardware_model"),
+        })
+
+    # Add ignored units
+    for unit_id, unit_data in snapshot.get("ignored", {}).items():
+        units_list.append({
+            "id": unit_id,
+            "status": "Ignored",
+            "age": "N/A",
+            "last_seen": "N/A",
+            "deployed": False,
+            "retired": False,
+            "ignored": True,
+            "note": unit_data.get("note", unit_data.get("reason", "")),
+            "device_type": unit_data.get("device_type", "unknown"),
+            "address": "",
+            "coordinates": "",
+            "project_id": "",
+            "last_calibrated": None,
+            "next_calibration_due": None,
+            "deployed_with_modem_id": None,
+            "deployed_with_unit_id": None,
+            "ip_address": None,
+            "phone_number": None,
+            "hardware_model": None,
+        })
+
+    # Sort by status category, then by ID
+    def sort_key(unit):
+        # Priority: deployed (active) -> benched -> retired -> ignored
+        if unit["deployed"]:
+            return (0, unit["id"])
+        elif not unit["retired"] and not unit["ignored"]:
+            return (1, unit["id"])
+        elif unit["retired"]:
+            return (2, unit["id"])
+        else:
+            return (3, unit["id"])
+
+    units_list.sort(key=sort_key)
+
+    return templates.TemplateResponse("partials/devices_table.html", {
+        "request": request,
+        "units": units_list,
+        "timestamp": datetime.now().strftime("%H:%M:%S"),
+        "user_timezone": get_user_timezone()
+    })
+
+
+@app.get("/health")
+def health_check():
+    """Health check endpoint"""
+    return {
+        "message": f"Seismo Fleet Manager v{VERSION}",
+        "status": "running",
+        "version": VERSION
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

backend/migrate_add_auto_increment_index.py

@@ -0,0 +1,67 @@
+"""
+Migration: Add auto_increment_index column to recurring_schedules table
+
+This migration adds the auto_increment_index column that controls whether
+the scheduler should automatically find an unused store index before starting
+a new measurement.
+
+Run this script once to update existing databases:
+    python -m backend.migrate_add_auto_increment_index
+"""
+
+import sqlite3
+import os
+
+DB_PATH = "data/seismo_fleet.db"
+
+
+def migrate():
+    """Add auto_increment_index column to recurring_schedules table."""
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        return False
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    try:
+        # Check if recurring_schedules table exists
+        cursor.execute("""
+            SELECT name FROM sqlite_master
+            WHERE type='table' AND name='recurring_schedules'
+        """)
+        if not cursor.fetchone():
+            print("recurring_schedules table does not exist yet. Will be created on app startup.")
+            conn.close()
+            return True
+
+        # Check if auto_increment_index column already exists
+        cursor.execute("PRAGMA table_info(recurring_schedules)")
+        columns = [row[1] for row in cursor.fetchall()]
+
+        if "auto_increment_index" in columns:
+            print("auto_increment_index column already exists in recurring_schedules table.")
+            conn.close()
+            return True
+
+        # Add the column
+        print("Adding auto_increment_index column to recurring_schedules table...")
+        cursor.execute("""
+            ALTER TABLE recurring_schedules
+            ADD COLUMN auto_increment_index BOOLEAN DEFAULT 1
+        """)
+        conn.commit()
+        print("Successfully added auto_increment_index column.")
+
+        conn.close()
+        return True
+
+    except Exception as e:
+        print(f"Migration failed: {e}")
+        conn.close()
+        return False
+
+
+if __name__ == "__main__":
+    success = migrate()
+    exit(0 if success else 1)

backend/migrate_add_deployment_type.py

@@ -0,0 +1,84 @@
+"""
+Migration script to add deployment_type and deployed_with_unit_id fields to roster table.
+
+deployment_type: tracks what type of device a modem is deployed with:
+- "seismograph" - Modem is connected to a seismograph
+- "slm" - Modem is connected to a sound level meter
+- NULL/empty - Not assigned or unknown
+
+deployed_with_unit_id: stores the ID of the seismograph/SLM this modem is deployed with
+(reverse relationship of deployed_with_modem_id)
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+
+def migrate_database():
+    """Add deployment_type and deployed_with_unit_id columns to roster table"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if roster table exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='roster'")
+    table_exists = cursor.fetchone()
+
+    if not table_exists:
+        print("Roster table does not exist yet - will be created when app runs")
+        conn.close()
+        return
+
+    # Check existing columns
+    cursor.execute("PRAGMA table_info(roster)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    try:
+        # Add deployment_type if not exists
+        if 'deployment_type' not in columns:
+            print("Adding deployment_type column to roster table...")
+            cursor.execute("ALTER TABLE roster ADD COLUMN deployment_type TEXT")
+            print("  Added deployment_type column")
+
+            cursor.execute("CREATE INDEX IF NOT EXISTS ix_roster_deployment_type ON roster(deployment_type)")
+            print("  Created index on deployment_type")
+        else:
+            print("deployment_type column already exists")
+
+        # Add deployed_with_unit_id if not exists
+        if 'deployed_with_unit_id' not in columns:
+            print("Adding deployed_with_unit_id column to roster table...")
+            cursor.execute("ALTER TABLE roster ADD COLUMN deployed_with_unit_id TEXT")
+            print("  Added deployed_with_unit_id column")
+
+            cursor.execute("CREATE INDEX IF NOT EXISTS ix_roster_deployed_with_unit_id ON roster(deployed_with_unit_id)")
+            print("  Created index on deployed_with_unit_id")
+        else:
+            print("deployed_with_unit_id column already exists")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_add_device_types.py

@@ -0,0 +1,84 @@
+"""
+Migration script to add device type support to the roster table.
+
+This adds columns for:
+- device_type (seismograph/modem discriminator)
+- Seismograph-specific fields (calibration dates, modem pairing)
+- Modem-specific fields (IP address, phone number, hardware model)
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+def migrate_database():
+    """Add new columns to the roster table"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if device_type column already exists
+    cursor.execute("PRAGMA table_info(roster)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    if "device_type" in columns:
+        print("Migration already applied - device_type column exists")
+        conn.close()
+        return
+
+    print("Adding new columns to roster table...")
+
+    try:
+        # Add device type discriminator
+        cursor.execute("ALTER TABLE roster ADD COLUMN device_type TEXT DEFAULT 'seismograph'")
+        print("  ✓ Added device_type column")
+
+        # Add seismograph-specific fields
+        cursor.execute("ALTER TABLE roster ADD COLUMN last_calibrated DATE")
+        print("  ✓ Added last_calibrated column")
+
+        cursor.execute("ALTER TABLE roster ADD COLUMN next_calibration_due DATE")
+        print("  ✓ Added next_calibration_due column")
+
+        cursor.execute("ALTER TABLE roster ADD COLUMN deployed_with_modem_id TEXT")
+        print("  ✓ Added deployed_with_modem_id column")
+
+        # Add modem-specific fields
+        cursor.execute("ALTER TABLE roster ADD COLUMN ip_address TEXT")
+        print("  ✓ Added ip_address column")
+
+        cursor.execute("ALTER TABLE roster ADD COLUMN phone_number TEXT")
+        print("  ✓ Added phone_number column")
+
+        cursor.execute("ALTER TABLE roster ADD COLUMN hardware_model TEXT")
+        print("  ✓ Added hardware_model column")
+
+        # Set all existing units to seismograph type
+        cursor.execute("UPDATE roster SET device_type = 'seismograph' WHERE device_type IS NULL")
+        print("  ✓ Set existing units to seismograph type")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_add_job_reservations.py

@@ -0,0 +1,103 @@
+"""
+Migration script to add job reservations for the Fleet Calendar feature.
+
+This creates two tables:
+- job_reservations: Track future unit assignments for jobs/projects
+- job_reservation_units: Link specific units to reservations
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+
+def migrate_database():
+    """Create the job_reservations and job_reservation_units tables"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if job_reservations table already exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='job_reservations'")
+    if cursor.fetchone():
+        print("Migration already applied - job_reservations table exists")
+        conn.close()
+        return
+
+    print("Creating job_reservations table...")
+
+    try:
+        # Create job_reservations table
+        cursor.execute("""
+            CREATE TABLE job_reservations (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                project_id TEXT,
+                start_date DATE NOT NULL,
+                end_date DATE NOT NULL,
+                assignment_type TEXT NOT NULL DEFAULT 'quantity',
+                device_type TEXT DEFAULT 'seismograph',
+                quantity_needed INTEGER,
+                notes TEXT,
+                color TEXT DEFAULT '#3B82F6',
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        print("  Created job_reservations table")
+
+        # Create indexes for job_reservations
+        cursor.execute("CREATE INDEX idx_job_reservations_project_id ON job_reservations(project_id)")
+        print("  Created index on project_id")
+
+        cursor.execute("CREATE INDEX idx_job_reservations_dates ON job_reservations(start_date, end_date)")
+        print("  Created index on dates")
+
+        # Create job_reservation_units table
+        print("Creating job_reservation_units table...")
+        cursor.execute("""
+            CREATE TABLE job_reservation_units (
+                id TEXT PRIMARY KEY,
+                reservation_id TEXT NOT NULL,
+                unit_id TEXT NOT NULL,
+                assignment_source TEXT DEFAULT 'specific',
+                assigned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                FOREIGN KEY (reservation_id) REFERENCES job_reservations(id),
+                FOREIGN KEY (unit_id) REFERENCES roster(id)
+            )
+        """)
+        print("  Created job_reservation_units table")
+
+        # Create indexes for job_reservation_units
+        cursor.execute("CREATE INDEX idx_job_reservation_units_reservation_id ON job_reservation_units(reservation_id)")
+        print("  Created index on reservation_id")
+
+        cursor.execute("CREATE INDEX idx_job_reservation_units_unit_id ON job_reservation_units(unit_id)")
+        print("  Created index on unit_id")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+        print("You can now use the Fleet Calendar to manage unit reservations.")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_add_oneoff_schedule_fields.py

@@ -0,0 +1,73 @@
+"""
+Migration: Add one-off schedule fields to recurring_schedules table
+
+Adds start_datetime and end_datetime columns for one-off recording schedules.
+
+Run this script once to update existing databases:
+    python -m backend.migrate_add_oneoff_schedule_fields
+"""
+
+import sqlite3
+import os
+
+DB_PATH = "data/seismo_fleet.db"
+
+
+def migrate():
+    """Add one-off schedule columns to recurring_schedules table."""
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        return False
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    try:
+        cursor.execute("""
+            SELECT name FROM sqlite_master
+            WHERE type='table' AND name='recurring_schedules'
+        """)
+        if not cursor.fetchone():
+            print("recurring_schedules table does not exist yet. Will be created on app startup.")
+            conn.close()
+            return True
+
+        cursor.execute("PRAGMA table_info(recurring_schedules)")
+        columns = [row[1] for row in cursor.fetchall()]
+
+        added = False
+
+        if "start_datetime" not in columns:
+            print("Adding start_datetime column to recurring_schedules table...")
+            cursor.execute("""
+                ALTER TABLE recurring_schedules
+                ADD COLUMN start_datetime DATETIME NULL
+            """)
+            added = True
+
+        if "end_datetime" not in columns:
+            print("Adding end_datetime column to recurring_schedules table...")
+            cursor.execute("""
+                ALTER TABLE recurring_schedules
+                ADD COLUMN end_datetime DATETIME NULL
+            """)
+            added = True
+
+        if added:
+            conn.commit()
+            print("Successfully added one-off schedule columns.")
+        else:
+            print("One-off schedule columns already exist.")
+
+        conn.close()
+        return True
+
+    except Exception as e:
+        print(f"Migration failed: {e}")
+        conn.close()
+        return False
+
+
+if __name__ == "__main__":
+    success = migrate()
+    exit(0 if success else 1)

backend/migrate_add_project_data_collection_mode.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+Migration: Add data_collection_mode column to projects table.
+
+Values:
+  "remote"  — units have modems; data pulled via FTP/scheduler automatically
+  "manual"  — no modem; SD cards retrieved daily and uploaded by hand
+
+All existing projects are backfilled to "manual" (safe conservative default).
+
+Run once inside the Docker container:
+    docker exec terra-view python3 backend/migrate_add_project_data_collection_mode.py
+"""
+from pathlib import Path
+
+DB_PATH = Path("data/seismo_fleet.db")
+
+
+def migrate():
+    import sqlite3
+
+    if not DB_PATH.exists():
+        print(f"Database not found at {DB_PATH}. Are you running from /home/serversdown/terra-view?")
+        return
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    # ── 1. Add column (idempotent) ───────────────────────────────────────────
+    cur.execute("PRAGMA table_info(projects)")
+    existing_cols = {row["name"] for row in cur.fetchall()}
+
+    if "data_collection_mode" not in existing_cols:
+        cur.execute("ALTER TABLE projects ADD COLUMN data_collection_mode TEXT DEFAULT 'manual'")
+        conn.commit()
+        print("✓ Added column data_collection_mode to projects")
+    else:
+        print("○ Column data_collection_mode already exists — skipping ALTER TABLE")
+
+    # ── 2. Backfill NULLs to 'manual' ────────────────────────────────────────
+    cur.execute("UPDATE projects SET data_collection_mode = 'manual' WHERE data_collection_mode IS NULL")
+    updated = cur.rowcount
+    conn.commit()
+    conn.close()
+
+    if updated:
+        print(f"✓ Backfilled {updated} project(s) to data_collection_mode='manual'.")
+    print("Migration complete.")
+
+
+if __name__ == "__main__":
+    migrate()

backend/migrate_add_project_deleted_at.py

@@ -0,0 +1,56 @@
+"""
+Migration: Add deleted_at column to projects table
+
+Adds columns:
+- projects.deleted_at: Timestamp set when status='deleted'; data hard-deleted after 60 days
+"""
+
+import sqlite3
+import sys
+from pathlib import Path
+
+
+def migrate(db_path: str):
+    """Run the migration."""
+    print(f"Migrating database: {db_path}")
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    try:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'")
+        if not cursor.fetchone():
+            print("projects table does not exist. Skipping migration.")
+            return
+
+        cursor.execute("PRAGMA table_info(projects)")
+        existing_cols = {row[1] for row in cursor.fetchall()}
+
+        if 'deleted_at' not in existing_cols:
+            print("Adding deleted_at column to projects...")
+            cursor.execute("ALTER TABLE projects ADD COLUMN deleted_at DATETIME")
+        else:
+            print("deleted_at column already exists. Skipping.")
+
+        conn.commit()
+        print("Migration completed successfully!")
+
+    except Exception as e:
+        print(f"Migration failed: {e}")
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    db_path = "./data/terra-view.db"
+
+    if len(sys.argv) > 1:
+        db_path = sys.argv[1]
+
+    if not Path(db_path).exists():
+        print(f"Database not found: {db_path}")
+        sys.exit(1)
+
+    migrate(db_path)

backend/migrate_add_project_number.py

@@ -0,0 +1,80 @@
+"""
+Migration script to add project_number field to projects table.
+
+This adds a new column for TMI internal project numbering:
+- Format: xxxx-YY (e.g., "2567-23")
+- xxxx = incremental project number
+- YY = year project was started
+
+Combined with client_name and name (project/site name), this enables
+smart searching across all project identifiers.
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+
+def migrate_database():
+    """Add project_number column to projects table"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if projects table exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='projects'")
+    table_exists = cursor.fetchone()
+
+    if not table_exists:
+        print("Projects table does not exist yet - will be created when app runs")
+        conn.close()
+        return
+
+    # Check if project_number column already exists
+    cursor.execute("PRAGMA table_info(projects)")
+    columns = [col[1] for col in cursor.fetchall()]
+
+    if 'project_number' in columns:
+        print("Migration already applied - project_number column exists")
+        conn.close()
+        return
+
+    print("Adding project_number column to projects table...")
+
+    try:
+        cursor.execute("ALTER TABLE projects ADD COLUMN project_number TEXT")
+        print("  Added project_number column")
+
+        # Create index for faster searching
+        cursor.execute("CREATE INDEX IF NOT EXISTS ix_projects_project_number ON projects(project_number)")
+        print("  Created index on project_number")
+
+        # Also add index on client_name if it doesn't exist
+        cursor.execute("CREATE INDEX IF NOT EXISTS ix_projects_client_name ON projects(client_name)")
+        print("  Created index on client_name")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_add_report_templates.py

@@ -0,0 +1,88 @@
+"""
+Migration script to add report_templates table.
+
+This creates a new table for storing report generation configurations:
+- Template name and project association
+- Time filtering settings (start/end time)
+- Date range filtering (optional)
+- Report title defaults
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+def migrate_database():
+    """Create report_templates table"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if report_templates table already exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='report_templates'")
+    table_exists = cursor.fetchone()
+
+    if table_exists:
+        print("Migration already applied - report_templates table exists")
+        conn.close()
+        return
+
+    print("Creating report_templates table...")
+
+    try:
+        cursor.execute("""
+            CREATE TABLE report_templates (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                project_id TEXT,
+                report_title TEXT DEFAULT 'Background Noise Study',
+                start_time TEXT,
+                end_time TEXT,
+                start_date TEXT,
+                end_date TEXT,
+                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        print("  ✓ Created report_templates table")
+
+        # Insert default templates
+        import uuid
+
+        default_templates = [
+            (str(uuid.uuid4()), "Nighttime (7PM-7AM)", None, "Background Noise Study", "19:00", "07:00", None, None),
+            (str(uuid.uuid4()), "Daytime (7AM-7PM)", None, "Background Noise Study", "07:00", "19:00", None, None),
+            (str(uuid.uuid4()), "Full Day (All Data)", None, "Background Noise Study", None, None, None, None),
+        ]
+
+        cursor.executemany("""
+            INSERT INTO report_templates (id, name, project_id, report_title, start_time, end_time, start_date, end_date)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """, default_templates)
+        print("  ✓ Inserted default templates (Nighttime, Daytime, Full Day)")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_add_session_device_model.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Migration: Add device_model column to monitoring_sessions table.
+
+Records which physical SLM model produced each session's data (e.g. "NL-43",
+"NL-53", "NL-32"). Used by report generation to apply the correct parsing
+logic without re-opening files to detect format.
+
+Run once inside the Docker container:
+    docker exec terra-view python3 backend/migrate_add_session_device_model.py
+
+Backfill strategy for existing rows:
+  1. If session.unit_id is set, use roster.slm_model for that unit.
+  2. Else, peek at the first .rnd file in the session: presence of the 'LAeq'
+     column header identifies AU2 / NL-32 format.
+  Sessions where neither hint is available remain NULL — the file-content
+  fallback in report code handles them transparently.
+"""
+import csv
+import io
+from pathlib import Path
+
+DB_PATH = Path("data/seismo_fleet.db")
+
+
+def _peek_first_row(abs_path: Path) -> dict:
+    """Read only the header + first data row of an RND file. Very cheap."""
+    try:
+        with open(abs_path, "r", encoding="utf-8", errors="replace") as f:
+            reader = csv.DictReader(f)
+            return next(reader, None) or {}
+    except Exception:
+        return {}
+
+
+def _detect_model_from_rnd(abs_path: Path) -> str | None:
+    """Return 'NL-32' if file uses AU2 column format, else None."""
+    row = _peek_first_row(abs_path)
+    if "LAeq" in row:
+        return "NL-32"
+    return None
+
+
+def migrate():
+    import sqlite3
+
+    if not DB_PATH.exists():
+        print(f"Database not found at {DB_PATH}. Are you running from /home/serversdown/terra-view?")
+        return
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    # ── 1. Add column (idempotent) ───────────────────────────────────────────
+    cur.execute("PRAGMA table_info(monitoring_sessions)")
+    existing_cols = {row["name"] for row in cur.fetchall()}
+
+    if "device_model" not in existing_cols:
+        cur.execute("ALTER TABLE monitoring_sessions ADD COLUMN device_model TEXT")
+        conn.commit()
+        print("✓ Added column device_model to monitoring_sessions")
+    else:
+        print("○ Column device_model already exists — skipping ALTER TABLE")
+
+    # ── 2. Backfill existing NULL rows ───────────────────────────────────────
+    cur.execute(
+        "SELECT id, unit_id FROM monitoring_sessions WHERE device_model IS NULL"
+    )
+    sessions = cur.fetchall()
+    print(f"Backfilling {len(sessions)} session(s) with device_model=NULL...")
+
+    updated = skipped = 0
+    for row in sessions:
+        session_id = row["id"]
+        unit_id = row["unit_id"]
+        device_model = None
+
+        # Strategy A: look up unit's slm_model from the roster
+        if unit_id:
+            cur.execute(
+                "SELECT slm_model FROM roster WHERE id = ?", (unit_id,)
+            )
+            unit_row = cur.fetchone()
+            if unit_row and unit_row["slm_model"]:
+                device_model = unit_row["slm_model"]
+
+        # Strategy B: detect from first .rnd file in the session
+        if device_model is None:
+            cur.execute(
+                """SELECT file_path FROM data_files
+                   WHERE session_id = ?
+                   AND lower(file_path) LIKE '%.rnd'
+                   LIMIT 1""",
+                (session_id,),
+            )
+            file_row = cur.fetchone()
+            if file_row:
+                abs_path = Path("data") / file_row["file_path"]
+                device_model = _detect_model_from_rnd(abs_path)
+                # None here means NL-43/NL-53 format (or unreadable file) —
+                # leave as NULL so the existing fallback applies.
+
+        if device_model:
+            cur.execute(
+                "UPDATE monitoring_sessions SET device_model = ? WHERE id = ?",
+                (device_model, session_id),
+            )
+            updated += 1
+        else:
+            skipped += 1
+
+    conn.commit()
+    conn.close()
+
+    print(f"✓ Backfilled {updated} session(s) with a device_model.")
+    if skipped:
+        print(
+            f"  {skipped} session(s) left as NULL "
+            "(no unit link and no AU2 file hint — NL-43/NL-53 or unknown; "
+            "file-content detection applies at report time)."
+        )
+    print("Migration complete.")
+
+
+if __name__ == "__main__":
+    migrate()

backend/migrate_add_session_period_type.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+Migration: Add session_label and period_type columns to monitoring_sessions.
+
+session_label  - user-editable display name, e.g. "NRL-1 Sun 2/23 Night"
+period_type    - one of: weekday_day | weekday_night | weekend_day | weekend_night
+                 Auto-derived from started_at when NULL.
+
+Period definitions (used in report stats table):
+  weekday_day   Mon-Fri  07:00-22:00  -> Daytime (7AM-10PM)
+  weekday_night Mon-Fri  22:00-07:00  -> Nighttime (10PM-7AM)
+  weekend_day   Sat-Sun  07:00-22:00  -> Daytime (7AM-10PM)
+  weekend_night Sat-Sun  22:00-07:00  -> Nighttime (10PM-7AM)
+
+Run once inside the Docker container:
+    docker exec terra-view python3 backend/migrate_add_session_period_type.py
+"""
+from pathlib import Path
+from datetime import datetime
+
+DB_PATH = Path("data/seismo_fleet.db")
+
+
+def _derive_period_type(started_at_str: str) -> str | None:
+    """Derive period_type from a started_at ISO datetime string."""
+    if not started_at_str:
+        return None
+    try:
+        dt = datetime.fromisoformat(started_at_str)
+    except ValueError:
+        return None
+    is_weekend = dt.weekday() >= 5  # 5=Sat, 6=Sun
+    is_night = dt.hour >= 22 or dt.hour < 7
+    if is_weekend:
+        return "weekend_night" if is_night else "weekend_day"
+    else:
+        return "weekday_night" if is_night else "weekday_day"
+
+
+def _build_label(started_at_str: str, location_name: str | None, period_type: str | None) -> str | None:
+    """Build a human-readable session label."""
+    if not started_at_str:
+        return None
+    try:
+        dt = datetime.fromisoformat(started_at_str)
+    except ValueError:
+        return None
+
+    day_abbr = dt.strftime("%a")   # Mon, Tue, Sun, etc.
+    date_str = dt.strftime("%-m/%-d")  # 2/23
+
+    period_labels = {
+        "weekday_day":   "Day",
+        "weekday_night": "Night",
+        "weekend_day":   "Day",
+        "weekend_night": "Night",
+    }
+    period_str = period_labels.get(period_type or "", "")
+
+    parts = []
+    if location_name:
+        parts.append(location_name)
+    parts.append(f"{day_abbr} {date_str}")
+    if period_str:
+        parts.append(period_str)
+    return " — ".join(parts)
+
+
+def migrate():
+    import sqlite3
+
+    if not DB_PATH.exists():
+        print(f"Database not found at {DB_PATH}. Are you running from /home/serversdown/terra-view?")
+        return
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cur = conn.cursor()
+
+    # 1. Add columns (idempotent)
+    cur.execute("PRAGMA table_info(monitoring_sessions)")
+    existing_cols = {row["name"] for row in cur.fetchall()}
+
+    for col, typedef in [("session_label", "TEXT"), ("period_type", "TEXT")]:
+        if col not in existing_cols:
+            cur.execute(f"ALTER TABLE monitoring_sessions ADD COLUMN {col} {typedef}")
+            conn.commit()
+            print(f"✓ Added column {col} to monitoring_sessions")
+        else:
+            print(f"○ Column {col} already exists — skipping ALTER TABLE")
+
+    # 2. Backfill existing rows
+    cur.execute(
+        """SELECT ms.id, ms.started_at, ms.location_id
+           FROM monitoring_sessions ms
+           WHERE ms.period_type IS NULL OR ms.session_label IS NULL"""
+    )
+    sessions = cur.fetchall()
+    print(f"Backfilling {len(sessions)} session(s)...")
+
+    updated = 0
+    for row in sessions:
+        session_id = row["id"]
+        started_at = row["started_at"]
+        location_id = row["location_id"]
+
+        # Look up location name
+        location_name = None
+        if location_id:
+            cur.execute("SELECT name FROM monitoring_locations WHERE id = ?", (location_id,))
+            loc_row = cur.fetchone()
+            if loc_row:
+                location_name = loc_row["name"]
+
+        period_type = _derive_period_type(started_at)
+        label = _build_label(started_at, location_name, period_type)
+
+        cur.execute(
+            "UPDATE monitoring_sessions SET period_type = ?, session_label = ? WHERE id = ?",
+            (period_type, label, session_id),
+        )
+        updated += 1
+
+    conn.commit()
+    conn.close()
+    print(f"✓ Backfilled {updated} session(s).")
+    print("Migration complete.")
+
+
+if __name__ == "__main__":
+    migrate()

backend/migrate_add_slm_fields.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+"""
+Database migration: Add sound level meter fields to roster table.
+
+Adds columns for sound_level_meter device type support.
+"""
+
+import sqlite3
+from pathlib import Path
+
+def migrate():
+    """Add SLM fields to roster table if they don't exist."""
+
+    # Try multiple possible database locations
+    possible_paths = [
+        Path("data/seismo_fleet.db"),
+        Path("data/sfm.db"),
+        Path("data/seismo.db"),
+    ]
+
+    db_path = None
+    for path in possible_paths:
+        if path.exists():
+            db_path = path
+            break
+
+    if db_path is None:
+        print(f"Database not found in any of: {[str(p) for p in possible_paths]}")
+        print("Creating database with models.py will include new fields automatically.")
+        return
+
+    print(f"Using database: {db_path}")
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    # Check if columns already exist
+    cursor.execute("PRAGMA table_info(roster)")
+    existing_columns = {row[1] for row in cursor.fetchall()}
+
+    new_columns = {
+        "slm_host": "TEXT",
+        "slm_tcp_port": "INTEGER",
+        "slm_model": "TEXT",
+        "slm_serial_number": "TEXT",
+        "slm_frequency_weighting": "TEXT",
+        "slm_time_weighting": "TEXT",
+        "slm_measurement_range": "TEXT",
+        "slm_last_check": "DATETIME",
+    }
+
+    migrations_applied = []
+
+    for column_name, column_type in new_columns.items():
+        if column_name not in existing_columns:
+            try:
+                cursor.execute(f"ALTER TABLE roster ADD COLUMN {column_name} {column_type}")
+                migrations_applied.append(column_name)
+                print(f"✓ Added column: {column_name} ({column_type})")
+            except sqlite3.OperationalError as e:
+                print(f"✗ Failed to add column {column_name}: {e}")
+        else:
+            print(f"○ Column already exists: {column_name}")
+
+    conn.commit()
+    conn.close()
+
+    if migrations_applied:
+        print(f"\n✓ Migration complete! Added {len(migrations_applied)} new columns.")
+    else:
+        print("\n○ No migration needed - all columns already exist.")
+
+    print("\nSound level meter fields are now available in the roster table.")
+    print("Note: Use device_type='slm' for Sound Level Meters. Legacy 'sound_level_meter' has been deprecated.")
+
+
+if __name__ == "__main__":
+    migrate()

backend/migrate_add_tbd_dates.py

@@ -0,0 +1,89 @@
+"""
+Migration: Add TBD date support to job reservations
+
+Adds columns:
+- job_reservations.estimated_end_date: For planning when end is TBD
+- job_reservations.end_date_tbd: Boolean flag for TBD end dates
+- job_reservation_units.unit_start_date: Unit-specific start (for swaps)
+- job_reservation_units.unit_end_date: Unit-specific end (for swaps)
+- job_reservation_units.unit_end_tbd: Unit-specific TBD flag
+- job_reservation_units.notes: Notes for the assignment
+
+Also makes job_reservations.end_date nullable.
+"""
+
+import sqlite3
+import sys
+from pathlib import Path
+
+def migrate(db_path: str):
+    """Run the migration."""
+    print(f"Migrating database: {db_path}")
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    try:
+        # Check if job_reservations table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='job_reservations'")
+        if not cursor.fetchone():
+            print("job_reservations table does not exist. Skipping migration.")
+            return
+
+        # Get existing columns in job_reservations
+        cursor.execute("PRAGMA table_info(job_reservations)")
+        existing_cols = {row[1] for row in cursor.fetchall()}
+
+        # Add new columns to job_reservations if they don't exist
+        if 'estimated_end_date' not in existing_cols:
+            print("Adding estimated_end_date column to job_reservations...")
+            cursor.execute("ALTER TABLE job_reservations ADD COLUMN estimated_end_date DATE")
+
+        if 'end_date_tbd' not in existing_cols:
+            print("Adding end_date_tbd column to job_reservations...")
+            cursor.execute("ALTER TABLE job_reservations ADD COLUMN end_date_tbd BOOLEAN DEFAULT 0")
+
+        # Get existing columns in job_reservation_units
+        cursor.execute("PRAGMA table_info(job_reservation_units)")
+        unit_cols = {row[1] for row in cursor.fetchall()}
+
+        # Add new columns to job_reservation_units if they don't exist
+        if 'unit_start_date' not in unit_cols:
+            print("Adding unit_start_date column to job_reservation_units...")
+            cursor.execute("ALTER TABLE job_reservation_units ADD COLUMN unit_start_date DATE")
+
+        if 'unit_end_date' not in unit_cols:
+            print("Adding unit_end_date column to job_reservation_units...")
+            cursor.execute("ALTER TABLE job_reservation_units ADD COLUMN unit_end_date DATE")
+
+        if 'unit_end_tbd' not in unit_cols:
+            print("Adding unit_end_tbd column to job_reservation_units...")
+            cursor.execute("ALTER TABLE job_reservation_units ADD COLUMN unit_end_tbd BOOLEAN DEFAULT 0")
+
+        if 'notes' not in unit_cols:
+            print("Adding notes column to job_reservation_units...")
+            cursor.execute("ALTER TABLE job_reservation_units ADD COLUMN notes TEXT")
+
+        conn.commit()
+        print("Migration completed successfully!")
+
+    except Exception as e:
+        print(f"Migration failed: {e}")
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    # Default to dev database
+    db_path = "./data-dev/seismo_fleet.db"
+
+    if len(sys.argv) > 1:
+        db_path = sys.argv[1]
+
+    if not Path(db_path).exists():
+        print(f"Database not found: {db_path}")
+        sys.exit(1)
+
+    migrate(db_path)

backend/migrate_add_unit_history.py

@@ -0,0 +1,78 @@
+"""
+Migration script to add unit history timeline support.
+
+This creates the unit_history table to track all changes to units:
+- Note changes (archived old notes, new notes)
+- Deployment status changes (deployed/benched)
+- Retired status changes
+- Other field changes
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+def migrate_database():
+    """Create the unit_history table"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if unit_history table already exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='unit_history'")
+    if cursor.fetchone():
+        print("Migration already applied - unit_history table exists")
+        conn.close()
+        return
+
+    print("Creating unit_history table...")
+
+    try:
+        cursor.execute("""
+            CREATE TABLE unit_history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                unit_id TEXT NOT NULL,
+                change_type TEXT NOT NULL,
+                field_name TEXT,
+                old_value TEXT,
+                new_value TEXT,
+                changed_at TIMESTAMP NOT NULL,
+                source TEXT DEFAULT 'manual',
+                notes TEXT
+            )
+        """)
+        print("  ✓ Created unit_history table")
+
+        # Create indexes for better query performance
+        cursor.execute("CREATE INDEX idx_unit_history_unit_id ON unit_history(unit_id)")
+        print("  ✓ Created index on unit_id")
+
+        cursor.execute("CREATE INDEX idx_unit_history_changed_at ON unit_history(changed_at)")
+        print("  ✓ Created index on changed_at")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+        print("Units will now track their complete history of changes.")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_add_user_preferences.py

@@ -0,0 +1,80 @@
+"""
+Migration script to add user_preferences table.
+
+This creates a new table for storing persistent user preferences:
+- Display settings (timezone, theme, date format)
+- Auto-refresh configuration
+- Calibration defaults
+- Status threshold customization
+
+Run this script once to migrate an existing database.
+"""
+
+import sqlite3
+import os
+
+# Database path
+DB_PATH = "./data/seismo_fleet.db"
+
+def migrate_database():
+    """Create user_preferences table"""
+
+    if not os.path.exists(DB_PATH):
+        print(f"Database not found at {DB_PATH}")
+        print("The database will be created automatically when you run the application.")
+        return
+
+    print(f"Migrating database: {DB_PATH}")
+
+    conn = sqlite3.connect(DB_PATH)
+    cursor = conn.cursor()
+
+    # Check if user_preferences table already exists
+    cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='user_preferences'")
+    table_exists = cursor.fetchone()
+
+    if table_exists:
+        print("Migration already applied - user_preferences table exists")
+        conn.close()
+        return
+
+    print("Creating user_preferences table...")
+
+    try:
+        cursor.execute("""
+            CREATE TABLE user_preferences (
+                id INTEGER PRIMARY KEY DEFAULT 1,
+                timezone TEXT DEFAULT 'America/New_York',
+                theme TEXT DEFAULT 'auto',
+                auto_refresh_interval INTEGER DEFAULT 10,
+                date_format TEXT DEFAULT 'MM/DD/YYYY',
+                table_rows_per_page INTEGER DEFAULT 25,
+                calibration_interval_days INTEGER DEFAULT 365,
+                calibration_warning_days INTEGER DEFAULT 30,
+                status_ok_threshold_hours INTEGER DEFAULT 12,
+                status_pending_threshold_hours INTEGER DEFAULT 24,
+                updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        """)
+        print("  ✓ Created user_preferences table")
+
+        # Insert default preferences
+        cursor.execute("""
+            INSERT INTO user_preferences (id) VALUES (1)
+        """)
+        print("  ✓ Inserted default preferences")
+
+        conn.commit()
+        print("\nMigration completed successfully!")
+
+    except sqlite3.Error as e:
+        print(f"\nError during migration: {e}")
+        conn.rollback()
+        raise
+
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    migrate_database()

backend/migrate_fix_end_date_nullable.py

@@ -0,0 +1,105 @@
+"""
+Migration: Make job_reservations.end_date nullable for TBD support
+
+SQLite doesn't support ALTER COLUMN, so we need to:
+1. Create a new table with the correct schema
+2. Copy data
+3. Drop old table
+4. Rename new table
+"""
+
+import sqlite3
+import sys
+from pathlib import Path
+
+def migrate(db_path: str):
+    """Run the migration."""
+    print(f"Migrating database: {db_path}")
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    try:
+        # Check if job_reservations table exists
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='job_reservations'")
+        if not cursor.fetchone():
+            print("job_reservations table does not exist. Skipping migration.")
+            return
+
+        # Check current schema
+        cursor.execute("PRAGMA table_info(job_reservations)")
+        columns = cursor.fetchall()
+        col_info = {row[1]: row for row in columns}
+
+        # Check if end_date is already nullable (notnull=0)
+        if 'end_date' in col_info and col_info['end_date'][3] == 0:
+            print("end_date is already nullable. Skipping table recreation.")
+            return
+
+        print("Recreating job_reservations table with nullable end_date...")
+
+        # Create new table with correct schema
+        cursor.execute("""
+            CREATE TABLE job_reservations_new (
+                id TEXT PRIMARY KEY,
+                name TEXT NOT NULL,
+                project_id TEXT,
+                start_date DATE NOT NULL,
+                end_date DATE,
+                estimated_end_date DATE,
+                end_date_tbd BOOLEAN DEFAULT 0,
+                assignment_type TEXT NOT NULL DEFAULT 'quantity',
+                device_type TEXT DEFAULT 'seismograph',
+                quantity_needed INTEGER,
+                notes TEXT,
+                color TEXT DEFAULT '#3B82F6',
+                created_at DATETIME,
+                updated_at DATETIME
+            )
+        """)
+
+        # Copy existing data
+        cursor.execute("""
+            INSERT INTO job_reservations_new
+            SELECT
+                id, name, project_id, start_date, end_date,
+                COALESCE(estimated_end_date, NULL) as estimated_end_date,
+                COALESCE(end_date_tbd, 0) as end_date_tbd,
+                assignment_type, device_type, quantity_needed, notes, color,
+                created_at, updated_at
+            FROM job_reservations
+        """)
+
+        # Drop old table
+        cursor.execute("DROP TABLE job_reservations")
+
+        # Rename new table
+        cursor.execute("ALTER TABLE job_reservations_new RENAME TO job_reservations")
+
+        # Recreate index
+        cursor.execute("CREATE INDEX IF NOT EXISTS ix_job_reservations_id ON job_reservations (id)")
+        cursor.execute("CREATE INDEX IF NOT EXISTS ix_job_reservations_project_id ON job_reservations (project_id)")
+
+        conn.commit()
+        print("Migration completed successfully!")
+
+    except Exception as e:
+        print(f"Migration failed: {e}")
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    # Default to dev database
+    db_path = "./data-dev/seismo_fleet.db"
+
+    if len(sys.argv) > 1:
+        db_path = sys.argv[1]
+
+    if not Path(db_path).exists():
+        print(f"Database not found: {db_path}")
+        sys.exit(1)
+
+    migrate(db_path)

backend/migrate_rename_recording_to_monitoring_sessions.py

@@ -0,0 +1,54 @@
+"""
+Migration: Rename recording_sessions table to monitoring_sessions
+
+Renames the table and updates the model name from RecordingSession to MonitoringSession.
+Run once per database: python backend/migrate_rename_recording_to_monitoring_sessions.py
+"""
+
+import sqlite3
+import sys
+from pathlib import Path
+
+
+def migrate(db_path: str):
+    """Run the migration."""
+    print(f"Migrating database: {db_path}")
+
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    try:
+        cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='recording_sessions'")
+        if not cursor.fetchone():
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='monitoring_sessions'")
+            if cursor.fetchone():
+                print("monitoring_sessions table already exists. Skipping migration.")
+            else:
+                print("recording_sessions table does not exist. Skipping migration.")
+            return
+
+        print("Renaming recording_sessions -> monitoring_sessions...")
+        cursor.execute("ALTER TABLE recording_sessions RENAME TO monitoring_sessions")
+
+        conn.commit()
+        print("Migration completed successfully!")
+
+    except Exception as e:
+        print(f"Migration failed: {e}")
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+if __name__ == "__main__":
+    db_path = "./data/terra-view.db"
+
+    if len(sys.argv) > 1:
+        db_path = sys.argv[1]
+
+    if not Path(db_path).exists():
+        print(f"Database not found: {db_path}")
+        sys.exit(1)
+
+    migrate(db_path)

backend/migrate_standardize_device_types.py

@@ -0,0 +1,106 @@
+"""
+Database Migration: Standardize device_type values
+
+This migration ensures all device_type values follow the official schema:
+- "seismograph" - Seismic monitoring devices
+- "modem" - Field modems and network equipment
+- "slm" - Sound level meters (NL-43/NL-53)
+
+Changes:
+- Converts "sound_level_meter" → "slm"
+- Safe to run multiple times (idempotent)
+- No data loss
+
+Usage:
+    python backend/migrate_standardize_device_types.py
+"""
+
+import sys
+import os
+
+# Add parent directory to path so we can import backend modules
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from sqlalchemy import create_engine, text
+from sqlalchemy.orm import sessionmaker
+
+# Database configuration
+SQLALCHEMY_DATABASE_URL = "sqlite:///./data/seismo_fleet.db"
+engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def migrate():
+    """Standardize device_type values in the database"""
+    db = SessionLocal()
+
+    try:
+        print("=" * 70)
+        print("Database Migration: Standardize device_type values")
+        print("=" * 70)
+        print()
+
+        # Check for existing "sound_level_meter" values
+        result = db.execute(
+            text("SELECT COUNT(*) as count FROM roster WHERE device_type = 'sound_level_meter'")
+        ).fetchone()
+
+        count_to_migrate = result[0] if result else 0
+
+        if count_to_migrate == 0:
+            print("✓ No records need migration - all device_type values are already standardized")
+            print()
+            print("Current device_type distribution:")
+
+            # Show distribution
+            distribution = db.execute(
+                text("SELECT device_type, COUNT(*) as count FROM roster GROUP BY device_type ORDER BY count DESC")
+            ).fetchall()
+
+            for row in distribution:
+                device_type, count = row
+                print(f"  - {device_type}: {count} units")
+
+            print()
+            print("Migration not needed.")
+            return
+
+        print(f"Found {count_to_migrate} record(s) with device_type='sound_level_meter'")
+        print()
+        print("Converting 'sound_level_meter' → 'slm'...")
+
+        # Perform the migration
+        db.execute(
+            text("UPDATE roster SET device_type = 'slm' WHERE device_type = 'sound_level_meter'")
+        )
+        db.commit()
+
+        print(f"✓ Successfully migrated {count_to_migrate} record(s)")
+        print()
+
+        # Show final distribution
+        print("Updated device_type distribution:")
+        distribution = db.execute(
+            text("SELECT device_type, COUNT(*) as count FROM roster GROUP BY device_type ORDER BY count DESC")
+        ).fetchall()
+
+        for row in distribution:
+            device_type, count = row
+            print(f"  - {device_type}: {count} units")
+
+        print()
+        print("=" * 70)
+        print("Migration completed successfully!")
+        print("=" * 70)
+
+    except Exception as e:
+        db.rollback()
+        print(f"\n❌ Error during migration: {e}")
+        print("\nRolling back changes...")
+        raise
+    finally:
+        db.close()
+
+
+if __name__ == "__main__":
+    migrate()

backend/models.py

@@ -0,0 +1,496 @@
+from sqlalchemy import Column, String, DateTime, Boolean, Text, Date, Integer
+from datetime import datetime
+from backend.database import Base
+
+
+class Emitter(Base):
+    __tablename__ = "emitters"
+
+    id = Column(String, primary_key=True, index=True)
+    unit_type = Column(String, nullable=False)
+    last_seen = Column(DateTime, default=datetime.utcnow)
+    last_file = Column(String, nullable=False)
+    status = Column(String, nullable=False)
+    notes = Column(String, nullable=True)
+
+
+class RosterUnit(Base):
+    """
+    Roster table: represents our *intended assignment* of a unit.
+    This is editable from the GUI.
+
+    Supports multiple device types with type-specific fields:
+    - "seismograph" - Seismic monitoring devices (default)
+    - "modem" - Field modems and network equipment
+    - "slm" - Sound level meters (NL-43/NL-53)
+    """
+    __tablename__ = "roster"
+
+    # Core fields (all device types)
+    id = Column(String, primary_key=True, index=True)
+    unit_type = Column(String, default="series3")  # Backward compatibility
+    device_type = Column(String, default="seismograph")  # "seismograph" | "modem" | "slm"
+    deployed = Column(Boolean, default=True)
+    retired = Column(Boolean, default=False)
+    note = Column(String, nullable=True)
+    project_id = Column(String, nullable=True)
+    location = Column(String, nullable=True)  # Legacy field - use address/coordinates instead
+    address = Column(String, nullable=True)  # Human-readable address
+    coordinates = Column(String, nullable=True)  # Lat,Lon format: "34.0522,-118.2437"
+    last_updated = Column(DateTime, default=datetime.utcnow)
+
+    # Seismograph-specific fields (nullable for modems and SLMs)
+    last_calibrated = Column(Date, nullable=True)
+    next_calibration_due = Column(Date, nullable=True)
+
+    # Modem assignment (shared by seismographs and SLMs)
+    deployed_with_modem_id = Column(String, nullable=True)  # FK to another RosterUnit (device_type=modem)
+
+    # Modem-specific fields (nullable for seismographs and SLMs)
+    ip_address = Column(String, nullable=True)
+    phone_number = Column(String, nullable=True)
+    hardware_model = Column(String, nullable=True)
+    deployment_type = Column(String, nullable=True)  # "seismograph" | "slm" - what type of device this modem is deployed with
+    deployed_with_unit_id = Column(String, nullable=True)  # ID of seismograph/SLM this modem is deployed with
+
+    # Sound Level Meter-specific fields (nullable for seismographs and modems)
+    slm_host = Column(String, nullable=True)  # Device IP or hostname
+    slm_tcp_port = Column(Integer, nullable=True)  # TCP control port (default 2255)
+    slm_ftp_port = Column(Integer, nullable=True)  # FTP data retrieval port (default 21)
+    slm_model = Column(String, nullable=True)  # NL-43, NL-53, etc.
+    slm_serial_number = Column(String, nullable=True)  # Device serial number
+    slm_frequency_weighting = Column(String, nullable=True)  # A, C, Z
+    slm_time_weighting = Column(String, nullable=True)  # F (Fast), S (Slow), I (Impulse)
+    slm_measurement_range = Column(String, nullable=True)  # e.g., "30-130 dB"
+    slm_last_check = Column(DateTime, nullable=True)  # Last communication check
+
+
+class IgnoredUnit(Base):
+    """
+    Ignored units: units that report but should be filtered out from unknown emitters.
+    Used to suppress noise from old projects.
+    """
+    __tablename__ = "ignored_units"
+
+    id = Column(String, primary_key=True, index=True)
+    reason = Column(String, nullable=True)
+    ignored_at = Column(DateTime, default=datetime.utcnow)
+
+
+class UnitHistory(Base):
+    """
+    Unit history: complete timeline of changes to each unit.
+    Tracks note changes, status changes, deployment/benched events, and more.
+    """
+    __tablename__ = "unit_history"
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    unit_id = Column(String, nullable=False, index=True)  # FK to RosterUnit.id
+    change_type = Column(String, nullable=False)  # note_change, deployed_change, retired_change, etc.
+    field_name = Column(String, nullable=True)  # Which field changed
+    old_value = Column(Text, nullable=True)  # Previous value
+    new_value = Column(Text, nullable=True)  # New value
+    changed_at = Column(DateTime, default=datetime.utcnow, nullable=False, index=True)
+    source = Column(String, default="manual")  # manual, csv_import, telemetry, offline_sync
+    notes = Column(Text, nullable=True)  # Optional reason/context for the change
+
+
+class UserPreferences(Base):
+    """
+    User preferences: persistent storage for application settings.
+    Single-row table (id=1) to store global user preferences.
+    """
+    __tablename__ = "user_preferences"
+
+    id = Column(Integer, primary_key=True, default=1)
+    timezone = Column(String, default="America/New_York")
+    theme = Column(String, default="auto")  # auto, light, dark
+    auto_refresh_interval = Column(Integer, default=10)  # seconds
+    date_format = Column(String, default="MM/DD/YYYY")
+    table_rows_per_page = Column(Integer, default=25)
+    calibration_interval_days = Column(Integer, default=365)
+    calibration_warning_days = Column(Integer, default=30)
+    status_ok_threshold_hours = Column(Integer, default=12)
+    status_pending_threshold_hours = Column(Integer, default=24)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+# ============================================================================
+# Project Management System
+# ============================================================================
+
+class ProjectType(Base):
+    """
+    Project type templates: defines available project types and their capabilities.
+    Pre-populated with: sound_monitoring, vibration_monitoring, combined.
+    """
+    __tablename__ = "project_types"
+
+    id = Column(String, primary_key=True)  # sound_monitoring, vibration_monitoring, combined
+    name = Column(String, nullable=False, unique=True)  # "Sound Monitoring", "Vibration Monitoring"
+    description = Column(Text, nullable=True)
+    icon = Column(String, nullable=True)  # Icon identifier for UI
+    supports_sound = Column(Boolean, default=False)  # Enables SLM features
+    supports_vibration = Column(Boolean, default=False)  # Enables seismograph features
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class Project(Base):
+    """
+    Projects: top-level organization for monitoring work.
+    Type-aware to enable/disable features based on project_type_id.
+
+    Project naming convention:
+    - project_number: TMI internal ID format xxxx-YY (e.g., "2567-23")
+    - client_name: Client/contractor name (e.g., "PJ Dick")
+    - name: Project/site name (e.g., "RKM Hall", "CMU Campus")
+
+    Display format: "2567-23 - PJ Dick - RKM Hall"
+    Users can search by any of these fields.
+    """
+    __tablename__ = "projects"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    project_number = Column(String, nullable=True, index=True)  # TMI ID: xxxx-YY format (e.g., "2567-23")
+    name = Column(String, nullable=False, unique=True)  # Project/site name (e.g., "RKM Hall")
+    description = Column(Text, nullable=True)
+    project_type_id = Column(String, nullable=False)  # FK to ProjectType.id
+    status = Column(String, default="active")  # active, on_hold, completed, archived, deleted
+
+    # Data collection mode: how field data reaches Terra-View.
+    # "remote"  — units have modems; data pulled via FTP/scheduler automatically
+    # "manual"  — no modem; SD cards retrieved daily and uploaded by hand
+    data_collection_mode = Column(String, default="manual")  # remote | manual
+
+    # Project metadata
+    client_name = Column(String, nullable=True, index=True)  # Client name (e.g., "PJ Dick")
+    site_address = Column(String, nullable=True)
+    site_coordinates = Column(String, nullable=True)  # "lat,lon"
+    start_date = Column(Date, nullable=True)
+    end_date = Column(Date, nullable=True)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    deleted_at = Column(DateTime, nullable=True)  # Set when status='deleted'; hard delete scheduled after 60 days
+
+
+class MonitoringLocation(Base):
+    """
+    Monitoring locations: generic location for monitoring activities.
+    Can be NRL (Noise Recording Location) for sound projects,
+    or monitoring point for vibration projects.
+    """
+    __tablename__ = "monitoring_locations"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    project_id = Column(String, nullable=False, index=True)  # FK to Project.id
+    location_type = Column(String, nullable=False)  # "sound" | "vibration"
+
+    name = Column(String, nullable=False)  # NRL-001, VP-North, etc.
+    description = Column(Text, nullable=True)
+    coordinates = Column(String, nullable=True)  # "lat,lon"
+    address = Column(String, nullable=True)
+
+    # Type-specific metadata stored as JSON
+    # For sound: {"ambient_conditions": "urban", "expected_sources": ["traffic"]}
+    # For vibration: {"ground_type": "bedrock", "depth": "10m"}
+    location_metadata = Column(Text, nullable=True)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class UnitAssignment(Base):
+    """
+    Unit assignments: links devices (SLMs or seismographs) to monitoring locations.
+    Supports temporary assignments with assigned_until.
+    """
+    __tablename__ = "unit_assignments"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    unit_id = Column(String, nullable=False, index=True)  # FK to RosterUnit.id
+    location_id = Column(String, nullable=False, index=True)  # FK to MonitoringLocation.id
+
+    assigned_at = Column(DateTime, default=datetime.utcnow)
+    assigned_until = Column(DateTime, nullable=True)  # Null = indefinite
+    status = Column(String, default="active")  # active, completed, cancelled
+    notes = Column(Text, nullable=True)
+
+    # Denormalized for efficient queries
+    device_type = Column(String, nullable=False)  # "slm" | "seismograph"
+    project_id = Column(String, nullable=False, index=True)  # FK to Project.id
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class ScheduledAction(Base):
+    """
+    Scheduled actions: automation for recording start/stop/download.
+    Terra-View executes these by calling SLMM or SFM endpoints.
+    """
+    __tablename__ = "scheduled_actions"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    project_id = Column(String, nullable=False, index=True)  # FK to Project.id
+    location_id = Column(String, nullable=False, index=True)  # FK to MonitoringLocation.id
+    unit_id = Column(String, nullable=True, index=True)  # FK to RosterUnit.id (nullable if location-based)
+
+    action_type = Column(String, nullable=False)  # start, stop, download, cycle, calibrate
+    device_type = Column(String, nullable=False)  # "slm" | "seismograph"
+
+    scheduled_time = Column(DateTime, nullable=False, index=True)
+    executed_at = Column(DateTime, nullable=True)
+    execution_status = Column(String, default="pending")  # pending, completed, failed, cancelled
+
+    # Response from device module (SLMM or SFM)
+    module_response = Column(Text, nullable=True)  # JSON
+    error_message = Column(Text, nullable=True)
+
+    notes = Column(Text, nullable=True)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class MonitoringSession(Base):
+    """
+    Monitoring sessions: tracks actual monitoring sessions.
+    Created when monitoring starts, updated when it stops.
+    """
+    __tablename__ = "monitoring_sessions"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    project_id = Column(String, nullable=False, index=True)  # FK to Project.id
+    location_id = Column(String, nullable=False, index=True)  # FK to MonitoringLocation.id
+    unit_id = Column(String, nullable=True, index=True)  # FK to RosterUnit.id (nullable for offline uploads)
+
+    # Physical device model that produced this session's data (e.g. "NL-43", "NL-53", "NL-32").
+    # Null for older records; report code falls back to file-content detection when null.
+    device_model = Column(String, nullable=True)
+
+    session_type = Column(String, nullable=False)  # sound | vibration
+    started_at = Column(DateTime, nullable=False)
+    stopped_at = Column(DateTime, nullable=True)
+    duration_seconds = Column(Integer, nullable=True)
+    status = Column(String, default="recording")  # recording, completed, failed
+
+    # Human-readable label auto-derived from date/location, editable by user.
+    # e.g. "NRL-1 — Sun 2/23 — Night"
+    session_label = Column(String, nullable=True)
+
+    # Period classification for report stats columns.
+    # weekday_day | weekday_night | weekend_day | weekend_night
+    period_type = Column(String, nullable=True)
+
+    # Snapshot of device configuration at recording time
+    session_metadata = Column(Text, nullable=True)  # JSON
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class DataFile(Base):
+    """
+    Data files: references to recorded data files.
+    Terra-View tracks file metadata; actual files stored in data/Projects/ directory.
+    """
+    __tablename__ = "data_files"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    session_id = Column(String, nullable=False, index=True)  # FK to MonitoringSession.id
+
+    file_path = Column(String, nullable=False)  # Relative to data/Projects/
+    file_type = Column(String, nullable=False)  # wav, csv, mseed, json
+    file_size_bytes = Column(Integer, nullable=True)
+    downloaded_at = Column(DateTime, nullable=True)
+    checksum = Column(String, nullable=True)  # SHA256 or MD5
+
+    # Additional file metadata
+    file_metadata = Column(Text, nullable=True)  # JSON
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class ReportTemplate(Base):
+    """
+    Report templates: saved configurations for generating Excel reports.
+    Allows users to save time filter presets, titles, etc. for reuse.
+    """
+    __tablename__ = "report_templates"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    name = Column(String, nullable=False)  # "Nighttime Report", "Full Day Report"
+    project_id = Column(String, nullable=True)  # Optional: project-specific template
+
+    # Template settings
+    report_title = Column(String, default="Background Noise Study")
+    start_time = Column(String, nullable=True)  # "19:00" format
+    end_time = Column(String, nullable=True)    # "07:00" format
+    start_date = Column(String, nullable=True)  # "2025-01-15" format (optional)
+    end_date = Column(String, nullable=True)    # "2025-01-20" format (optional)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+# ============================================================================
+# Sound Monitoring Scheduler
+# ============================================================================
+
+class RecurringSchedule(Base):
+    """
+    Recurring schedule definitions for automated sound monitoring.
+
+    Supports three schedule types:
+    - "weekly_calendar": Select specific days with start/end times (e.g., Mon/Wed/Fri 7pm-7am)
+    - "simple_interval": For 24/7 monitoring with daily stop/download/restart cycles
+    - "one_off": Single recording session with specific start and end date/time
+    """
+    __tablename__ = "recurring_schedules"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    project_id = Column(String, nullable=False, index=True)  # FK to Project.id
+    location_id = Column(String, nullable=False, index=True)  # FK to MonitoringLocation.id
+    unit_id = Column(String, nullable=True, index=True)  # FK to RosterUnit.id (optional, can use assignment)
+
+    name = Column(String, nullable=False)  # "Weeknight Monitoring", "24/7 Continuous"
+    schedule_type = Column(String, nullable=False)  # "weekly_calendar" | "simple_interval" | "one_off"
+    device_type = Column(String, nullable=False)  # "slm" | "seismograph"
+
+    # Weekly Calendar fields (schedule_type = "weekly_calendar")
+    # JSON format: {
+    #   "monday": {"enabled": true, "start": "19:00", "end": "07:00"},
+    #   "tuesday": {"enabled": false},
+    #   ...
+    # }
+    weekly_pattern = Column(Text, nullable=True)
+
+    # Simple Interval fields (schedule_type = "simple_interval")
+    interval_type = Column(String, nullable=True)  # "daily" | "hourly"
+    cycle_time = Column(String, nullable=True)  # "00:00" - time to run stop/download/restart
+    include_download = Column(Boolean, default=True)  # Download data before restart
+
+    # One-Off fields (schedule_type = "one_off")
+    start_datetime = Column(DateTime, nullable=True)  # Exact start date+time (stored as UTC)
+    end_datetime = Column(DateTime, nullable=True)    # Exact end date+time (stored as UTC)
+
+    # Automation options (applies to all schedule types)
+    auto_increment_index = Column(Boolean, default=True)  # Auto-increment store/index number before start
+    # When True: prevents "overwrite data?" prompts by using a new index each time
+
+    # Shared configuration
+    enabled = Column(Boolean, default=True)
+    timezone = Column(String, default="America/New_York")
+
+    # Tracking
+    last_generated_at = Column(DateTime, nullable=True)  # When actions were last generated
+    next_occurrence = Column(DateTime, nullable=True)  # Computed next action time
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class Alert(Base):
+    """
+    In-app alerts for device status changes and system events.
+
+    Designed for future expansion to email/webhook notifications.
+    Currently supports:
+    - device_offline: Device became unreachable
+    - device_online: Device came back online
+    - schedule_failed: Scheduled action failed to execute
+    - schedule_completed: Scheduled action completed successfully
+    """
+    __tablename__ = "alerts"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+
+    # Alert classification
+    alert_type = Column(String, nullable=False)  # "device_offline" | "device_online" | "schedule_failed" | "schedule_completed"
+    severity = Column(String, default="warning")  # "info" | "warning" | "critical"
+
+    # Related entities (nullable - may not all apply)
+    project_id = Column(String, nullable=True, index=True)
+    location_id = Column(String, nullable=True, index=True)
+    unit_id = Column(String, nullable=True, index=True)
+    schedule_id = Column(String, nullable=True)  # RecurringSchedule or ScheduledAction id
+
+    # Alert content
+    title = Column(String, nullable=False)  # "NRL-001 Device Offline"
+    message = Column(Text, nullable=True)  # Detailed description
+    alert_metadata = Column(Text, nullable=True)  # JSON: additional context data
+
+    # Status tracking
+    status = Column(String, default="active")  # "active" | "acknowledged" | "resolved" | "dismissed"
+    acknowledged_at = Column(DateTime, nullable=True)
+    resolved_at = Column(DateTime, nullable=True)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    expires_at = Column(DateTime, nullable=True)  # Auto-dismiss after this time
+
+
+# ============================================================================
+# Fleet Calendar & Job Reservations
+# ============================================================================
+
+class JobReservation(Base):
+    """
+    Job reservations: reserve units for future jobs/projects.
+
+    Supports two assignment modes:
+    - "specific": Pick exact units (SN-001, SN-002, etc.)
+    - "quantity": Reserve a number of units (e.g., "need 8 seismographs")
+
+    Used by the Fleet Calendar to visualize unit availability over time.
+    """
+    __tablename__ = "job_reservations"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    name = Column(String, nullable=False)  # "Job A - March deployment"
+    project_id = Column(String, nullable=True, index=True)  # Optional FK to Project
+
+    # Date range for the reservation
+    start_date = Column(Date, nullable=False)
+    end_date = Column(Date, nullable=True)  # Nullable = TBD / ongoing
+    estimated_end_date = Column(Date, nullable=True)  # For planning when end is TBD
+    end_date_tbd = Column(Boolean, default=False)  # True = end date unknown
+
+    # Assignment type: "specific" or "quantity"
+    assignment_type = Column(String, nullable=False, default="quantity")
+
+    # For quantity reservations
+    device_type = Column(String, default="seismograph")  # seismograph | slm
+    quantity_needed = Column(Integer, nullable=True)  # e.g., 8 units
+
+    # Metadata
+    notes = Column(Text, nullable=True)
+    color = Column(String, default="#3B82F6")  # For calendar display (blue default)
+
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+
+class JobReservationUnit(Base):
+    """
+    Links specific units to job reservations.
+
+    Used when:
+    - assignment_type="specific": Units are directly assigned
+    - assignment_type="quantity": Units can be filled in later
+
+    Supports unit swaps: same reservation can have multiple units with
+    different date ranges (e.g., BE17353 Feb-Jun, then BE18438 Jun-Nov).
+    """
+    __tablename__ = "job_reservation_units"
+
+    id = Column(String, primary_key=True, index=True)  # UUID
+    reservation_id = Column(String, nullable=False, index=True)  # FK to JobReservation
+    unit_id = Column(String, nullable=False, index=True)  # FK to RosterUnit
+
+    # Unit-specific date range (for swaps) - defaults to reservation dates if null
+    unit_start_date = Column(Date, nullable=True)  # When this specific unit starts
+    unit_end_date = Column(Date, nullable=True)  # When this unit ends (swap out date)
+    unit_end_tbd = Column(Boolean, default=False)  # True = end unknown (until cal expires or job ends)
+
+    # Track how this assignment was made
+    assignment_source = Column(String, default="specific")  # "specific" | "filled" | "swap"
+    assigned_at = Column(DateTime, default=datetime.utcnow)
+    notes = Column(Text, nullable=True)  # "Replacing BE17353" etc.

backend/routers/activity.py

@@ -4,8 +4,8 @@ from sqlalchemy import desc
 from pathlib import Path
 from datetime import datetime, timedelta, timezone
 from typing import List, Dict, Any
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.models import UnitHistory, Emitter, RosterUnit
+from backend.models import UnitHistory, Emitter, RosterUnit
 
 router = APIRouter(prefix="/api", tags=["activity"])
 

backend/routers/alerts.py

@@ -0,0 +1,326 @@
+"""
+Alerts Router
+
+API endpoints for managing in-app alerts.
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from typing import Optional
+from datetime import datetime, timedelta
+
+from backend.database import get_db
+from backend.models import Alert, RosterUnit
+from backend.services.alert_service import get_alert_service
+from backend.templates_config import templates
+
+router = APIRouter(prefix="/api/alerts", tags=["alerts"])
+
+
+# ============================================================================
+# Alert List and Count
+# ============================================================================
+
+@router.get("/")
+async def list_alerts(
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query(None, description="Filter by status: active, acknowledged, resolved, dismissed"),
+    project_id: Optional[str] = Query(None),
+    unit_id: Optional[str] = Query(None),
+    alert_type: Optional[str] = Query(None, description="Filter by type: device_offline, device_online, schedule_failed"),
+    limit: int = Query(50, le=100),
+    offset: int = Query(0, ge=0),
+):
+    """
+    List alerts with optional filters.
+    """
+    alert_service = get_alert_service(db)
+
+    alerts = alert_service.get_all_alerts(
+        status=status,
+        project_id=project_id,
+        unit_id=unit_id,
+        alert_type=alert_type,
+        limit=limit,
+        offset=offset,
+    )
+
+    return {
+        "alerts": [
+            {
+                "id": a.id,
+                "alert_type": a.alert_type,
+                "severity": a.severity,
+                "title": a.title,
+                "message": a.message,
+                "status": a.status,
+                "unit_id": a.unit_id,
+                "project_id": a.project_id,
+                "location_id": a.location_id,
+                "created_at": a.created_at.isoformat() if a.created_at else None,
+                "acknowledged_at": a.acknowledged_at.isoformat() if a.acknowledged_at else None,
+                "resolved_at": a.resolved_at.isoformat() if a.resolved_at else None,
+            }
+            for a in alerts
+        ],
+        "count": len(alerts),
+        "limit": limit,
+        "offset": offset,
+    }
+
+
+@router.get("/active")
+async def list_active_alerts(
+    db: Session = Depends(get_db),
+    project_id: Optional[str] = Query(None),
+    unit_id: Optional[str] = Query(None),
+    alert_type: Optional[str] = Query(None),
+    min_severity: Optional[str] = Query(None, description="Minimum severity: info, warning, critical"),
+    limit: int = Query(50, le=100),
+):
+    """
+    List only active alerts.
+    """
+    alert_service = get_alert_service(db)
+
+    alerts = alert_service.get_active_alerts(
+        project_id=project_id,
+        unit_id=unit_id,
+        alert_type=alert_type,
+        min_severity=min_severity,
+        limit=limit,
+    )
+
+    return {
+        "alerts": [
+            {
+                "id": a.id,
+                "alert_type": a.alert_type,
+                "severity": a.severity,
+                "title": a.title,
+                "message": a.message,
+                "unit_id": a.unit_id,
+                "project_id": a.project_id,
+                "created_at": a.created_at.isoformat() if a.created_at else None,
+            }
+            for a in alerts
+        ],
+        "count": len(alerts),
+    }
+
+
+@router.get("/active/count")
+async def get_active_alert_count(db: Session = Depends(get_db)):
+    """
+    Get count of active alerts (for navbar badge).
+    """
+    alert_service = get_alert_service(db)
+    count = alert_service.get_active_alert_count()
+    return {"count": count}
+
+
+# ============================================================================
+# Single Alert Operations
+# ============================================================================
+
+@router.get("/{alert_id}")
+async def get_alert(
+    alert_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Get a specific alert.
+    """
+    alert = db.query(Alert).filter_by(id=alert_id).first()
+    if not alert:
+        raise HTTPException(status_code=404, detail="Alert not found")
+
+    # Get related unit info
+    unit = None
+    if alert.unit_id:
+        unit = db.query(RosterUnit).filter_by(id=alert.unit_id).first()
+
+    return {
+        "id": alert.id,
+        "alert_type": alert.alert_type,
+        "severity": alert.severity,
+        "title": alert.title,
+        "message": alert.message,
+        "metadata": alert.alert_metadata,
+        "status": alert.status,
+        "unit_id": alert.unit_id,
+        "unit_name": unit.id if unit else None,
+        "project_id": alert.project_id,
+        "location_id": alert.location_id,
+        "schedule_id": alert.schedule_id,
+        "created_at": alert.created_at.isoformat() if alert.created_at else None,
+        "acknowledged_at": alert.acknowledged_at.isoformat() if alert.acknowledged_at else None,
+        "resolved_at": alert.resolved_at.isoformat() if alert.resolved_at else None,
+        "expires_at": alert.expires_at.isoformat() if alert.expires_at else None,
+    }
+
+
+@router.post("/{alert_id}/acknowledge")
+async def acknowledge_alert(
+    alert_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Mark alert as acknowledged.
+    """
+    alert_service = get_alert_service(db)
+    alert = alert_service.acknowledge_alert(alert_id)
+
+    if not alert:
+        raise HTTPException(status_code=404, detail="Alert not found")
+
+    return {
+        "success": True,
+        "alert_id": alert.id,
+        "status": alert.status,
+    }
+
+
+@router.post("/{alert_id}/dismiss")
+async def dismiss_alert(
+    alert_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Dismiss alert.
+    """
+    alert_service = get_alert_service(db)
+    alert = alert_service.dismiss_alert(alert_id)
+
+    if not alert:
+        raise HTTPException(status_code=404, detail="Alert not found")
+
+    return {
+        "success": True,
+        "alert_id": alert.id,
+        "status": alert.status,
+    }
+
+
+@router.post("/{alert_id}/resolve")
+async def resolve_alert(
+    alert_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Manually resolve an alert.
+    """
+    alert_service = get_alert_service(db)
+    alert = alert_service.resolve_alert(alert_id)
+
+    if not alert:
+        raise HTTPException(status_code=404, detail="Alert not found")
+
+    return {
+        "success": True,
+        "alert_id": alert.id,
+        "status": alert.status,
+    }
+
+
+# ============================================================================
+# HTML Partials for HTMX
+# ============================================================================
+
+@router.get("/partials/dropdown", response_class=HTMLResponse)
+async def get_alert_dropdown(
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Return HTML partial for alert dropdown in navbar.
+    """
+    alert_service = get_alert_service(db)
+    alerts = alert_service.get_active_alerts(limit=10)
+
+    # Calculate relative time for each alert
+    now = datetime.utcnow()
+    alerts_data = []
+    for alert in alerts:
+        delta = now - alert.created_at
+        if delta.days > 0:
+            time_ago = f"{delta.days}d ago"
+        elif delta.seconds >= 3600:
+            time_ago = f"{delta.seconds // 3600}h ago"
+        elif delta.seconds >= 60:
+            time_ago = f"{delta.seconds // 60}m ago"
+        else:
+            time_ago = "just now"
+
+        alerts_data.append({
+            "alert": alert,
+            "time_ago": time_ago,
+        })
+
+    return templates.TemplateResponse("partials/alerts/alert_dropdown.html", {
+        "request": request,
+        "alerts": alerts_data,
+        "total_count": alert_service.get_active_alert_count(),
+    })
+
+
+@router.get("/partials/list", response_class=HTMLResponse)
+async def get_alert_list(
+    request: Request,
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query(None),
+    limit: int = Query(20),
+):
+    """
+    Return HTML partial for alert list page.
+    """
+    alert_service = get_alert_service(db)
+
+    if status:
+        alerts = alert_service.get_all_alerts(status=status, limit=limit)
+    else:
+        alerts = alert_service.get_all_alerts(limit=limit)
+
+    # Calculate relative time for each alert
+    now = datetime.utcnow()
+    alerts_data = []
+    for alert in alerts:
+        delta = now - alert.created_at
+        if delta.days > 0:
+            time_ago = f"{delta.days}d ago"
+        elif delta.seconds >= 3600:
+            time_ago = f"{delta.seconds // 3600}h ago"
+        elif delta.seconds >= 60:
+            time_ago = f"{delta.seconds // 60}m ago"
+        else:
+            time_ago = "just now"
+
+        alerts_data.append({
+            "alert": alert,
+            "time_ago": time_ago,
+        })
+
+    return templates.TemplateResponse("partials/alerts/alert_list.html", {
+        "request": request,
+        "alerts": alerts_data,
+        "status_filter": status,
+    })
+
+
+# ============================================================================
+# Cleanup
+# ============================================================================
+
+@router.post("/cleanup-expired")
+async def cleanup_expired_alerts(db: Session = Depends(get_db)):
+    """
+    Cleanup expired alerts (admin/maintenance endpoint).
+    """
+    alert_service = get_alert_service(db)
+    count = alert_service.cleanup_expired_alerts()
+
+    return {
+        "success": True,
+        "cleaned_up": count,
+    }

backend/routers/dashboard.py

@@ -0,0 +1,106 @@
+from fastapi import APIRouter, Request, Depends
+from sqlalchemy.orm import Session
+from sqlalchemy import and_
+from datetime import datetime, timedelta
+
+from backend.database import get_db
+from backend.models import ScheduledAction, MonitoringLocation, Project
+from backend.services.snapshot import emit_status_snapshot
+from backend.templates_config import templates
+from backend.utils.timezone import utc_to_local, local_to_utc, get_user_timezone
+
+router = APIRouter()
+
+
+@router.get("/dashboard/active")
+def dashboard_active(request: Request):
+    snapshot = emit_status_snapshot()
+    return templates.TemplateResponse(
+        "partials/active_table.html",
+        {"request": request, "units": snapshot["active"]}
+    )
+
+
+@router.get("/dashboard/benched")
+def dashboard_benched(request: Request):
+    snapshot = emit_status_snapshot()
+    return templates.TemplateResponse(
+        "partials/benched_table.html",
+        {"request": request, "units": snapshot["benched"]}
+    )
+
+
+@router.get("/dashboard/todays-actions")
+def dashboard_todays_actions(request: Request, db: Session = Depends(get_db)):
+    """
+    Get today's scheduled actions for the dashboard card.
+    Shows upcoming, completed, and failed actions for today.
+    """
+    import json
+    from zoneinfo import ZoneInfo
+
+    # Get today's date range in local timezone
+    tz = ZoneInfo(get_user_timezone())
+    now_local = datetime.now(tz)
+    today_start_local = now_local.replace(hour=0, minute=0, second=0, microsecond=0)
+    today_end_local = today_start_local + timedelta(days=1)
+
+    # Convert to UTC for database query
+    today_start_utc = today_start_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+    today_end_utc = today_end_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+
+    # Exclude actions from paused/removed projects
+    paused_project_ids = [
+        p.id for p in db.query(Project.id).filter(
+            Project.status.in_(["on_hold", "archived", "deleted"])
+        ).all()
+    ]
+
+    # Query today's actions
+    actions = db.query(ScheduledAction).filter(
+        ScheduledAction.scheduled_time >= today_start_utc,
+        ScheduledAction.scheduled_time < today_end_utc,
+        ScheduledAction.project_id.notin_(paused_project_ids),
+    ).order_by(ScheduledAction.scheduled_time.asc()).all()
+
+    # Enrich with location/project info and parse results
+    enriched_actions = []
+    for action in actions:
+        location = None
+        project = None
+        if action.location_id:
+            location = db.query(MonitoringLocation).filter_by(id=action.location_id).first()
+        if action.project_id:
+            project = db.query(Project).filter_by(id=action.project_id).first()
+
+        # Parse module_response for result details
+        result_data = None
+        if action.module_response:
+            try:
+                result_data = json.loads(action.module_response)
+            except json.JSONDecodeError:
+                pass
+
+        enriched_actions.append({
+            "action": action,
+            "location": location,
+            "project": project,
+            "result": result_data,
+        })
+
+    # Count by status
+    pending_count = sum(1 for a in actions if a.execution_status == "pending")
+    completed_count = sum(1 for a in actions if a.execution_status == "completed")
+    failed_count = sum(1 for a in actions if a.execution_status == "failed")
+
+    return templates.TemplateResponse(
+        "partials/dashboard/todays_actions.html",
+        {
+            "request": request,
+            "actions": enriched_actions,
+            "pending_count": pending_count,
+            "completed_count": completed_count,
+            "failed_count": failed_count,
+            "total_count": len(actions),
+        }
+    )

backend/routers/dashboard_tabs.py

@@ -2,8 +2,8 @@
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.services.snapshot import emit_status_snapshot
+from backend.services.snapshot import emit_status_snapshot
 
 router = APIRouter(prefix="/dashboard", tags=["dashboard-tabs"])
 

backend/routers/fleet_calendar.py

@@ -0,0 +1,610 @@
+"""
+Fleet Calendar Router
+
+API endpoints for the Fleet Calendar feature:
+- Calendar page and data
+- Job reservation CRUD
+- Unit assignment management
+- Availability checking
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from datetime import datetime, date, timedelta
+from typing import Optional, List
+import uuid
+import logging
+
+from backend.database import get_db
+from backend.models import (
+    RosterUnit, JobReservation, JobReservationUnit,
+    UserPreferences, Project
+)
+from backend.templates_config import templates
+from backend.services.fleet_calendar_service import (
+    get_day_summary,
+    get_calendar_year_data,
+    get_rolling_calendar_data,
+    check_calibration_conflicts,
+    get_available_units_for_period,
+    get_calibration_status
+)
+
+router = APIRouter(tags=["fleet-calendar"])
+logger = logging.getLogger(__name__)
+
+
+# ============================================================================
+# Calendar Page
+# ============================================================================
+
+@router.get("/fleet-calendar", response_class=HTMLResponse)
+async def fleet_calendar_page(
+    request: Request,
+    year: Optional[int] = None,
+    month: Optional[int] = None,
+    device_type: str = "seismograph",
+    db: Session = Depends(get_db)
+):
+    """Main Fleet Calendar page with rolling 12-month view."""
+    today = date.today()
+
+    # Default to current month as the start
+    if year is None:
+        year = today.year
+    if month is None:
+        month = today.month
+
+    # Get calendar data for 12 months starting from year/month
+    calendar_data = get_rolling_calendar_data(db, year, month, device_type)
+
+    # Get projects for the reservation form dropdown
+    projects = db.query(Project).filter(
+        Project.status == "active"
+    ).order_by(Project.name).all()
+
+    # Calculate prev/next month navigation
+    prev_year, prev_month = (year - 1, 12) if month == 1 else (year, month - 1)
+    next_year, next_month = (year + 1, 1) if month == 12 else (year, month + 1)
+
+    return templates.TemplateResponse(
+        "fleet_calendar.html",
+        {
+            "request": request,
+            "start_year": year,
+            "start_month": month,
+            "prev_year": prev_year,
+            "prev_month": prev_month,
+            "next_year": next_year,
+            "next_month": next_month,
+            "device_type": device_type,
+            "calendar_data": calendar_data,
+            "projects": projects,
+            "today": today.isoformat()
+        }
+    )
+
+
+# ============================================================================
+# Calendar Data API
+# ============================================================================
+
+@router.get("/api/fleet-calendar/data", response_class=JSONResponse)
+async def get_calendar_data(
+    year: int,
+    device_type: str = "seismograph",
+    db: Session = Depends(get_db)
+):
+    """Get calendar data for a specific year."""
+    return get_calendar_year_data(db, year, device_type)
+
+
+@router.get("/api/fleet-calendar/day/{date_str}", response_class=HTMLResponse)
+async def get_day_detail(
+    request: Request,
+    date_str: str,
+    device_type: str = "seismograph",
+    db: Session = Depends(get_db)
+):
+    """Get detailed view for a specific day (HTMX partial)."""
+    try:
+        check_date = date.fromisoformat(date_str)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYY-MM-DD")
+
+    day_data = get_day_summary(db, check_date, device_type)
+
+    # Get projects for display names
+    projects = {p.id: p for p in db.query(Project).all()}
+
+    return templates.TemplateResponse(
+        "partials/fleet_calendar/day_detail.html",
+        {
+            "request": request,
+            "day_data": day_data,
+            "date_str": date_str,
+            "date_display": check_date.strftime("%B %d, %Y"),
+            "device_type": device_type,
+            "projects": projects
+        }
+    )
+
+
+# ============================================================================
+# Reservation CRUD
+# ============================================================================
+
+@router.post("/api/fleet-calendar/reservations", response_class=JSONResponse)
+async def create_reservation(
+    request: Request,
+    db: Session = Depends(get_db)
+):
+    """Create a new job reservation."""
+    data = await request.json()
+
+    # Validate required fields
+    required = ["name", "start_date", "assignment_type"]
+    for field in required:
+        if field not in data:
+            raise HTTPException(status_code=400, detail=f"Missing required field: {field}")
+
+    # Need either end_date or end_date_tbd
+    end_date_tbd = data.get("end_date_tbd", False)
+    if not end_date_tbd and not data.get("end_date"):
+        raise HTTPException(status_code=400, detail="End date is required unless marked as TBD")
+
+    try:
+        start_date = date.fromisoformat(data["start_date"])
+        end_date = date.fromisoformat(data["end_date"]) if data.get("end_date") else None
+        estimated_end_date = date.fromisoformat(data["estimated_end_date"]) if data.get("estimated_end_date") else None
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYY-MM-DD")
+
+    if end_date and end_date < start_date:
+        raise HTTPException(status_code=400, detail="End date must be after start date")
+
+    if estimated_end_date and estimated_end_date < start_date:
+        raise HTTPException(status_code=400, detail="Estimated end date must be after start date")
+
+    reservation = JobReservation(
+        id=str(uuid.uuid4()),
+        name=data["name"],
+        project_id=data.get("project_id"),
+        start_date=start_date,
+        end_date=end_date,
+        estimated_end_date=estimated_end_date,
+        end_date_tbd=end_date_tbd,
+        assignment_type=data["assignment_type"],
+        device_type=data.get("device_type", "seismograph"),
+        quantity_needed=data.get("quantity_needed"),
+        notes=data.get("notes"),
+        color=data.get("color", "#3B82F6")
+    )
+
+    db.add(reservation)
+
+    # If specific units were provided, assign them
+    if data.get("unit_ids") and data["assignment_type"] == "specific":
+        for unit_id in data["unit_ids"]:
+            assignment = JobReservationUnit(
+                id=str(uuid.uuid4()),
+                reservation_id=reservation.id,
+                unit_id=unit_id,
+                assignment_source="specific"
+            )
+            db.add(assignment)
+
+    db.commit()
+
+    logger.info(f"Created reservation: {reservation.name} ({reservation.id})")
+
+    return {
+        "success": True,
+        "reservation_id": reservation.id,
+        "message": f"Created reservation: {reservation.name}"
+    }
+
+
+@router.get("/api/fleet-calendar/reservations/{reservation_id}", response_class=JSONResponse)
+async def get_reservation(
+    reservation_id: str,
+    db: Session = Depends(get_db)
+):
+    """Get a specific reservation with its assigned units."""
+    reservation = db.query(JobReservation).filter_by(id=reservation_id).first()
+    if not reservation:
+        raise HTTPException(status_code=404, detail="Reservation not found")
+
+    # Get assigned units
+    assignments = db.query(JobReservationUnit).filter_by(
+        reservation_id=reservation_id
+    ).all()
+
+    unit_ids = [a.unit_id for a in assignments]
+    units = db.query(RosterUnit).filter(RosterUnit.id.in_(unit_ids)).all() if unit_ids else []
+
+    return {
+        "id": reservation.id,
+        "name": reservation.name,
+        "project_id": reservation.project_id,
+        "start_date": reservation.start_date.isoformat(),
+        "end_date": reservation.end_date.isoformat() if reservation.end_date else None,
+        "estimated_end_date": reservation.estimated_end_date.isoformat() if reservation.estimated_end_date else None,
+        "end_date_tbd": reservation.end_date_tbd,
+        "assignment_type": reservation.assignment_type,
+        "device_type": reservation.device_type,
+        "quantity_needed": reservation.quantity_needed,
+        "notes": reservation.notes,
+        "color": reservation.color,
+        "assigned_units": [
+            {
+                "id": u.id,
+                "last_calibrated": u.last_calibrated.isoformat() if u.last_calibrated else None,
+                "deployed": u.deployed
+            }
+            for u in units
+        ]
+    }
+
+
+@router.put("/api/fleet-calendar/reservations/{reservation_id}", response_class=JSONResponse)
+async def update_reservation(
+    reservation_id: str,
+    request: Request,
+    db: Session = Depends(get_db)
+):
+    """Update an existing reservation."""
+    reservation = db.query(JobReservation).filter_by(id=reservation_id).first()
+    if not reservation:
+        raise HTTPException(status_code=404, detail="Reservation not found")
+
+    data = await request.json()
+
+    # Update fields if provided
+    if "name" in data:
+        reservation.name = data["name"]
+    if "project_id" in data:
+        reservation.project_id = data["project_id"]
+    if "start_date" in data:
+        reservation.start_date = date.fromisoformat(data["start_date"])
+    if "end_date" in data:
+        reservation.end_date = date.fromisoformat(data["end_date"]) if data["end_date"] else None
+    if "estimated_end_date" in data:
+        reservation.estimated_end_date = date.fromisoformat(data["estimated_end_date"]) if data["estimated_end_date"] else None
+    if "end_date_tbd" in data:
+        reservation.end_date_tbd = data["end_date_tbd"]
+    if "assignment_type" in data:
+        reservation.assignment_type = data["assignment_type"]
+    if "quantity_needed" in data:
+        reservation.quantity_needed = data["quantity_needed"]
+    if "notes" in data:
+        reservation.notes = data["notes"]
+    if "color" in data:
+        reservation.color = data["color"]
+
+    reservation.updated_at = datetime.utcnow()
+
+    db.commit()
+
+    logger.info(f"Updated reservation: {reservation.name} ({reservation.id})")
+
+    return {
+        "success": True,
+        "message": f"Updated reservation: {reservation.name}"
+    }
+
+
+@router.delete("/api/fleet-calendar/reservations/{reservation_id}", response_class=JSONResponse)
+async def delete_reservation(
+    reservation_id: str,
+    db: Session = Depends(get_db)
+):
+    """Delete a reservation and its unit assignments."""
+    reservation = db.query(JobReservation).filter_by(id=reservation_id).first()
+    if not reservation:
+        raise HTTPException(status_code=404, detail="Reservation not found")
+
+    # Delete unit assignments first
+    db.query(JobReservationUnit).filter_by(reservation_id=reservation_id).delete()
+
+    # Delete the reservation
+    db.delete(reservation)
+    db.commit()
+
+    logger.info(f"Deleted reservation: {reservation.name} ({reservation_id})")
+
+    return {
+        "success": True,
+        "message": "Reservation deleted"
+    }
+
+
+# ============================================================================
+# Unit Assignment
+# ============================================================================
+
+@router.post("/api/fleet-calendar/reservations/{reservation_id}/assign-units", response_class=JSONResponse)
+async def assign_units_to_reservation(
+    reservation_id: str,
+    request: Request,
+    db: Session = Depends(get_db)
+):
+    """Assign specific units to a reservation."""
+    reservation = db.query(JobReservation).filter_by(id=reservation_id).first()
+    if not reservation:
+        raise HTTPException(status_code=404, detail="Reservation not found")
+
+    data = await request.json()
+    unit_ids = data.get("unit_ids", [])
+
+    if not unit_ids:
+        raise HTTPException(status_code=400, detail="No units specified")
+
+    # Verify units exist
+    units = db.query(RosterUnit).filter(RosterUnit.id.in_(unit_ids)).all()
+    found_ids = {u.id for u in units}
+    missing = set(unit_ids) - found_ids
+    if missing:
+        raise HTTPException(status_code=404, detail=f"Units not found: {', '.join(missing)}")
+
+    # Check for conflicts (already assigned to overlapping reservations)
+    conflicts = []
+    for unit_id in unit_ids:
+        # Check if unit is already assigned to this reservation
+        existing = db.query(JobReservationUnit).filter_by(
+            reservation_id=reservation_id,
+            unit_id=unit_id
+        ).first()
+        if existing:
+            continue  # Already assigned, skip
+
+        # Check overlapping reservations
+        overlapping = db.query(JobReservation).join(
+            JobReservationUnit, JobReservation.id == JobReservationUnit.reservation_id
+        ).filter(
+            JobReservationUnit.unit_id == unit_id,
+            JobReservation.id != reservation_id,
+            JobReservation.start_date <= reservation.end_date,
+            JobReservation.end_date >= reservation.start_date
+        ).first()
+
+        if overlapping:
+            conflicts.append({
+                "unit_id": unit_id,
+                "conflict_reservation": overlapping.name,
+                "conflict_dates": f"{overlapping.start_date} - {overlapping.end_date}"
+            })
+            continue
+
+        # Add assignment
+        assignment = JobReservationUnit(
+            id=str(uuid.uuid4()),
+            reservation_id=reservation_id,
+            unit_id=unit_id,
+            assignment_source="filled" if reservation.assignment_type == "quantity" else "specific"
+        )
+        db.add(assignment)
+
+    db.commit()
+
+    # Check for calibration conflicts
+    cal_conflicts = check_calibration_conflicts(db, reservation_id)
+
+    assigned_count = db.query(JobReservationUnit).filter_by(
+        reservation_id=reservation_id
+    ).count()
+
+    return {
+        "success": True,
+        "assigned_count": assigned_count,
+        "conflicts": conflicts,
+        "calibration_warnings": cal_conflicts,
+        "message": f"Assigned {len(unit_ids) - len(conflicts)} units"
+    }
+
+
+@router.delete("/api/fleet-calendar/reservations/{reservation_id}/units/{unit_id}", response_class=JSONResponse)
+async def remove_unit_from_reservation(
+    reservation_id: str,
+    unit_id: str,
+    db: Session = Depends(get_db)
+):
+    """Remove a unit from a reservation."""
+    assignment = db.query(JobReservationUnit).filter_by(
+        reservation_id=reservation_id,
+        unit_id=unit_id
+    ).first()
+
+    if not assignment:
+        raise HTTPException(status_code=404, detail="Unit assignment not found")
+
+    db.delete(assignment)
+    db.commit()
+
+    return {
+        "success": True,
+        "message": f"Removed {unit_id} from reservation"
+    }
+
+
+# ============================================================================
+# Availability & Conflicts
+# ============================================================================
+
+@router.get("/api/fleet-calendar/availability", response_class=JSONResponse)
+async def check_availability(
+    start_date: str,
+    end_date: str,
+    device_type: str = "seismograph",
+    exclude_reservation_id: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
+    """Get units available for a specific date range."""
+    try:
+        start = date.fromisoformat(start_date)
+        end = date.fromisoformat(end_date)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid date format. Use YYYY-MM-DD")
+
+    available = get_available_units_for_period(
+        db, start, end, device_type, exclude_reservation_id
+    )
+
+    return {
+        "start_date": start_date,
+        "end_date": end_date,
+        "device_type": device_type,
+        "available_units": available,
+        "count": len(available)
+    }
+
+
+@router.get("/api/fleet-calendar/reservations/{reservation_id}/conflicts", response_class=JSONResponse)
+async def get_reservation_conflicts(
+    reservation_id: str,
+    db: Session = Depends(get_db)
+):
+    """Check for calibration conflicts in a reservation."""
+    reservation = db.query(JobReservation).filter_by(id=reservation_id).first()
+    if not reservation:
+        raise HTTPException(status_code=404, detail="Reservation not found")
+
+    conflicts = check_calibration_conflicts(db, reservation_id)
+
+    return {
+        "reservation_id": reservation_id,
+        "reservation_name": reservation.name,
+        "conflicts": conflicts,
+        "has_conflicts": len(conflicts) > 0
+    }
+
+
+# ============================================================================
+# HTMX Partials
+# ============================================================================
+
+@router.get("/api/fleet-calendar/reservations-list", response_class=HTMLResponse)
+async def get_reservations_list(
+    request: Request,
+    year: Optional[int] = None,
+    month: Optional[int] = None,
+    device_type: str = "seismograph",
+    db: Session = Depends(get_db)
+):
+    """Get list of reservations as HTMX partial."""
+    from sqlalchemy import or_
+
+    today = date.today()
+    if year is None:
+        year = today.year
+    if month is None:
+        month = today.month
+
+    # Calculate 12-month window
+    start_date = date(year, month, 1)
+    # End date is 12 months later
+    end_year = year + ((month + 10) // 12)
+    end_month = ((month + 10) % 12) + 1
+    if end_month == 12:
+        end_date = date(end_year, 12, 31)
+    else:
+        end_date = date(end_year, end_month + 1, 1) - timedelta(days=1)
+
+    # Include TBD reservations that started before window end
+    reservations = db.query(JobReservation).filter(
+        JobReservation.device_type == device_type,
+        JobReservation.start_date <= end_date,
+        or_(
+            JobReservation.end_date >= start_date,
+            JobReservation.end_date == None  # TBD reservations
+        )
+    ).order_by(JobReservation.start_date).all()
+
+    # Get assignment counts
+    reservation_data = []
+    for res in reservations:
+        assigned_count = db.query(JobReservationUnit).filter_by(
+            reservation_id=res.id
+        ).count()
+
+        # Check for calibration conflicts
+        conflicts = check_calibration_conflicts(db, res.id)
+
+        reservation_data.append({
+            "reservation": res,
+            "assigned_count": assigned_count,
+            "has_conflicts": len(conflicts) > 0,
+            "conflict_count": len(conflicts)
+        })
+
+    return templates.TemplateResponse(
+        "partials/fleet_calendar/reservations_list.html",
+        {
+            "request": request,
+            "reservations": reservation_data,
+            "year": year,
+            "device_type": device_type
+        }
+    )
+
+
+@router.get("/api/fleet-calendar/available-units", response_class=HTMLResponse)
+async def get_available_units_partial(
+    request: Request,
+    start_date: str,
+    end_date: str,
+    device_type: str = "seismograph",
+    reservation_id: Optional[str] = None,
+    db: Session = Depends(get_db)
+):
+    """Get available units as HTMX partial for the assignment modal."""
+    try:
+        start = date.fromisoformat(start_date)
+        end = date.fromisoformat(end_date)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid date format")
+
+    available = get_available_units_for_period(
+        db, start, end, device_type, reservation_id
+    )
+
+    return templates.TemplateResponse(
+        "partials/fleet_calendar/available_units.html",
+        {
+            "request": request,
+            "units": available,
+            "start_date": start_date,
+            "end_date": end_date,
+            "device_type": device_type,
+            "reservation_id": reservation_id
+        }
+    )
+
+
+@router.get("/api/fleet-calendar/month/{year}/{month}", response_class=HTMLResponse)
+async def get_month_partial(
+    request: Request,
+    year: int,
+    month: int,
+    device_type: str = "seismograph",
+    db: Session = Depends(get_db)
+):
+    """Get a single month calendar as HTMX partial."""
+    calendar_data = get_calendar_year_data(db, year, device_type)
+    month_data = calendar_data["months"].get(month)
+
+    if not month_data:
+        raise HTTPException(status_code=404, detail="Invalid month")
+
+    return templates.TemplateResponse(
+        "partials/fleet_calendar/month_grid.html",
+        {
+            "request": request,
+            "year": year,
+            "month": month,
+            "month_data": month_data,
+            "device_type": device_type,
+            "today": date.today().isoformat()
+        }
+    )

backend/routers/modem_dashboard.py

@@ -0,0 +1,429 @@
+"""
+Modem Dashboard Router
+
+Provides API endpoints for the Field Modems management page.
+"""
+
+from fastapi import APIRouter, Request, Depends, Query
+from fastapi.responses import HTMLResponse
+from sqlalchemy.orm import Session
+from datetime import datetime
+import subprocess
+import time
+import logging
+
+from backend.database import get_db
+from backend.models import RosterUnit
+from backend.templates_config import templates
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/modem-dashboard", tags=["modem-dashboard"])
+
+
+@router.get("/stats", response_class=HTMLResponse)
+async def get_modem_stats(request: Request, db: Session = Depends(get_db)):
+    """
+    Get summary statistics for modem dashboard.
+    Returns HTML partial with stat cards.
+    """
+    # Query all modems
+    all_modems = db.query(RosterUnit).filter_by(device_type="modem").all()
+
+    # Get IDs of modems that have devices paired to them
+    paired_modem_ids = set()
+    devices_with_modems = db.query(RosterUnit).filter(
+        RosterUnit.deployed_with_modem_id.isnot(None),
+        RosterUnit.retired == False
+    ).all()
+    for device in devices_with_modems:
+        if device.deployed_with_modem_id:
+            paired_modem_ids.add(device.deployed_with_modem_id)
+
+    # Count categories
+    total_count = len(all_modems)
+    retired_count = sum(1 for m in all_modems if m.retired)
+
+    # In use = deployed AND paired with a device
+    in_use_count = sum(1 for m in all_modems
+                       if m.deployed and not m.retired and m.id in paired_modem_ids)
+
+    # Spare = deployed but NOT paired (available for assignment)
+    spare_count = sum(1 for m in all_modems
+                      if m.deployed and not m.retired and m.id not in paired_modem_ids)
+
+    # Benched = not deployed and not retired
+    benched_count = sum(1 for m in all_modems if not m.deployed and not m.retired)
+
+    return templates.TemplateResponse("partials/modem_stats.html", {
+        "request": request,
+        "total_count": total_count,
+        "in_use_count": in_use_count,
+        "spare_count": spare_count,
+        "benched_count": benched_count,
+        "retired_count": retired_count
+    })
+
+
+@router.get("/units", response_class=HTMLResponse)
+async def get_modem_units(
+    request: Request,
+    db: Session = Depends(get_db),
+    search: str = Query(None),
+    filter_status: str = Query(None),  # "in_use", "spare", "benched", "retired"
+):
+    """
+    Get list of modem units for the dashboard.
+    Returns HTML partial with modem cards.
+    """
+    query = db.query(RosterUnit).filter_by(device_type="modem")
+
+    # Filter by search term if provided
+    if search:
+        search_term = f"%{search}%"
+        query = query.filter(
+            (RosterUnit.id.ilike(search_term)) |
+            (RosterUnit.ip_address.ilike(search_term)) |
+            (RosterUnit.hardware_model.ilike(search_term)) |
+            (RosterUnit.phone_number.ilike(search_term)) |
+            (RosterUnit.location.ilike(search_term))
+        )
+
+    modems = query.order_by(
+        RosterUnit.retired.asc(),
+        RosterUnit.deployed.desc(),
+        RosterUnit.id.asc()
+    ).all()
+
+    # Get paired device info for each modem
+    paired_devices = {}
+    devices_with_modems = db.query(RosterUnit).filter(
+        RosterUnit.deployed_with_modem_id.isnot(None),
+        RosterUnit.retired == False
+    ).all()
+    for device in devices_with_modems:
+        if device.deployed_with_modem_id:
+            paired_devices[device.deployed_with_modem_id] = {
+                "id": device.id,
+                "device_type": device.device_type,
+                "deployed": device.deployed
+            }
+
+    # Annotate modems with paired device info
+    modem_list = []
+    for modem in modems:
+        paired = paired_devices.get(modem.id)
+
+        # Determine status category
+        if modem.retired:
+            status = "retired"
+        elif not modem.deployed:
+            status = "benched"
+        elif paired:
+            status = "in_use"
+        else:
+            status = "spare"
+
+        # Apply filter if specified
+        if filter_status and status != filter_status:
+            continue
+
+        modem_list.append({
+            "id": modem.id,
+            "ip_address": modem.ip_address,
+            "phone_number": modem.phone_number,
+            "hardware_model": modem.hardware_model,
+            "deployed": modem.deployed,
+            "retired": modem.retired,
+            "location": modem.location,
+            "project_id": modem.project_id,
+            "paired_device": paired,
+            "status": status
+        })
+
+    return templates.TemplateResponse("partials/modem_list.html", {
+        "request": request,
+        "modems": modem_list
+    })
+
+
+@router.get("/{modem_id}/paired-device")
+async def get_paired_device(modem_id: str, db: Session = Depends(get_db)):
+    """
+    Get the device (SLM/seismograph) that is paired with this modem.
+    Returns JSON with device info or null if not paired.
+    """
+    # Check modem exists
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    # Find device paired with this modem
+    device = db.query(RosterUnit).filter(
+        RosterUnit.deployed_with_modem_id == modem_id,
+        RosterUnit.retired == False
+    ).first()
+
+    if device:
+        return {
+            "paired": True,
+            "device": {
+                "id": device.id,
+                "device_type": device.device_type,
+                "deployed": device.deployed,
+                "project_id": device.project_id,
+                "location": device.location or device.address
+            }
+        }
+
+    return {"paired": False, "device": None}
+
+
+@router.get("/{modem_id}/paired-device-html", response_class=HTMLResponse)
+async def get_paired_device_html(modem_id: str, request: Request, db: Session = Depends(get_db)):
+    """
+    Get HTML partial showing the device paired with this modem.
+    Used by unit_detail.html for modems.
+    """
+    # Check modem exists
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+    if not modem:
+        return HTMLResponse('<p class="text-red-500">Modem not found</p>')
+
+    # Find device paired with this modem
+    device = db.query(RosterUnit).filter(
+        RosterUnit.deployed_with_modem_id == modem_id,
+        RosterUnit.retired == False
+    ).first()
+
+    return templates.TemplateResponse("partials/modem_paired_device.html", {
+        "request": request,
+        "modem_id": modem_id,
+        "device": device
+    })
+
+
+@router.get("/{modem_id}/ping")
+async def ping_modem(modem_id: str, db: Session = Depends(get_db)):
+    """
+    Test modem connectivity with a simple ping.
+    Returns response time and connection status.
+    """
+    # Get modem from database
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    if not modem.ip_address:
+        return {"status": "error", "detail": f"Modem {modem_id} has no IP address configured"}
+
+    try:
+        # Ping the modem (1 packet, 2 second timeout)
+        start_time = time.time()
+        result = subprocess.run(
+            ["ping", "-c", "1", "-W", "2", modem.ip_address],
+            capture_output=True,
+            text=True,
+            timeout=3
+        )
+        response_time = int((time.time() - start_time) * 1000)  # Convert to milliseconds
+
+        if result.returncode == 0:
+            return {
+                "status": "success",
+                "modem_id": modem_id,
+                "ip_address": modem.ip_address,
+                "response_time_ms": response_time,
+                "message": "Modem is responding"
+            }
+        else:
+            return {
+                "status": "error",
+                "modem_id": modem_id,
+                "ip_address": modem.ip_address,
+                "detail": "Modem not responding to ping"
+            }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "status": "error",
+            "modem_id": modem_id,
+            "ip_address": modem.ip_address,
+            "detail": "Ping timeout"
+        }
+    except Exception as e:
+        logger.error(f"Failed to ping modem {modem_id}: {e}")
+        return {
+            "status": "error",
+            "modem_id": modem_id,
+            "detail": str(e)
+        }
+
+
+@router.get("/{modem_id}/diagnostics")
+async def get_modem_diagnostics(modem_id: str, db: Session = Depends(get_db)):
+    """
+    Get modem diagnostics (signal strength, data usage, uptime).
+
+    Currently returns placeholders. When ModemManager is available,
+    this endpoint will query it for real diagnostics.
+    """
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    # TODO: Query ModemManager backend when available
+    return {
+        "status": "unavailable",
+        "message": "ModemManager integration not yet available",
+        "modem_id": modem_id,
+        "signal_strength_dbm": None,
+        "data_usage_mb": None,
+        "uptime_seconds": None,
+        "carrier": None,
+        "connection_type": None  # LTE, 5G, etc.
+    }
+
+
+@router.get("/{modem_id}/pairable-devices")
+async def get_pairable_devices(
+    modem_id: str,
+    db: Session = Depends(get_db),
+    search: str = Query(None),
+    hide_paired: bool = Query(True)
+):
+    """
+    Get list of devices (seismographs and SLMs) that can be paired with this modem.
+    Used by the device picker modal in unit_detail.html.
+    """
+    # Check modem exists
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    # Query seismographs and SLMs
+    query = db.query(RosterUnit).filter(
+        RosterUnit.device_type.in_(["seismograph", "sound_level_meter"]),
+        RosterUnit.retired == False
+    )
+
+    # Filter by search term if provided
+    if search:
+        search_term = f"%{search}%"
+        query = query.filter(
+            (RosterUnit.id.ilike(search_term)) |
+            (RosterUnit.project_id.ilike(search_term)) |
+            (RosterUnit.location.ilike(search_term)) |
+            (RosterUnit.address.ilike(search_term)) |
+            (RosterUnit.note.ilike(search_term))
+        )
+
+    devices = query.order_by(
+        RosterUnit.deployed.desc(),
+        RosterUnit.device_type.asc(),
+        RosterUnit.id.asc()
+    ).all()
+
+    # Build device list
+    device_list = []
+    for device in devices:
+        # Skip already paired devices if hide_paired is True
+        is_paired_to_other = (
+            device.deployed_with_modem_id is not None and
+            device.deployed_with_modem_id != modem_id
+        )
+        is_paired_to_this = device.deployed_with_modem_id == modem_id
+
+        if hide_paired and is_paired_to_other:
+            continue
+
+        device_list.append({
+            "id": device.id,
+            "device_type": device.device_type,
+            "deployed": device.deployed,
+            "project_id": device.project_id,
+            "location": device.location or device.address,
+            "note": device.note,
+            "paired_modem_id": device.deployed_with_modem_id,
+            "is_paired_to_this": is_paired_to_this,
+            "is_paired_to_other": is_paired_to_other
+        })
+
+    return {"devices": device_list, "modem_id": modem_id}
+
+
+@router.post("/{modem_id}/pair")
+async def pair_device_to_modem(
+    modem_id: str,
+    db: Session = Depends(get_db),
+    device_id: str = Query(..., description="ID of the device to pair")
+):
+    """
+    Pair a device (seismograph or SLM) to this modem.
+    Updates the device's deployed_with_modem_id field.
+    """
+    # Check modem exists
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    # Find the device
+    device = db.query(RosterUnit).filter(
+        RosterUnit.id == device_id,
+        RosterUnit.device_type.in_(["seismograph", "sound_level_meter"]),
+        RosterUnit.retired == False
+    ).first()
+    if not device:
+        return {"status": "error", "detail": f"Device {device_id} not found"}
+
+    # Unpair any device currently paired to this modem
+    currently_paired = db.query(RosterUnit).filter(
+        RosterUnit.deployed_with_modem_id == modem_id
+    ).all()
+    for paired_device in currently_paired:
+        paired_device.deployed_with_modem_id = None
+
+    # Pair the new device
+    device.deployed_with_modem_id = modem_id
+    db.commit()
+
+    return {
+        "status": "success",
+        "modem_id": modem_id,
+        "device_id": device_id,
+        "message": f"Device {device_id} paired to modem {modem_id}"
+    }
+
+
+@router.post("/{modem_id}/unpair")
+async def unpair_device_from_modem(modem_id: str, db: Session = Depends(get_db)):
+    """
+    Unpair any device currently paired to this modem.
+    """
+    # Check modem exists
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    # Find and unpair device
+    device = db.query(RosterUnit).filter(
+        RosterUnit.deployed_with_modem_id == modem_id
+    ).first()
+
+    if device:
+        old_device_id = device.id
+        device.deployed_with_modem_id = None
+        db.commit()
+        return {
+            "status": "success",
+            "modem_id": modem_id,
+            "unpaired_device_id": old_device_id,
+            "message": f"Device {old_device_id} unpaired from modem {modem_id}"
+        }
+
+    return {
+        "status": "success",
+        "modem_id": modem_id,
+        "message": "No device was paired to this modem"
+    }

backend/routers/photos.py

@@ -8,8 +8,8 @@ import shutil
 from PIL import Image
 from PIL.ExifTags import TAGS, GPSTAGS
 from sqlalchemy.orm import Session
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.models import RosterUnit
+from backend.models import RosterUnit
 
 router = APIRouter(prefix="/api", tags=["photos"])
 

backend/routers/project_locations.py

@@ -0,0 +1,864 @@
+"""
+Project Locations Router
+
+Handles monitoring locations (NRLs for sound, monitoring points for vibration)
+and unit assignments within projects.
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_
+from datetime import datetime
+from typing import Optional
+import uuid
+import json
+
+from fastapi import UploadFile, File
+import zipfile
+import hashlib
+import io
+from pathlib import Path
+
+from backend.database import get_db
+from backend.models import (
+    Project,
+    ProjectType,
+    MonitoringLocation,
+    UnitAssignment,
+    RosterUnit,
+    MonitoringSession,
+    DataFile,
+)
+from backend.templates_config import templates
+
+router = APIRouter(prefix="/api/projects/{project_id}", tags=["project-locations"])
+
+
+# ============================================================================
+# Session period helpers
+# ============================================================================
+
+def _derive_period_type(dt: datetime) -> str:
+    """
+    Classify a session start time into one of four period types.
+    Night = 22:00–07:00, Day = 07:00–22:00.
+    Weekend = Saturday (5) or Sunday (6).
+    """
+    is_weekend = dt.weekday() >= 5
+    is_night = dt.hour >= 22 or dt.hour < 7
+    if is_weekend:
+        return "weekend_night" if is_night else "weekend_day"
+    return "weekday_night" if is_night else "weekday_day"
+
+
+def _build_session_label(dt: datetime, location_name: str, period_type: str) -> str:
+    """Build a human-readable session label, e.g. 'NRL-1 — Sun 2/23 — Night'.
+    Uses started_at date as-is; user can correct period_type in the wizard.
+    """
+    day_abbr = dt.strftime("%a")
+    date_str = f"{dt.month}/{dt.day}"
+    period_str = {
+        "weekday_day":   "Day",
+        "weekday_night": "Night",
+        "weekend_day":   "Day",
+        "weekend_night": "Night",
+    }.get(period_type, "")
+    parts = [p for p in [location_name, f"{day_abbr} {date_str}", period_str] if p]
+    return " — ".join(parts)
+
+
+# ============================================================================
+# Monitoring Locations CRUD
+# ============================================================================
+
+@router.get("/locations", response_class=HTMLResponse)
+async def get_project_locations(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    location_type: Optional[str] = Query(None),
+):
+    """
+    Get all monitoring locations for a project.
+    Returns HTML partial with location list.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    query = db.query(MonitoringLocation).filter_by(project_id=project_id)
+
+    # Filter by type if provided
+    if location_type:
+        query = query.filter_by(location_type=location_type)
+
+    locations = query.order_by(MonitoringLocation.name).all()
+
+    # Enrich with assignment info
+    locations_data = []
+    for location in locations:
+        # Get active assignment
+        assignment = db.query(UnitAssignment).filter(
+            and_(
+                UnitAssignment.location_id == location.id,
+                UnitAssignment.status == "active",
+            )
+        ).first()
+
+        assigned_unit = None
+        if assignment:
+            assigned_unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+
+        # Count monitoring sessions
+        session_count = db.query(MonitoringSession).filter_by(
+            location_id=location.id
+        ).count()
+
+        locations_data.append({
+            "location": location,
+            "assignment": assignment,
+            "assigned_unit": assigned_unit,
+            "session_count": session_count,
+        })
+
+    return templates.TemplateResponse("partials/projects/location_list.html", {
+        "request": request,
+        "project": project,
+        "locations": locations_data,
+    })
+
+
+@router.get("/locations-json")
+async def get_project_locations_json(
+    project_id: str,
+    db: Session = Depends(get_db),
+    location_type: Optional[str] = Query(None),
+):
+    """
+    Get all monitoring locations for a project as JSON.
+    Used by the schedule modal to populate location dropdown.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    query = db.query(MonitoringLocation).filter_by(project_id=project_id)
+
+    if location_type:
+        query = query.filter_by(location_type=location_type)
+
+    locations = query.order_by(MonitoringLocation.name).all()
+
+    return [
+        {
+            "id": loc.id,
+            "name": loc.name,
+            "location_type": loc.location_type,
+            "description": loc.description,
+            "address": loc.address,
+            "coordinates": loc.coordinates,
+        }
+        for loc in locations
+    ]
+
+
+@router.post("/locations/create")
+async def create_location(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Create a new monitoring location within a project.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    form_data = await request.form()
+
+    location = MonitoringLocation(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_type=form_data.get("location_type"),
+        name=form_data.get("name"),
+        description=form_data.get("description"),
+        coordinates=form_data.get("coordinates"),
+        address=form_data.get("address"),
+        location_metadata=form_data.get("location_metadata"),  # JSON string
+    )
+
+    db.add(location)
+    db.commit()
+    db.refresh(location)
+
+    return JSONResponse({
+        "success": True,
+        "location_id": location.id,
+        "message": f"Location '{location.name}' created successfully",
+    })
+
+
+@router.put("/locations/{location_id}")
+async def update_location(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Update a monitoring location.
+    """
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    data = await request.json()
+
+    # Update fields if provided
+    if "name" in data:
+        location.name = data["name"]
+    if "description" in data:
+        location.description = data["description"]
+    if "location_type" in data:
+        location.location_type = data["location_type"]
+    if "coordinates" in data:
+        location.coordinates = data["coordinates"]
+    if "address" in data:
+        location.address = data["address"]
+    if "location_metadata" in data:
+        location.location_metadata = data["location_metadata"]
+
+    location.updated_at = datetime.utcnow()
+
+    db.commit()
+
+    return {"success": True, "message": "Location updated successfully"}
+
+
+@router.delete("/locations/{location_id}")
+async def delete_location(
+    project_id: str,
+    location_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Delete a monitoring location.
+    """
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    # Check if location has active assignments
+    active_assignments = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.location_id == location_id,
+            UnitAssignment.status == "active",
+        )
+    ).count()
+
+    if active_assignments > 0:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot delete location with active unit assignments. Unassign units first.",
+        )
+
+    db.delete(location)
+    db.commit()
+
+    return {"success": True, "message": "Location deleted successfully"}
+
+
+# ============================================================================
+# Unit Assignments
+# ============================================================================
+
+@router.get("/assignments", response_class=HTMLResponse)
+async def get_project_assignments(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query("active"),
+):
+    """
+    Get all unit assignments for a project.
+    Returns HTML partial with assignment list.
+    """
+    query = db.query(UnitAssignment).filter_by(project_id=project_id)
+
+    if status:
+        query = query.filter_by(status=status)
+
+    assignments = query.order_by(UnitAssignment.assigned_at.desc()).all()
+
+    # Enrich with unit and location details
+    assignments_data = []
+    for assignment in assignments:
+        unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+        location = db.query(MonitoringLocation).filter_by(id=assignment.location_id).first()
+
+        assignments_data.append({
+            "assignment": assignment,
+            "unit": unit,
+            "location": location,
+        })
+
+    return templates.TemplateResponse("partials/projects/assignment_list.html", {
+        "request": request,
+        "project_id": project_id,
+        "assignments": assignments_data,
+    })
+
+
+@router.post("/locations/{location_id}/assign")
+async def assign_unit_to_location(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Assign a unit to a monitoring location.
+    """
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    form_data = await request.form()
+    unit_id = form_data.get("unit_id")
+
+    # Verify unit exists and matches location type
+    unit = db.query(RosterUnit).filter_by(id=unit_id).first()
+    if not unit:
+        raise HTTPException(status_code=404, detail="Unit not found")
+
+    # Check device type matches location type
+    expected_device_type = "slm" if location.location_type == "sound" else "seismograph"
+    if unit.device_type != expected_device_type:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Unit type '{unit.device_type}' does not match location type '{location.location_type}'",
+        )
+
+    # Check if location already has an active assignment
+    existing_assignment = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.location_id == location_id,
+            UnitAssignment.status == "active",
+        )
+    ).first()
+
+    if existing_assignment:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Location already has an active unit assignment ({existing_assignment.unit_id}). Unassign first.",
+        )
+
+    # Create new assignment
+    assigned_until_str = form_data.get("assigned_until")
+    assigned_until = datetime.fromisoformat(assigned_until_str) if assigned_until_str else None
+
+    assignment = UnitAssignment(
+        id=str(uuid.uuid4()),
+        unit_id=unit_id,
+        location_id=location_id,
+        project_id=project_id,
+        device_type=unit.device_type,
+        assigned_until=assigned_until,
+        status="active",
+        notes=form_data.get("notes"),
+    )
+
+    db.add(assignment)
+    db.commit()
+    db.refresh(assignment)
+
+    return JSONResponse({
+        "success": True,
+        "assignment_id": assignment.id,
+        "message": f"Unit '{unit_id}' assigned to '{location.name}'",
+    })
+
+
+@router.post("/assignments/{assignment_id}/unassign")
+async def unassign_unit(
+    project_id: str,
+    assignment_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Unassign a unit from a location.
+    """
+    assignment = db.query(UnitAssignment).filter_by(
+        id=assignment_id,
+        project_id=project_id,
+    ).first()
+
+    if not assignment:
+        raise HTTPException(status_code=404, detail="Assignment not found")
+
+    # Check if there are active monitoring sessions
+    active_sessions = db.query(MonitoringSession).filter(
+        and_(
+            MonitoringSession.location_id == assignment.location_id,
+            MonitoringSession.unit_id == assignment.unit_id,
+            MonitoringSession.status == "recording",
+        )
+    ).count()
+
+    if active_sessions > 0:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot unassign unit with active monitoring sessions. Stop monitoring first.",
+        )
+
+    assignment.status = "completed"
+    assignment.assigned_until = datetime.utcnow()
+
+    db.commit()
+
+    return {"success": True, "message": "Unit unassigned successfully"}
+
+
+# ============================================================================
+# Available Units for Assignment
+# ============================================================================
+
+@router.get("/available-units", response_class=JSONResponse)
+async def get_available_units(
+    project_id: str,
+    location_type: str = Query(...),
+    db: Session = Depends(get_db),
+):
+    """
+    Get list of available units for assignment to a location.
+    Filters by device type matching the location type.
+    """
+    # Determine required device type
+    required_device_type = "slm" if location_type == "sound" else "seismograph"
+
+    # Get all units of the required type that are deployed and not retired
+    all_units = db.query(RosterUnit).filter(
+        and_(
+            RosterUnit.device_type == required_device_type,
+            RosterUnit.deployed == True,
+            RosterUnit.retired == False,
+        )
+    ).all()
+
+    # Filter out units that already have active assignments
+    assigned_unit_ids = db.query(UnitAssignment.unit_id).filter(
+        UnitAssignment.status == "active"
+    ).distinct().all()
+    assigned_unit_ids = [uid[0] for uid in assigned_unit_ids]
+
+    available_units = [
+        {
+            "id": unit.id,
+            "device_type": unit.device_type,
+            "location": unit.address or unit.location,
+            "model": unit.slm_model if unit.device_type == "slm" else unit.unit_type,
+        }
+        for unit in all_units
+        if unit.id not in assigned_unit_ids
+    ]
+
+    return available_units
+
+
+# ============================================================================
+# NRL-specific endpoints for detail page
+# ============================================================================
+
+@router.get("/nrl/{location_id}/sessions", response_class=HTMLResponse)
+async def get_nrl_sessions(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Get monitoring sessions for a specific NRL.
+    Returns HTML partial with session list.
+    """
+    sessions = db.query(MonitoringSession).filter_by(
+        location_id=location_id
+    ).order_by(MonitoringSession.started_at.desc()).all()
+
+    # Enrich with unit details
+    sessions_data = []
+    for session in sessions:
+        unit = None
+        if session.unit_id:
+            unit = db.query(RosterUnit).filter_by(id=session.unit_id).first()
+
+        sessions_data.append({
+            "session": session,
+            "unit": unit,
+        })
+
+    return templates.TemplateResponse("partials/projects/session_list.html", {
+        "request": request,
+        "project_id": project_id,
+        "location_id": location_id,
+        "sessions": sessions_data,
+    })
+
+
+@router.get("/nrl/{location_id}/files", response_class=HTMLResponse)
+async def get_nrl_files(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Get data files for a specific NRL.
+    Returns HTML partial with file list.
+    """
+    # Join DataFile with MonitoringSession to filter by location_id
+    files = db.query(DataFile).join(
+        MonitoringSession,
+        DataFile.session_id == MonitoringSession.id
+    ).filter(
+        MonitoringSession.location_id == location_id
+    ).order_by(DataFile.created_at.desc()).all()
+
+    # Enrich with session details
+    files_data = []
+    for file in files:
+        session = None
+        if file.session_id:
+            session = db.query(MonitoringSession).filter_by(id=file.session_id).first()
+
+        files_data.append({
+            "file": file,
+            "session": session,
+        })
+
+    return templates.TemplateResponse("partials/projects/file_list.html", {
+        "request": request,
+        "project_id": project_id,
+        "location_id": location_id,
+        "files": files_data,
+    })
+
+
+# ============================================================================
+# Manual SD Card Data Upload
+# ============================================================================
+
+def _parse_rnh(content: bytes) -> dict:
+    """
+    Parse a Rion .rnh metadata file (INI-style with [Section] headers).
+    Returns a dict of key metadata fields.
+    """
+    result = {}
+    try:
+        text = content.decode("utf-8", errors="replace")
+        for line in text.splitlines():
+            line = line.strip()
+            if not line or line.startswith("["):
+                continue
+            if "," in line:
+                key, _, value = line.partition(",")
+                key = key.strip()
+                value = value.strip()
+                if key == "Serial Number":
+                    result["serial_number"] = value
+                elif key == "Store Name":
+                    result["store_name"] = value
+                elif key == "Index Number":
+                    result["index_number"] = value
+                elif key == "Measurement Start Time":
+                    result["start_time_str"] = value
+                elif key == "Measurement Stop Time":
+                    result["stop_time_str"] = value
+                elif key == "Total Measurement Time":
+                    result["total_time_str"] = value
+    except Exception:
+        pass
+    return result
+
+
+def _parse_rnh_datetime(s: str):
+    """Parse RNH datetime string: '2026/02/17 19:00:19' -> datetime"""
+    from datetime import datetime
+    if not s:
+        return None
+    try:
+        return datetime.strptime(s.strip(), "%Y/%m/%d %H:%M:%S")
+    except Exception:
+        return None
+
+
+def _classify_file(filename: str) -> str:
+    """Classify a file by name into a DataFile file_type."""
+    name = filename.lower()
+    if name.endswith(".rnh"):
+        return "log"
+    if name.endswith(".rnd"):
+        return "measurement"
+    if name.endswith(".zip"):
+        return "archive"
+    return "data"
+
+
+@router.post("/nrl/{location_id}/upload-data")
+async def upload_nrl_data(
+    project_id: str,
+    location_id: str,
+    db: Session = Depends(get_db),
+    files: list[UploadFile] = File(...),
+):
+    """
+    Manually upload SD card data for an offline NRL.
+
+    Accepts either:
+    - A single .zip file (the Auto_#### folder zipped) — auto-extracted
+    - Multiple .rnd / .rnh files selected directly from the SD card folder
+
+    Creates a MonitoringSession from .rnh metadata and DataFile records
+    for each measurement file. No unit assignment required.
+    """
+    from datetime import datetime
+
+    # Verify project and location exist
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id, project_id=project_id
+    ).first()
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    # --- Step 1: Normalize to (filename, bytes) list ---
+    file_entries: list[tuple[str, bytes]] = []
+
+    if len(files) == 1 and files[0].filename.lower().endswith(".zip"):
+        raw = await files[0].read()
+        try:
+            with zipfile.ZipFile(io.BytesIO(raw)) as zf:
+                for info in zf.infolist():
+                    if info.is_dir():
+                        continue
+                    name = Path(info.filename).name  # strip folder path
+                    if not name:
+                        continue
+                    file_entries.append((name, zf.read(info)))
+        except zipfile.BadZipFile:
+            raise HTTPException(status_code=400, detail="Uploaded file is not a valid ZIP archive.")
+    else:
+        for uf in files:
+            data = await uf.read()
+            file_entries.append((uf.filename, data))
+
+    if not file_entries:
+        raise HTTPException(status_code=400, detail="No usable files found in upload.")
+
+    # --- Step 1b: Filter to only relevant files ---
+    # Keep: .rnh (metadata) and measurement .rnd files
+    #   NL-43 generates two .rnd types: _Leq_ (15-min averages, wanted) and _Lp_ (1-sec granular, skip)
+    #   AU2 (NL-23/older Rion) generates a single Au2_####.rnd per session — always keep those
+    # Drop: _Lp_ .rnd, .xlsx, .mp3, and anything else
+    def _is_wanted(fname: str) -> bool:
+        n = fname.lower()
+        if n.endswith(".rnh"):
+            return True
+        if n.endswith(".rnd"):
+            if "_leq_" in n:        # NL-43 Leq file
+                return True
+            if n.startswith("au2_"): # AU2 format (NL-23) — always Leq equivalent
+                return True
+            if "_lp" not in n and "_leq_" not in n:
+                # Unknown .rnd format — include it so we don't silently drop data
+                return True
+        return False
+
+    file_entries = [(fname, fbytes) for fname, fbytes in file_entries if _is_wanted(fname)]
+
+    if not file_entries:
+        raise HTTPException(status_code=400, detail="No usable .rnd or .rnh files found. Expected NL-43 _Leq_ files or AU2 format .rnd files.")
+
+    # --- Step 2: Find and parse .rnh metadata ---
+    rnh_meta = {}
+    for fname, fbytes in file_entries:
+        if fname.lower().endswith(".rnh"):
+            rnh_meta = _parse_rnh(fbytes)
+            break
+
+    started_at = _parse_rnh_datetime(rnh_meta.get("start_time_str")) or datetime.utcnow()
+    stopped_at = _parse_rnh_datetime(rnh_meta.get("stop_time_str"))
+    duration_seconds = None
+    if started_at and stopped_at:
+        duration_seconds = int((stopped_at - started_at).total_seconds())
+
+    store_name = rnh_meta.get("store_name", "")
+    serial_number = rnh_meta.get("serial_number", "")
+    index_number = rnh_meta.get("index_number", "")
+
+    # --- Step 3: Create MonitoringSession ---
+    period_type = _derive_period_type(started_at) if started_at else None
+    session_label = _build_session_label(started_at, location.name, period_type) if started_at else None
+
+    session_id = str(uuid.uuid4())
+    monitoring_session = MonitoringSession(
+        id=session_id,
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=None,
+        session_type="sound",
+        started_at=started_at,
+        stopped_at=stopped_at,
+        duration_seconds=duration_seconds,
+        status="completed",
+        session_label=session_label,
+        period_type=period_type,
+        session_metadata=json.dumps({
+            "source": "manual_upload",
+            "store_name": store_name,
+            "serial_number": serial_number,
+            "index_number": index_number,
+        }),
+    )
+    db.add(monitoring_session)
+    db.commit()
+    db.refresh(monitoring_session)
+
+    # --- Step 4: Write files to disk and create DataFile records ---
+    output_dir = Path("data/Projects") / project_id / session_id
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    leq_count = 0
+    lp_count = 0
+    metadata_count = 0
+    files_imported = 0
+
+    for fname, fbytes in file_entries:
+        file_type = _classify_file(fname)
+        fname_lower = fname.lower()
+
+        # Track counts for summary
+        if fname_lower.endswith(".rnd"):
+            if "_leq_" in fname_lower:
+                leq_count += 1
+            elif "_lp" in fname_lower:
+                lp_count += 1
+        elif fname_lower.endswith(".rnh"):
+            metadata_count += 1
+
+        # Write to disk
+        dest = output_dir / fname
+        dest.write_bytes(fbytes)
+
+        # Compute checksum
+        checksum = hashlib.sha256(fbytes).hexdigest()
+
+        # Store relative path from data/ dir
+        rel_path = str(dest.relative_to("data"))
+
+        data_file = DataFile(
+            id=str(uuid.uuid4()),
+            session_id=session_id,
+            file_path=rel_path,
+            file_type=file_type,
+            file_size_bytes=len(fbytes),
+            downloaded_at=datetime.utcnow(),
+            checksum=checksum,
+            file_metadata=json.dumps({
+                "source": "manual_upload",
+                "original_filename": fname,
+                "store_name": store_name,
+            }),
+        )
+        db.add(data_file)
+        files_imported += 1
+
+    db.commit()
+
+    return {
+        "success": True,
+        "session_id": session_id,
+        "files_imported": files_imported,
+        "leq_files": leq_count,
+        "lp_files": lp_count,
+        "metadata_files": metadata_count,
+        "store_name": store_name,
+        "started_at": started_at.isoformat() if started_at else None,
+        "stopped_at": stopped_at.isoformat() if stopped_at else None,
+    }
+
+
+# ============================================================================
+# NRL Live Status (connected NRLs only)
+# ============================================================================
+
+@router.get("/nrl/{location_id}/live-status", response_class=HTMLResponse)
+async def get_nrl_live_status(
+    project_id: str,
+    location_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Fetch cached status from SLMM for the unit assigned to this NRL and
+    return a compact HTML status card. Used in the NRL overview tab for
+    connected NRLs. Gracefully shows an offline message if SLMM is unreachable.
+    """
+    import os
+    import httpx
+
+    # Find the assigned unit
+    assignment = db.query(UnitAssignment).filter(
+        and_(
+            UnitAssignment.location_id == location_id,
+            UnitAssignment.status == "active",
+        )
+    ).first()
+
+    if not assignment:
+        return templates.TemplateResponse("partials/projects/nrl_live_status.html", {
+            "request": request,
+            "status": None,
+            "error": "No unit assigned",
+        })
+
+    unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+    if not unit:
+        return templates.TemplateResponse("partials/projects/nrl_live_status.html", {
+            "request": request,
+            "status": None,
+            "error": "Assigned unit not found",
+        })
+
+    slmm_base = os.getenv("SLMM_BASE_URL", "http://localhost:8100")
+    status_data = None
+    error_msg = None
+
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            resp = await client.get(f"{slmm_base}/api/nl43/{unit.id}/status")
+            if resp.status_code == 200:
+                status_data = resp.json()
+            else:
+                error_msg = f"SLMM returned {resp.status_code}"
+    except Exception as e:
+        error_msg = "SLMM unreachable"
+
+    return templates.TemplateResponse("partials/projects/nrl_live_status.html", {
+        "request": request,
+        "unit": unit,
+        "status": status_data,
+        "error": error_msg,
+    })

backend/routers/recurring_schedules.py

@@ -0,0 +1,522 @@
+"""
+Recurring Schedules Router
+
+API endpoints for managing recurring monitoring schedules.
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from typing import Optional
+from datetime import datetime
+import json
+
+from backend.database import get_db
+from backend.models import RecurringSchedule, MonitoringLocation, Project, RosterUnit
+from backend.services.recurring_schedule_service import get_recurring_schedule_service
+from backend.templates_config import templates
+
+router = APIRouter(prefix="/api/projects/{project_id}/recurring-schedules", tags=["recurring-schedules"])
+
+
+# ============================================================================
+# List and Get
+# ============================================================================
+
+@router.get("/")
+async def list_recurring_schedules(
+    project_id: str,
+    db: Session = Depends(get_db),
+    enabled_only: bool = Query(False),
+):
+    """
+    List all recurring schedules for a project.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    query = db.query(RecurringSchedule).filter_by(project_id=project_id)
+    if enabled_only:
+        query = query.filter_by(enabled=True)
+
+    schedules = query.order_by(RecurringSchedule.created_at.desc()).all()
+
+    return {
+        "schedules": [
+            {
+                "id": s.id,
+                "name": s.name,
+                "schedule_type": s.schedule_type,
+                "device_type": s.device_type,
+                "location_id": s.location_id,
+                "unit_id": s.unit_id,
+                "enabled": s.enabled,
+                "weekly_pattern": json.loads(s.weekly_pattern) if s.weekly_pattern else None,
+                "interval_type": s.interval_type,
+                "cycle_time": s.cycle_time,
+                "include_download": s.include_download,
+                "timezone": s.timezone,
+                "next_occurrence": s.next_occurrence.isoformat() if s.next_occurrence else None,
+                "last_generated_at": s.last_generated_at.isoformat() if s.last_generated_at else None,
+                "created_at": s.created_at.isoformat() if s.created_at else None,
+            }
+            for s in schedules
+        ],
+        "count": len(schedules),
+    }
+
+
+@router.get("/{schedule_id}")
+async def get_recurring_schedule(
+    project_id: str,
+    schedule_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Get a specific recurring schedule.
+    """
+    schedule = db.query(RecurringSchedule).filter_by(
+        id=schedule_id,
+        project_id=project_id,
+    ).first()
+
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    # Get related location and unit info
+    location = db.query(MonitoringLocation).filter_by(id=schedule.location_id).first()
+    unit = None
+    if schedule.unit_id:
+        unit = db.query(RosterUnit).filter_by(id=schedule.unit_id).first()
+
+    return {
+        "id": schedule.id,
+        "name": schedule.name,
+        "schedule_type": schedule.schedule_type,
+        "device_type": schedule.device_type,
+        "location_id": schedule.location_id,
+        "location_name": location.name if location else None,
+        "unit_id": schedule.unit_id,
+        "unit_name": unit.id if unit else None,
+        "enabled": schedule.enabled,
+        "weekly_pattern": json.loads(schedule.weekly_pattern) if schedule.weekly_pattern else None,
+        "interval_type": schedule.interval_type,
+        "cycle_time": schedule.cycle_time,
+        "include_download": schedule.include_download,
+        "timezone": schedule.timezone,
+        "next_occurrence": schedule.next_occurrence.isoformat() if schedule.next_occurrence else None,
+        "last_generated_at": schedule.last_generated_at.isoformat() if schedule.last_generated_at else None,
+        "created_at": schedule.created_at.isoformat() if schedule.created_at else None,
+        "updated_at": schedule.updated_at.isoformat() if schedule.updated_at else None,
+    }
+
+
+# ============================================================================
+# Create
+# ============================================================================
+
+@router.post("/")
+async def create_recurring_schedule(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Create recurring schedules for one or more locations.
+
+    Body for weekly_calendar (supports multiple locations):
+    {
+        "name": "Weeknight Monitoring",
+        "schedule_type": "weekly_calendar",
+        "location_ids": ["uuid1", "uuid2"],  // Array of location IDs
+        "weekly_pattern": {
+            "monday": {"enabled": true, "start": "19:00", "end": "07:00"},
+            "tuesday": {"enabled": false},
+            ...
+        },
+        "include_download": true,
+        "auto_increment_index": true,
+        "timezone": "America/New_York"
+    }
+
+    Body for simple_interval (supports multiple locations):
+    {
+        "name": "24/7 Continuous",
+        "schedule_type": "simple_interval",
+        "location_ids": ["uuid1", "uuid2"],  // Array of location IDs
+        "interval_type": "daily",
+        "cycle_time": "00:00",
+        "include_download": true,
+        "auto_increment_index": true,
+        "timezone": "America/New_York"
+    }
+
+    Legacy single location support (backwards compatible):
+    {
+        "name": "...",
+        "location_id": "uuid",  // Single location ID
+        ...
+    }
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    data = await request.json()
+
+    # Support both location_ids (array) and location_id (single) for backwards compatibility
+    location_ids = data.get("location_ids", [])
+    if not location_ids and data.get("location_id"):
+        location_ids = [data.get("location_id")]
+
+    if not location_ids:
+        raise HTTPException(status_code=400, detail="At least one location is required")
+
+    # Validate all locations exist
+    locations = db.query(MonitoringLocation).filter(
+        MonitoringLocation.id.in_(location_ids),
+        MonitoringLocation.project_id == project_id,
+    ).all()
+
+    if len(locations) != len(location_ids):
+        raise HTTPException(status_code=404, detail="One or more locations not found")
+
+    service = get_recurring_schedule_service(db)
+    created_schedules = []
+    base_name = data.get("name", "Unnamed Schedule")
+
+    # Parse one-off datetime fields if applicable
+    one_off_start = None
+    one_off_end = None
+    if data.get("schedule_type") == "one_off":
+        from zoneinfo import ZoneInfo
+
+        tz = ZoneInfo(data.get("timezone", "America/New_York"))
+
+        start_dt_str = data.get("start_datetime")
+        end_dt_str = data.get("end_datetime")
+
+        if not start_dt_str or not end_dt_str:
+            raise HTTPException(status_code=400, detail="One-off schedules require start and end date/time")
+
+        try:
+            start_local = datetime.fromisoformat(start_dt_str).replace(tzinfo=tz)
+            end_local = datetime.fromisoformat(end_dt_str).replace(tzinfo=tz)
+        except ValueError:
+            raise HTTPException(status_code=400, detail="Invalid datetime format")
+
+        duration = end_local - start_local
+        if duration.total_seconds() < 900:
+            raise HTTPException(status_code=400, detail="Duration must be at least 15 minutes")
+        if duration.total_seconds() > 86400:
+            raise HTTPException(status_code=400, detail="Duration cannot exceed 24 hours")
+
+        from datetime import timezone as dt_timezone
+        now_local = datetime.now(tz)
+        if start_local <= now_local:
+            raise HTTPException(status_code=400, detail="Start time must be in the future")
+
+        # Convert to UTC for storage
+        one_off_start = start_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+        one_off_end = end_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+
+    # Create a schedule for each location
+    for location in locations:
+        # Determine device type from location
+        device_type = "slm" if location.location_type == "sound" else "seismograph"
+
+        # Append location name if multiple locations
+        schedule_name = f"{base_name} - {location.name}" if len(locations) > 1 else base_name
+
+        schedule = service.create_schedule(
+            project_id=project_id,
+            location_id=location.id,
+            name=schedule_name,
+            schedule_type=data.get("schedule_type", "weekly_calendar"),
+            device_type=device_type,
+            unit_id=data.get("unit_id"),
+            weekly_pattern=data.get("weekly_pattern"),
+            interval_type=data.get("interval_type"),
+            cycle_time=data.get("cycle_time"),
+            include_download=data.get("include_download", True),
+            auto_increment_index=data.get("auto_increment_index", True),
+            timezone=data.get("timezone", "America/New_York"),
+            start_datetime=one_off_start,
+            end_datetime=one_off_end,
+        )
+
+        # Generate actions immediately so they appear right away
+        generated_actions = service.generate_actions_for_schedule(schedule, horizon_days=7)
+
+        created_schedules.append({
+            "schedule_id": schedule.id,
+            "location_id": location.id,
+            "location_name": location.name,
+            "actions_generated": len(generated_actions),
+        })
+
+    total_actions = sum(s.get("actions_generated", 0) for s in created_schedules)
+
+    return JSONResponse({
+        "success": True,
+        "schedules": created_schedules,
+        "count": len(created_schedules),
+        "actions_generated": total_actions,
+        "message": f"Created {len(created_schedules)} recurring schedule(s) with {total_actions} upcoming actions",
+    })
+
+
+# ============================================================================
+# Update
+# ============================================================================
+
+@router.put("/{schedule_id}")
+async def update_recurring_schedule(
+    project_id: str,
+    schedule_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Update a recurring schedule.
+    """
+    schedule = db.query(RecurringSchedule).filter_by(
+        id=schedule_id,
+        project_id=project_id,
+    ).first()
+
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    data = await request.json()
+    service = get_recurring_schedule_service(db)
+
+    # Build update kwargs
+    update_kwargs = {}
+    for field in ["name", "weekly_pattern", "interval_type", "cycle_time",
+                  "include_download", "auto_increment_index", "timezone", "unit_id"]:
+        if field in data:
+            update_kwargs[field] = data[field]
+
+    updated = service.update_schedule(schedule_id, **update_kwargs)
+
+    return {
+        "success": True,
+        "schedule_id": updated.id,
+        "message": "Schedule updated successfully",
+    }
+
+
+# ============================================================================
+# Delete
+# ============================================================================
+
+@router.delete("/{schedule_id}")
+async def delete_recurring_schedule(
+    project_id: str,
+    schedule_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Delete a recurring schedule.
+    """
+    service = get_recurring_schedule_service(db)
+    deleted = service.delete_schedule(schedule_id)
+
+    if not deleted:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    return {
+        "success": True,
+        "message": "Schedule deleted successfully",
+    }
+
+
+# ============================================================================
+# Enable/Disable
+# ============================================================================
+
+@router.post("/{schedule_id}/enable")
+async def enable_schedule(
+    project_id: str,
+    schedule_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Enable a disabled schedule.
+    """
+    service = get_recurring_schedule_service(db)
+    schedule = service.enable_schedule(schedule_id)
+
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    return {
+        "success": True,
+        "schedule_id": schedule.id,
+        "enabled": schedule.enabled,
+        "message": "Schedule enabled",
+    }
+
+
+@router.post("/{schedule_id}/disable")
+async def disable_schedule(
+    project_id: str,
+    schedule_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Disable a schedule and cancel all its pending actions.
+    """
+    service = get_recurring_schedule_service(db)
+
+    # Count pending actions before disabling (for response message)
+    from sqlalchemy import and_
+    from backend.models import ScheduledAction
+    pending_count = db.query(ScheduledAction).filter(
+        and_(
+            ScheduledAction.execution_status == "pending",
+            ScheduledAction.notes.like(f'%"schedule_id": "{schedule_id}"%'),
+        )
+    ).count()
+
+    schedule = service.disable_schedule(schedule_id)
+
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    message = "Schedule disabled"
+    if pending_count > 0:
+        message += f" and {pending_count} pending action(s) cancelled"
+
+    return {
+        "success": True,
+        "schedule_id": schedule.id,
+        "enabled": schedule.enabled,
+        "cancelled_actions": pending_count,
+        "message": message,
+    }
+
+
+# ============================================================================
+# Preview Generated Actions
+# ============================================================================
+
+@router.post("/{schedule_id}/generate-preview")
+async def preview_generated_actions(
+    project_id: str,
+    schedule_id: str,
+    db: Session = Depends(get_db),
+    days: int = Query(7, ge=1, le=30),
+):
+    """
+    Preview what actions would be generated without saving them.
+    """
+    schedule = db.query(RecurringSchedule).filter_by(
+        id=schedule_id,
+        project_id=project_id,
+    ).first()
+
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    service = get_recurring_schedule_service(db)
+    actions = service.generate_actions_for_schedule(
+        schedule,
+        horizon_days=days,
+        preview_only=True,
+    )
+
+    return {
+        "schedule_id": schedule_id,
+        "schedule_name": schedule.name,
+        "preview_days": days,
+        "actions": [
+            {
+                "action_type": a.action_type,
+                "scheduled_time": a.scheduled_time.isoformat(),
+                "notes": a.notes,
+            }
+            for a in actions
+        ],
+        "action_count": len(actions),
+    }
+
+
+# ============================================================================
+# Manual Generation Trigger
+# ============================================================================
+
+@router.post("/{schedule_id}/generate")
+async def generate_actions_now(
+    project_id: str,
+    schedule_id: str,
+    db: Session = Depends(get_db),
+    days: int = Query(7, ge=1, le=30),
+):
+    """
+    Manually trigger action generation for a schedule.
+    """
+    schedule = db.query(RecurringSchedule).filter_by(
+        id=schedule_id,
+        project_id=project_id,
+    ).first()
+
+    if not schedule:
+        raise HTTPException(status_code=404, detail="Schedule not found")
+
+    if not schedule.enabled:
+        raise HTTPException(status_code=400, detail="Schedule is disabled")
+
+    service = get_recurring_schedule_service(db)
+    actions = service.generate_actions_for_schedule(
+        schedule,
+        horizon_days=days,
+        preview_only=False,
+    )
+
+    return {
+        "success": True,
+        "schedule_id": schedule_id,
+        "generated_count": len(actions),
+        "message": f"Generated {len(actions)} scheduled actions",
+    }
+
+
+# ============================================================================
+# HTML Partials
+# ============================================================================
+
+@router.get("/partials/list", response_class=HTMLResponse)
+async def get_schedule_list_partial(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Return HTML partial for schedule list.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    project_status = project.status if project else "active"
+
+    schedules = db.query(RecurringSchedule).filter_by(
+        project_id=project_id
+    ).order_by(RecurringSchedule.created_at.desc()).all()
+
+    # Enrich with location info
+    schedule_data = []
+    for s in schedules:
+        location = db.query(MonitoringLocation).filter_by(id=s.location_id).first()
+        schedule_data.append({
+            "schedule": s,
+            "location": location,
+            "pattern": json.loads(s.weekly_pattern) if s.weekly_pattern else None,
+        })
+
+    return templates.TemplateResponse("partials/projects/recurring_schedule_list.html", {
+        "request": request,
+        "project_id": project_id,
+        "schedules": schedule_data,
+        "project_status": project_status,
+    })

backend/routers/report_templates.py

@@ -0,0 +1,187 @@
+"""
+Report Templates Router
+
+CRUD operations for report template management.
+Templates store time filter presets and report configuration for reuse.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import JSONResponse
+from sqlalchemy.orm import Session
+from datetime import datetime
+from typing import Optional
+import uuid
+
+from backend.database import get_db
+from backend.models import ReportTemplate
+
+router = APIRouter(prefix="/api/report-templates", tags=["report-templates"])
+
+
+@router.get("")
+async def list_templates(
+    project_id: Optional[str] = None,
+    db: Session = Depends(get_db),
+):
+    """
+    List all report templates.
+    Optionally filter by project_id (includes global templates with project_id=None).
+    """
+    query = db.query(ReportTemplate)
+
+    if project_id:
+        # Include global templates (project_id=None) AND project-specific templates
+        query = query.filter(
+            (ReportTemplate.project_id == None) | (ReportTemplate.project_id == project_id)
+        )
+
+    templates = query.order_by(ReportTemplate.name).all()
+
+    return [
+        {
+            "id": t.id,
+            "name": t.name,
+            "project_id": t.project_id,
+            "report_title": t.report_title,
+            "start_time": t.start_time,
+            "end_time": t.end_time,
+            "start_date": t.start_date,
+            "end_date": t.end_date,
+            "created_at": t.created_at.isoformat() if t.created_at else None,
+            "updated_at": t.updated_at.isoformat() if t.updated_at else None,
+        }
+        for t in templates
+    ]
+
+
+@router.post("")
+async def create_template(
+    data: dict,
+    db: Session = Depends(get_db),
+):
+    """
+    Create a new report template.
+
+    Request body:
+    - name: Template name (required)
+    - project_id: Optional project ID for project-specific template
+    - report_title: Default report title
+    - start_time: Start time filter (HH:MM format)
+    - end_time: End time filter (HH:MM format)
+    - start_date: Start date filter (YYYY-MM-DD format)
+    - end_date: End date filter (YYYY-MM-DD format)
+    """
+    name = data.get("name")
+    if not name:
+        raise HTTPException(status_code=400, detail="Template name is required")
+
+    template = ReportTemplate(
+        id=str(uuid.uuid4()),
+        name=name,
+        project_id=data.get("project_id"),
+        report_title=data.get("report_title", "Background Noise Study"),
+        start_time=data.get("start_time"),
+        end_time=data.get("end_time"),
+        start_date=data.get("start_date"),
+        end_date=data.get("end_date"),
+    )
+
+    db.add(template)
+    db.commit()
+    db.refresh(template)
+
+    return {
+        "id": template.id,
+        "name": template.name,
+        "project_id": template.project_id,
+        "report_title": template.report_title,
+        "start_time": template.start_time,
+        "end_time": template.end_time,
+        "start_date": template.start_date,
+        "end_date": template.end_date,
+        "created_at": template.created_at.isoformat() if template.created_at else None,
+    }
+
+
+@router.get("/{template_id}")
+async def get_template(
+    template_id: str,
+    db: Session = Depends(get_db),
+):
+    """Get a specific report template by ID."""
+    template = db.query(ReportTemplate).filter_by(id=template_id).first()
+    if not template:
+        raise HTTPException(status_code=404, detail="Template not found")
+
+    return {
+        "id": template.id,
+        "name": template.name,
+        "project_id": template.project_id,
+        "report_title": template.report_title,
+        "start_time": template.start_time,
+        "end_time": template.end_time,
+        "start_date": template.start_date,
+        "end_date": template.end_date,
+        "created_at": template.created_at.isoformat() if template.created_at else None,
+        "updated_at": template.updated_at.isoformat() if template.updated_at else None,
+    }
+
+
+@router.put("/{template_id}")
+async def update_template(
+    template_id: str,
+    data: dict,
+    db: Session = Depends(get_db),
+):
+    """Update an existing report template."""
+    template = db.query(ReportTemplate).filter_by(id=template_id).first()
+    if not template:
+        raise HTTPException(status_code=404, detail="Template not found")
+
+    # Update fields if provided
+    if "name" in data:
+        template.name = data["name"]
+    if "project_id" in data:
+        template.project_id = data["project_id"]
+    if "report_title" in data:
+        template.report_title = data["report_title"]
+    if "start_time" in data:
+        template.start_time = data["start_time"]
+    if "end_time" in data:
+        template.end_time = data["end_time"]
+    if "start_date" in data:
+        template.start_date = data["start_date"]
+    if "end_date" in data:
+        template.end_date = data["end_date"]
+
+    template.updated_at = datetime.utcnow()
+    db.commit()
+    db.refresh(template)
+
+    return {
+        "id": template.id,
+        "name": template.name,
+        "project_id": template.project_id,
+        "report_title": template.report_title,
+        "start_time": template.start_time,
+        "end_time": template.end_time,
+        "start_date": template.start_date,
+        "end_date": template.end_date,
+        "updated_at": template.updated_at.isoformat() if template.updated_at else None,
+    }
+
+
+@router.delete("/{template_id}")
+async def delete_template(
+    template_id: str,
+    db: Session = Depends(get_db),
+):
+    """Delete a report template."""
+    template = db.query(ReportTemplate).filter_by(id=template_id).first()
+    if not template:
+        raise HTTPException(status_code=404, detail="Template not found")
+
+    db.delete(template)
+    db.commit()
+
+    return JSONResponse({"status": "success", "message": "Template deleted"})

backend/routers/roster.py

@@ -2,20 +2,32 @@ from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 from datetime import datetime, timedelta
 from typing import Dict, Any
+import asyncio
+import logging
 import random
 
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.services.snapshot import emit_status_snapshot
+from backend.services.snapshot import emit_status_snapshot
+from backend.services.slm_status_sync import sync_slm_status_to_emitters
 
 router = APIRouter(prefix="/api", tags=["roster"])
+logger = logging.getLogger(__name__)
 
 
 @router.get("/status-snapshot")
-def get_status_snapshot(db: Session = Depends(get_db)):
+async def get_status_snapshot(db: Session = Depends(get_db)):
     """
     Calls emit_status_snapshot() to get current fleet status.
-    This will be replaced with real Series3 emitter logic later.
+    Syncs SLM status from SLMM before generating snapshot.
     """
+    # Sync SLM status from SLMM (with timeout to prevent blocking)
+    try:
+        await asyncio.wait_for(sync_slm_status_to_emitters(), timeout=2.0)
+    except asyncio.TimeoutError:
+        logger.warning("SLM status sync timed out, using cached data")
+    except Exception as e:
+        logger.warning(f"SLM status sync failed: {e}")
+
     return emit_status_snapshot()
 
 

backend/routers/roster_rename.py

@@ -0,0 +1,139 @@
+"""
+Roster Unit Rename Router
+
+Provides endpoint for safely renaming unit IDs across all database tables.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Form
+from sqlalchemy.orm import Session
+from datetime import datetime
+import logging
+
+from backend.database import get_db
+from backend.models import RosterUnit, Emitter, UnitHistory
+from backend.routers.roster_edit import record_history, sync_slm_to_slmm_cache
+
+router = APIRouter(prefix="/api/roster", tags=["roster-rename"])
+logger = logging.getLogger(__name__)
+
+
+@router.post("/rename")
+async def rename_unit(
+    old_id: str = Form(...),
+    new_id: str = Form(...),
+    db: Session = Depends(get_db)
+):
+    """
+    Rename a unit ID across all tables.
+    Updates the unit ID in roster, emitters, unit_history, and all foreign key references.
+
+    IMPORTANT: This operation updates the primary key, which affects all relationships.
+    """
+    # Validate input
+    if not old_id or not new_id:
+        raise HTTPException(status_code=400, detail="Both old_id and new_id are required")
+
+    if old_id == new_id:
+        raise HTTPException(status_code=400, detail="New ID must be different from old ID")
+
+    # Check if old unit exists
+    old_unit = db.query(RosterUnit).filter(RosterUnit.id == old_id).first()
+    if not old_unit:
+        raise HTTPException(status_code=404, detail=f"Unit '{old_id}' not found")
+
+    # Check if new ID already exists
+    existing_unit = db.query(RosterUnit).filter(RosterUnit.id == new_id).first()
+    if existing_unit:
+        raise HTTPException(status_code=409, detail=f"Unit ID '{new_id}' already exists")
+
+    device_type = old_unit.device_type
+
+    try:
+        # Record history for the rename operation (using old_id since that's still valid)
+        record_history(
+            db=db,
+            unit_id=old_id,
+            change_type="id_change",
+            field_name="id",
+            old_value=old_id,
+            new_value=new_id,
+            source="manual",
+            notes=f"Unit renamed from '{old_id}' to '{new_id}'"
+        )
+
+        # Update roster table (primary)
+        old_unit.id = new_id
+        old_unit.last_updated = datetime.utcnow()
+
+        # Update emitters table
+        emitter = db.query(Emitter).filter(Emitter.id == old_id).first()
+        if emitter:
+            emitter.id = new_id
+
+        # Update unit_history table (all entries for this unit)
+        db.query(UnitHistory).filter(UnitHistory.unit_id == old_id).update(
+            {"unit_id": new_id},
+            synchronize_session=False
+        )
+
+        # Update deployed_with_modem_id references (units that reference this as modem)
+        db.query(RosterUnit).filter(RosterUnit.deployed_with_modem_id == old_id).update(
+            {"deployed_with_modem_id": new_id},
+            synchronize_session=False
+        )
+
+        # Update unit_assignments table (if exists)
+        try:
+            from backend.models import UnitAssignment
+            db.query(UnitAssignment).filter(UnitAssignment.unit_id == old_id).update(
+                {"unit_id": new_id},
+                synchronize_session=False
+            )
+        except Exception as e:
+            logger.warning(f"Could not update unit_assignments: {e}")
+
+        # Update monitoring_sessions table (if exists)
+        try:
+            from backend.models import MonitoringSession
+            db.query(MonitoringSession).filter(MonitoringSession.unit_id == old_id).update(
+                {"unit_id": new_id},
+                synchronize_session=False
+            )
+        except Exception as e:
+            logger.warning(f"Could not update monitoring_sessions: {e}")
+
+        # Commit all changes
+        db.commit()
+
+        # If sound level meter, sync updated config to SLMM cache
+        if device_type == "slm":
+            logger.info(f"Syncing renamed SLM {new_id} (was {old_id}) config to SLMM cache...")
+            result = await sync_slm_to_slmm_cache(
+                unit_id=new_id,
+                host=old_unit.slm_host,
+                tcp_port=old_unit.slm_tcp_port,
+                ftp_port=old_unit.slm_ftp_port,
+                deployed_with_modem_id=old_unit.deployed_with_modem_id,
+                db=db
+            )
+
+            if not result["success"]:
+                logger.warning(f"SLMM cache sync warning for renamed unit {new_id}: {result['message']}")
+
+        logger.info(f"Successfully renamed unit '{old_id}' to '{new_id}'")
+
+        return {
+            "success": True,
+            "message": f"Successfully renamed unit from '{old_id}' to '{new_id}'",
+            "old_id": old_id,
+            "new_id": new_id,
+            "device_type": device_type
+        }
+
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Error renaming unit '{old_id}' to '{new_id}': {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to rename unit: {str(e)}"
+        )

backend/routers/scheduler.py

@@ -0,0 +1,408 @@
+"""
+Scheduler Router
+
+Handles scheduled actions for automated recording control.
+"""
+
+from fastapi import APIRouter, Request, Depends, HTTPException, Query
+from fastapi.responses import HTMLResponse, JSONResponse
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_
+from datetime import datetime, timedelta
+from typing import Optional
+import uuid
+import json
+
+from backend.database import get_db
+from backend.models import (
+    Project,
+    ScheduledAction,
+    MonitoringLocation,
+    UnitAssignment,
+    RosterUnit,
+)
+from backend.services.scheduler import get_scheduler
+from backend.templates_config import templates
+
+router = APIRouter(prefix="/api/projects/{project_id}/scheduler", tags=["scheduler"])
+
+
+# ============================================================================
+# Scheduled Actions List
+# ============================================================================
+
+@router.get("/actions", response_class=HTMLResponse)
+async def get_scheduled_actions(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+    status: Optional[str] = Query(None),
+    start_date: Optional[str] = Query(None),
+    end_date: Optional[str] = Query(None),
+):
+    """
+    Get scheduled actions for a project.
+    Returns HTML partial with agenda/calendar view.
+    """
+    query = db.query(ScheduledAction).filter_by(project_id=project_id)
+
+    # Filter by status
+    if status:
+        query = query.filter_by(execution_status=status)
+    else:
+        # By default, show pending and upcoming completed/failed
+        query = query.filter(
+            or_(
+                ScheduledAction.execution_status == "pending",
+                and_(
+                    ScheduledAction.execution_status.in_(["completed", "failed"]),
+                    ScheduledAction.scheduled_time >= datetime.utcnow() - timedelta(days=7),
+                ),
+            )
+        )
+
+    # Filter by date range
+    if start_date:
+        query = query.filter(ScheduledAction.scheduled_time >= datetime.fromisoformat(start_date))
+    if end_date:
+        query = query.filter(ScheduledAction.scheduled_time <= datetime.fromisoformat(end_date))
+
+    actions = query.order_by(ScheduledAction.scheduled_time).all()
+
+    # Enrich with location and unit details
+    actions_data = []
+    for action in actions:
+        location = db.query(MonitoringLocation).filter_by(id=action.location_id).first()
+
+        unit = None
+        if action.unit_id:
+            unit = db.query(RosterUnit).filter_by(id=action.unit_id).first()
+        else:
+            # Get from assignment
+            assignment = db.query(UnitAssignment).filter(
+                and_(
+                    UnitAssignment.location_id == action.location_id,
+                    UnitAssignment.status == "active",
+                )
+            ).first()
+            if assignment:
+                unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+
+        actions_data.append({
+            "action": action,
+            "location": location,
+            "unit": unit,
+        })
+
+    return templates.TemplateResponse("partials/projects/scheduler_agenda.html", {
+        "request": request,
+        "project_id": project_id,
+        "actions": actions_data,
+    })
+
+
+# ============================================================================
+# Create Scheduled Action
+# ============================================================================
+
+@router.post("/actions/create")
+async def create_scheduled_action(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Create a new scheduled action.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    form_data = await request.form()
+
+    location_id = form_data.get("location_id")
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    # Determine device type from location
+    device_type = "slm" if location.location_type == "sound" else "seismograph"
+
+    # Get unit_id (optional - can be determined from assignment at execution time)
+    unit_id = form_data.get("unit_id")
+
+    action = ScheduledAction(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=unit_id,
+        action_type=form_data.get("action_type"),
+        device_type=device_type,
+        scheduled_time=datetime.fromisoformat(form_data.get("scheduled_time")),
+        execution_status="pending",
+        notes=form_data.get("notes"),
+    )
+
+    db.add(action)
+    db.commit()
+    db.refresh(action)
+
+    return JSONResponse({
+        "success": True,
+        "action_id": action.id,
+        "message": f"Scheduled action '{action.action_type}' created for {action.scheduled_time}",
+    })
+
+
+# ============================================================================
+# Schedule Recording Session
+# ============================================================================
+
+@router.post("/schedule-session")
+async def schedule_recording_session(
+    project_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Schedule a complete recording session (start + stop).
+    Creates two scheduled actions: start and stop.
+    """
+    project = db.query(Project).filter_by(id=project_id).first()
+    if not project:
+        raise HTTPException(status_code=404, detail="Project not found")
+
+    form_data = await request.form()
+
+    location_id = form_data.get("location_id")
+    location = db.query(MonitoringLocation).filter_by(
+        id=location_id,
+        project_id=project_id,
+    ).first()
+
+    if not location:
+        raise HTTPException(status_code=404, detail="Location not found")
+
+    device_type = "slm" if location.location_type == "sound" else "seismograph"
+    unit_id = form_data.get("unit_id")
+
+    start_time = datetime.fromisoformat(form_data.get("start_time"))
+    duration_minutes = int(form_data.get("duration_minutes", 60))
+    stop_time = start_time + timedelta(minutes=duration_minutes)
+
+    # Create START action
+    start_action = ScheduledAction(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=unit_id,
+        action_type="start",
+        device_type=device_type,
+        scheduled_time=start_time,
+        execution_status="pending",
+        notes=form_data.get("notes"),
+    )
+
+    # Create STOP action
+    stop_action = ScheduledAction(
+        id=str(uuid.uuid4()),
+        project_id=project_id,
+        location_id=location_id,
+        unit_id=unit_id,
+        action_type="stop",
+        device_type=device_type,
+        scheduled_time=stop_time,
+        execution_status="pending",
+        notes=f"Auto-stop after {duration_minutes} minutes",
+    )
+
+    db.add(start_action)
+    db.add(stop_action)
+    db.commit()
+
+    return JSONResponse({
+        "success": True,
+        "start_action_id": start_action.id,
+        "stop_action_id": stop_action.id,
+        "message": f"Recording session scheduled from {start_time} to {stop_time}",
+    })
+
+
+# ============================================================================
+# Update/Cancel Scheduled Action
+# ============================================================================
+
+@router.put("/actions/{action_id}")
+async def update_scheduled_action(
+    project_id: str,
+    action_id: str,
+    request: Request,
+    db: Session = Depends(get_db),
+):
+    """
+    Update a scheduled action (only if not yet executed).
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot update action that has already been executed",
+        )
+
+    data = await request.json()
+
+    if "scheduled_time" in data:
+        action.scheduled_time = datetime.fromisoformat(data["scheduled_time"])
+    if "notes" in data:
+        action.notes = data["notes"]
+
+    db.commit()
+
+    return {"success": True, "message": "Action updated successfully"}
+
+
+@router.post("/actions/{action_id}/cancel")
+async def cancel_scheduled_action(
+    project_id: str,
+    action_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Cancel a pending scheduled action.
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Can only cancel pending actions",
+        )
+
+    action.execution_status = "cancelled"
+    db.commit()
+
+    return {"success": True, "message": "Action cancelled successfully"}
+
+
+@router.delete("/actions/{action_id}")
+async def delete_scheduled_action(
+    project_id: str,
+    action_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Delete a scheduled action (only if pending or cancelled).
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status not in ["pending", "cancelled"]:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot delete action that has been executed",
+        )
+
+    db.delete(action)
+    db.commit()
+
+    return {"success": True, "message": "Action deleted successfully"}
+
+
+# ============================================================================
+# Manual Execution
+# ============================================================================
+
+@router.post("/actions/{action_id}/execute")
+async def execute_action_now(
+    project_id: str,
+    action_id: str,
+    db: Session = Depends(get_db),
+):
+    """
+    Manually trigger execution of a scheduled action (for testing/debugging).
+    """
+    action = db.query(ScheduledAction).filter_by(
+        id=action_id,
+        project_id=project_id,
+    ).first()
+
+    if not action:
+        raise HTTPException(status_code=404, detail="Action not found")
+
+    if action.execution_status != "pending":
+        raise HTTPException(
+            status_code=400,
+            detail="Action is not pending",
+        )
+
+    # Execute via scheduler service
+    scheduler = get_scheduler()
+    result = await scheduler.execute_action_by_id(action_id)
+
+    # Refresh from DB to get updated status
+    db.refresh(action)
+
+    return JSONResponse({
+        "success": result.get("success", False),
+        "result": result,
+        "action": {
+            "id": action.id,
+            "execution_status": action.execution_status,
+            "executed_at": action.executed_at.isoformat() if action.executed_at else None,
+            "error_message": action.error_message,
+        },
+    })
+
+
+# ============================================================================
+# Scheduler Status
+# ============================================================================
+
+@router.get("/status")
+async def get_scheduler_status():
+    """
+    Get scheduler service status.
+    """
+    scheduler = get_scheduler()
+
+    return {
+        "running": scheduler.running,
+        "check_interval": scheduler.check_interval,
+    }
+
+
+@router.post("/execute-pending")
+async def trigger_pending_execution():
+    """
+    Manually trigger execution of all pending actions (for testing).
+    """
+    scheduler = get_scheduler()
+    results = await scheduler.execute_pending_actions()
+
+    return {
+        "success": True,
+        "executed_count": len(results),
+        "results": results,
+    }

backend/routers/seismo_dashboard.py

@@ -3,15 +3,16 @@ Seismograph Dashboard API Router
 Provides endpoints for the seismograph-specific dashboard
 """
 
+from datetime import date
+
 from fastapi import APIRouter, Request, Depends, Query
 from fastapi.responses import HTMLResponse
-from fastapi.templating import Jinja2Templates
 from sqlalchemy.orm import Session
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.models import RosterUnit
+from backend.models import RosterUnit
+from backend.templates_config import templates
 
 router = APIRouter(prefix="/api/seismo-dashboard", tags=["seismo-dashboard"])
-templates = Jinja2Templates(directory="templates")
 
 
 @router.get("/stats", response_class=HTMLResponse)
@@ -50,10 +51,14 @@ async def get_seismo_stats(request: Request, db: Session = Depends(get_db)):
 async def get_seismo_units(
     request: Request,
     db: Session = Depends(get_db),
-    search: str = Query(None)
+    search: str = Query(None),
+    sort: str = Query("id"),
+    order: str = Query("asc"),
+    status: str = Query(None),
+    modem: str = Query(None)
 ):
     """
-    Returns HTML partial with filterable seismograph unit list
+    Returns HTML partial with filterable and sortable seismograph unit list
     """
     query = db.query(RosterUnit).filter_by(
         device_type="seismograph",
@@ -62,20 +67,52 @@ async def get_seismo_units(
 
     # Apply search filter
     if search:
-        search_lower = search.lower()
         query = query.filter(
             (RosterUnit.id.ilike(f"%{search}%")) |
             (RosterUnit.note.ilike(f"%{search}%")) |
             (RosterUnit.address.ilike(f"%{search}%"))
         )
 
-    seismos = query.order_by(RosterUnit.id).all()
+    # Apply status filter
+    if status == "deployed":
+        query = query.filter(RosterUnit.deployed == True)
+    elif status == "benched":
+        query = query.filter(RosterUnit.deployed == False)
+
+    # Apply modem filter
+    if modem == "with":
+        query = query.filter(RosterUnit.deployed_with_modem_id.isnot(None))
+    elif modem == "without":
+        query = query.filter(RosterUnit.deployed_with_modem_id.is_(None))
+
+    # Apply sorting
+    sort_column_map = {
+        "id": RosterUnit.id,
+        "status": RosterUnit.deployed,
+        "modem": RosterUnit.deployed_with_modem_id,
+        "location": RosterUnit.address,
+        "last_calibrated": RosterUnit.last_calibrated,
+        "notes": RosterUnit.note
+    }
+    sort_column = sort_column_map.get(sort, RosterUnit.id)
+
+    if order == "desc":
+        query = query.order_by(sort_column.desc())
+    else:
+        query = query.order_by(sort_column.asc())
+
+    seismos = query.all()
 
     return templates.TemplateResponse(
         "partials/seismo_unit_list.html",
         {
             "request": request,
             "units": seismos,
-            "search": search or ""
+            "search": search or "",
+            "sort": sort,
+            "order": order,
+            "status": status or "",
+            "modem": modem or "",
+            "today": date.today()
         }
     )

backend/routers/settings.py

@@ -9,9 +9,9 @@ import io
 import shutil
 from pathlib import Path
 
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.models import RosterUnit, Emitter, IgnoredUnit, UserPreferences
+from backend.models import RosterUnit, Emitter, IgnoredUnit, UserPreferences
-from app.seismo.services.database_backup import DatabaseBackupService
+from backend.services.database_backup import DatabaseBackupService
 
 router = APIRouter(prefix="/api/settings", tags=["settings"])
 
@@ -477,3 +477,75 @@ async def upload_snapshot(file: UploadFile = File(...)):
 
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Upload failed: {str(e)}")
+
+
+# ============================================================================
+# SLMM SYNC ENDPOINTS
+# ============================================================================
+
+@router.post("/slmm/sync-all")
+async def sync_all_slms(db: Session = Depends(get_db)):
+    """
+    Manually trigger full sync of all SLM devices from Terra-View roster to SLMM.
+
+    This ensures SLMM database matches Terra-View roster (source of truth).
+    Also cleans up orphaned devices in SLMM that are not in Terra-View.
+    """
+    from backend.services.slmm_sync import sync_all_slms_to_slmm, cleanup_orphaned_slmm_devices
+
+    try:
+        # Sync all SLMs
+        sync_results = await sync_all_slms_to_slmm(db)
+
+        # Clean up orphaned devices
+        cleanup_results = await cleanup_orphaned_slmm_devices(db)
+
+        return {
+            "status": "ok",
+            "sync": sync_results,
+            "cleanup": cleanup_results
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Sync failed: {str(e)}")
+
+
+@router.get("/slmm/status")
+async def get_slmm_sync_status(db: Session = Depends(get_db)):
+    """
+    Get status of SLMM synchronization.
+
+    Shows which devices are in Terra-View roster vs SLMM database.
+    """
+    from backend.services.slmm_sync import get_slmm_devices
+
+    try:
+        # Get devices from both systems
+        roster_slms = db.query(RosterUnit).filter_by(device_type="slm").all()
+        slmm_devices = await get_slmm_devices()
+
+        if slmm_devices is None:
+            raise HTTPException(status_code=503, detail="SLMM service unavailable")
+
+        roster_unit_ids = {unit.unit_type for unit in roster_slms}
+        slmm_unit_ids = set(slmm_devices)
+
+        # Find differences
+        in_roster_only = roster_unit_ids - slmm_unit_ids
+        in_slmm_only = slmm_unit_ids - roster_unit_ids
+        in_both = roster_unit_ids & slmm_unit_ids
+
+        return {
+            "status": "ok",
+            "terra_view_total": len(roster_unit_ids),
+            "slmm_total": len(slmm_unit_ids),
+            "synced": len(in_both),
+            "missing_from_slmm": list(in_roster_only),
+            "orphaned_in_slmm": list(in_slmm_only),
+            "in_sync": len(in_roster_only) == 0 and len(in_slmm_only) == 0
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Status check failed: {str(e)}")

backend/routers/slm_dashboard.py

@@ -0,0 +1,363 @@
+"""
+SLM Dashboard Router
+
+Provides API endpoints for the Sound Level Meters dashboard page.
+"""
+
+from fastapi import APIRouter, Request, Depends, Query
+from fastapi.responses import HTMLResponse
+from sqlalchemy.orm import Session
+from sqlalchemy import func
+from datetime import datetime, timedelta
+import asyncio
+import httpx
+import logging
+import os
+
+from backend.database import get_db
+from backend.models import RosterUnit
+from backend.routers.roster_edit import sync_slm_to_slmm_cache
+from backend.templates_config import templates
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/slm-dashboard", tags=["slm-dashboard"])
+
+# SLMM backend URL - configurable via environment variable
+SLMM_BASE_URL = os.getenv("SLMM_BASE_URL", "http://localhost:8100")
+
+
+@router.get("/stats", response_class=HTMLResponse)
+async def get_slm_stats(request: Request, db: Session = Depends(get_db)):
+    """
+    Get summary statistics for SLM dashboard.
+    Returns HTML partial with stat cards.
+    """
+    # Query all SLMs
+    all_slms = db.query(RosterUnit).filter_by(device_type="slm").all()
+
+    # Count deployed vs benched
+    deployed_count = sum(1 for slm in all_slms if slm.deployed and not slm.retired)
+    benched_count = sum(1 for slm in all_slms if not slm.deployed and not slm.retired)
+    retired_count = sum(1 for slm in all_slms if slm.retired)
+
+    # Count recently active (checked in last hour)
+    one_hour_ago = datetime.utcnow() - timedelta(hours=1)
+    active_count = sum(1 for slm in all_slms
+                      if slm.slm_last_check and slm.slm_last_check > one_hour_ago)
+
+    return templates.TemplateResponse("partials/slm_stats.html", {
+        "request": request,
+        "total_count": len(all_slms),
+        "deployed_count": deployed_count,
+        "benched_count": benched_count,
+        "active_count": active_count,
+        "retired_count": retired_count
+    })
+
+
+@router.get("/units", response_class=HTMLResponse)
+async def get_slm_units(
+    request: Request,
+    db: Session = Depends(get_db),
+    search: str = Query(None),
+    project: str = Query(None),
+    include_measurement: bool = Query(False),
+):
+    """
+    Get list of SLM units for the sidebar.
+    Returns HTML partial with unit cards.
+    """
+    query = db.query(RosterUnit).filter_by(device_type="slm")
+
+    # Filter by project if provided
+    if project:
+        query = query.filter(RosterUnit.project_id == project)
+
+    # Filter by search term if provided
+    if search:
+        search_term = f"%{search}%"
+        query = query.filter(
+            (RosterUnit.id.like(search_term)) |
+            (RosterUnit.slm_model.like(search_term)) |
+            (RosterUnit.address.like(search_term))
+        )
+
+    units = query.order_by(
+        RosterUnit.retired.asc(),
+        RosterUnit.deployed.desc(),
+        RosterUnit.id.asc()
+    ).all()
+
+    one_hour_ago = datetime.utcnow() - timedelta(hours=1)
+    for unit in units:
+        unit.is_recent = bool(unit.slm_last_check and unit.slm_last_check > one_hour_ago)
+
+    if include_measurement:
+        async def fetch_measurement_state(client: httpx.AsyncClient, unit_id: str) -> str | None:
+            try:
+                response = await client.get(f"{SLMM_BASE_URL}/api/nl43/{unit_id}/measurement-state")
+                if response.status_code == 200:
+                    return response.json().get("measurement_state")
+            except Exception:
+                return None
+            return None
+
+        deployed_units = [unit for unit in units if unit.deployed and not unit.retired]
+        if deployed_units:
+            async with httpx.AsyncClient(timeout=3.0) as client:
+                tasks = [fetch_measurement_state(client, unit.id) for unit in deployed_units]
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+
+            for unit, state in zip(deployed_units, results):
+                if isinstance(state, Exception):
+                    unit.measurement_state = None
+                else:
+                    unit.measurement_state = state
+
+    return templates.TemplateResponse("partials/slm_device_list.html", {
+        "request": request,
+        "units": units
+    })
+
+
+@router.get("/live-view/{unit_id}", response_class=HTMLResponse)
+async def get_live_view(request: Request, unit_id: str, db: Session = Depends(get_db)):
+    """
+    Get live view panel for a specific SLM unit.
+    Returns HTML partial with live metrics and chart.
+    """
+    # Get unit from database
+    unit = db.query(RosterUnit).filter_by(id=unit_id, device_type="slm").first()
+
+    if not unit:
+        return templates.TemplateResponse("partials/slm_live_view_error.html", {
+            "request": request,
+            "error": f"Unit {unit_id} not found"
+        })
+
+    # Get modem information if assigned
+    modem = None
+    modem_ip = None
+    if unit.deployed_with_modem_id:
+        modem = db.query(RosterUnit).filter_by(id=unit.deployed_with_modem_id, device_type="modem").first()
+        if modem:
+            modem_ip = modem.ip_address
+        else:
+            logger.warning(f"SLM {unit_id} is assigned to modem {unit.deployed_with_modem_id} but modem not found")
+
+    # Fallback to direct slm_host if no modem assigned (backward compatibility)
+    if not modem_ip and unit.slm_host:
+        modem_ip = unit.slm_host
+        logger.info(f"Using legacy slm_host for {unit_id}: {modem_ip}")
+
+    # Try to get current status from SLMM
+    current_status = None
+    measurement_state = None
+    is_measuring = False
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            # Get measurement state
+            state_response = await client.get(
+                f"{SLMM_BASE_URL}/api/nl43/{unit_id}/measurement-state"
+            )
+            if state_response.status_code == 200:
+                state_data = state_response.json()
+                measurement_state = state_data.get("measurement_state", "Unknown")
+                is_measuring = state_data.get("is_measuring", False)
+
+            # Get live status (measurement_start_time is already stored in SLMM database)
+            status_response = await client.get(
+                f"{SLMM_BASE_URL}/api/nl43/{unit_id}/live"
+            )
+            if status_response.status_code == 200:
+                status_data = status_response.json()
+                current_status = status_data.get("data", {})
+    except Exception as e:
+        logger.error(f"Failed to get status for {unit_id}: {e}")
+
+    return templates.TemplateResponse("partials/slm_live_view.html", {
+        "request": request,
+        "unit": unit,
+        "modem": modem,
+        "modem_ip": modem_ip,
+        "current_status": current_status,
+        "measurement_state": measurement_state,
+        "is_measuring": is_measuring
+    })
+
+
+@router.post("/control/{unit_id}/{action}")
+async def control_slm(unit_id: str, action: str):
+    """
+    Send control commands to SLM (start, stop, pause, resume, reset).
+    Proxies to SLMM backend.
+    """
+    valid_actions = ["start", "stop", "pause", "resume", "reset"]
+
+    if action not in valid_actions:
+        return {"status": "error", "detail": f"Invalid action. Must be one of: {valid_actions}"}
+
+    try:
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.post(
+                f"{SLMM_BASE_URL}/api/nl43/{unit_id}/{action}"
+            )
+
+            if response.status_code == 200:
+                return response.json()
+            else:
+                return {
+                    "status": "error",
+                    "detail": f"SLMM returned status {response.status_code}"
+                }
+    except Exception as e:
+        logger.error(f"Failed to control {unit_id}: {e}")
+        return {
+            "status": "error",
+            "detail": str(e)
+        }
+
+@router.get("/config/{unit_id}", response_class=HTMLResponse)
+async def get_slm_config(request: Request, unit_id: str, db: Session = Depends(get_db)):
+    """
+    Get configuration form for a specific SLM unit.
+    Returns HTML partial with configuration form.
+    """
+    unit = db.query(RosterUnit).filter_by(id=unit_id, device_type="slm").first()
+
+    if not unit:
+        return HTMLResponse(
+            content=f'<div class="text-red-500">Unit {unit_id} not found</div>',
+            status_code=404
+        )
+
+    return templates.TemplateResponse("partials/slm_config_form.html", {
+        "request": request,
+        "unit": unit
+    })
+
+
+@router.post("/config/{unit_id}")
+async def save_slm_config(request: Request, unit_id: str, db: Session = Depends(get_db)):
+    """
+    Save SLM configuration.
+    Updates unit parameters in the database.
+    """
+    unit = db.query(RosterUnit).filter_by(id=unit_id, device_type="slm").first()
+
+    if not unit:
+        return {"status": "error", "detail": f"Unit {unit_id} not found"}
+
+    try:
+        # Get form data
+        form_data = await request.form()
+
+        # Update SLM-specific fields
+        unit.slm_model = form_data.get("slm_model") or None
+        unit.slm_serial_number = form_data.get("slm_serial_number") or None
+        unit.slm_frequency_weighting = form_data.get("slm_frequency_weighting") or None
+        unit.slm_time_weighting = form_data.get("slm_time_weighting") or None
+        unit.slm_measurement_range = form_data.get("slm_measurement_range") or None
+
+        # Update network configuration
+        modem_id = form_data.get("deployed_with_modem_id")
+        unit.deployed_with_modem_id = modem_id if modem_id else None
+
+        # Always update TCP and FTP ports (used regardless of modem assignment)
+        unit.slm_tcp_port = int(form_data.get("slm_tcp_port")) if form_data.get("slm_tcp_port") else None
+        unit.slm_ftp_port = int(form_data.get("slm_ftp_port")) if form_data.get("slm_ftp_port") else None
+
+        # Only update direct IP if no modem is assigned
+        if not modem_id:
+            unit.slm_host = form_data.get("slm_host") or None
+        else:
+            # Clear legacy direct IP field when modem is assigned
+            unit.slm_host = None
+
+        db.commit()
+        logger.info(f"Updated configuration for SLM {unit_id}")
+
+        # Sync updated configuration to SLMM cache
+        logger.info(f"Syncing SLM {unit_id} config changes to SLMM cache...")
+        result = await sync_slm_to_slmm_cache(
+            unit_id=unit_id,
+            host=unit.slm_host,  # Use the updated host from Terra-View
+            tcp_port=unit.slm_tcp_port,
+            ftp_port=unit.slm_ftp_port,
+            deployed_with_modem_id=unit.deployed_with_modem_id,  # Resolve modem IP if assigned
+            db=db
+        )
+
+        if not result["success"]:
+            logger.warning(f"SLMM cache sync warning for {unit_id}: {result['message']}")
+            # Config still saved in Terra-View (source of truth)
+
+        return {"status": "success", "unit_id": unit_id}
+
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Failed to save config for {unit_id}: {e}")
+        return {"status": "error", "detail": str(e)}
+
+
+@router.get("/test-modem/{modem_id}")
+async def test_modem_connection(modem_id: str, db: Session = Depends(get_db)):
+    """
+    Test modem connectivity with a simple ping/health check.
+    Returns response time and connection status.
+    """
+    import subprocess
+    import time
+
+    # Get modem from database
+    modem = db.query(RosterUnit).filter_by(id=modem_id, device_type="modem").first()
+
+    if not modem:
+        return {"status": "error", "detail": f"Modem {modem_id} not found"}
+
+    if not modem.ip_address:
+        return {"status": "error", "detail": f"Modem {modem_id} has no IP address configured"}
+
+    try:
+        # Ping the modem (1 packet, 2 second timeout)
+        start_time = time.time()
+        result = subprocess.run(
+            ["ping", "-c", "1", "-W", "2", modem.ip_address],
+            capture_output=True,
+            text=True,
+            timeout=3
+        )
+        response_time = int((time.time() - start_time) * 1000)  # Convert to milliseconds
+
+        if result.returncode == 0:
+            return {
+                "status": "success",
+                "modem_id": modem_id,
+                "ip_address": modem.ip_address,
+                "response_time": response_time,
+                "message": "Modem is responding to ping"
+            }
+        else:
+            return {
+                "status": "error",
+                "modem_id": modem_id,
+                "ip_address": modem.ip_address,
+                "detail": "Modem not responding to ping"
+            }
+
+    except subprocess.TimeoutExpired:
+        return {
+            "status": "error",
+            "modem_id": modem_id,
+            "ip_address": modem.ip_address,
+            "detail": "Ping timeout (> 2 seconds)"
+        }
+    except Exception as e:
+        logger.error(f"Failed to ping modem {modem_id}: {e}")
+        return {
+            "status": "error",
+            "modem_id": modem_id,
+            "detail": str(e)
+        }

backend/routers/slm_ui.py

@@ -0,0 +1,122 @@
+"""
+Sound Level Meter UI Router
+
+Provides endpoints for SLM dashboard cards, detail pages, and real-time data.
+"""
+
+from fastapi import APIRouter, Depends, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from sqlalchemy.orm import Session
+from datetime import datetime
+import httpx
+import logging
+import os
+
+from backend.database import get_db
+from backend.models import RosterUnit
+from backend.templates_config import templates
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/slm", tags=["slm-ui"])
+
+SLMM_BASE_URL = os.getenv("SLMM_BASE_URL", "http://172.19.0.1:8100")
+
+
+@router.get("/{unit_id}", response_class=HTMLResponse)
+async def slm_detail_page(request: Request, unit_id: str, db: Session = Depends(get_db)):
+    """Sound level meter detail page with controls."""
+
+    # Get roster unit
+    unit = db.query(RosterUnit).filter_by(id=unit_id).first()
+    if not unit or unit.device_type != "slm":
+        raise HTTPException(status_code=404, detail="Sound level meter not found")
+
+    return templates.TemplateResponse("slm_detail.html", {
+        "request": request,
+        "unit": unit,
+        "unit_id": unit_id
+    })
+
+
+@router.get("/api/{unit_id}/summary")
+async def get_slm_summary(unit_id: str, db: Session = Depends(get_db)):
+    """Get SLM summary data for dashboard card."""
+
+    # Get roster unit
+    unit = db.query(RosterUnit).filter_by(id=unit_id).first()
+    if not unit or unit.device_type != "slm":
+        raise HTTPException(status_code=404, detail="Sound level meter not found")
+
+    # Try to get live status from SLMM
+    status_data = None
+    try:
+        async with httpx.AsyncClient(timeout=3.0) as client:
+            response = await client.get(f"{SLMM_BASE_URL}/api/nl43/{unit_id}/status")
+            if response.status_code == 200:
+                status_data = response.json().get("data")
+    except Exception as e:
+        logger.warning(f"Failed to get SLM status for {unit_id}: {e}")
+
+    return {
+        "unit_id": unit_id,
+        "device_type": "slm",
+        "deployed": unit.deployed,
+        "model": unit.slm_model or "NL-43",
+        "location": unit.address or unit.location,
+        "coordinates": unit.coordinates,
+        "note": unit.note,
+        "status": status_data,
+        "last_check": unit.slm_last_check.isoformat() if unit.slm_last_check else None,
+    }
+
+
+@router.get("/partials/{unit_id}/card", response_class=HTMLResponse)
+async def slm_dashboard_card(request: Request, unit_id: str, db: Session = Depends(get_db)):
+    """Render SLM dashboard card partial."""
+
+    summary = await get_slm_summary(unit_id, db)
+
+    return templates.TemplateResponse("partials/slm_card.html", {
+        "request": request,
+        "slm": summary
+    })
+
+
+@router.get("/partials/{unit_id}/controls", response_class=HTMLResponse)
+async def slm_controls_partial(request: Request, unit_id: str, db: Session = Depends(get_db)):
+    """Render SLM control panel partial."""
+
+    unit = db.query(RosterUnit).filter_by(id=unit_id).first()
+    if not unit or unit.device_type != "slm":
+        raise HTTPException(status_code=404, detail="Sound level meter not found")
+
+    # Get current status from SLMM
+    measurement_state = None
+    battery_level = None
+    try:
+        async with httpx.AsyncClient(timeout=3.0) as client:
+            # Get measurement state
+            state_response = await client.get(
+                f"{SLMM_BASE_URL}/api/nl43/{unit_id}/measurement-state"
+            )
+            if state_response.status_code == 200:
+                measurement_state = state_response.json().get("measurement_state")
+
+            # Get battery level
+            battery_response = await client.get(
+                f"{SLMM_BASE_URL}/api/nl43/{unit_id}/battery"
+            )
+            if battery_response.status_code == 200:
+                battery_level = battery_response.json().get("battery_level")
+    except Exception as e:
+        logger.warning(f"Failed to get SLM control data for {unit_id}: {e}")
+
+    return templates.TemplateResponse("partials/slm_controls.html", {
+        "request": request,
+        "unit_id": unit_id,
+        "unit": unit,
+        "measurement_state": measurement_state,
+        "battery_level": battery_level,
+        "is_measuring": measurement_state == "Start"
+    })

backend/routers/slmm.py

@@ -0,0 +1,301 @@
+"""
+SLMM (Sound Level Meter Manager) Proxy Router
+
+Proxies requests from SFM to the standalone SLMM backend service.
+SLMM runs on port 8100 and handles NL43/NL53 sound level meter communication.
+"""
+
+from fastapi import APIRouter, HTTPException, Request, Response, WebSocket, WebSocketDisconnect
+from fastapi.responses import StreamingResponse
+import httpx
+import websockets
+import asyncio
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api/slmm", tags=["slmm"])
+
+# SLMM backend URL - configurable via environment variable
+SLMM_BASE_URL = os.getenv("SLMM_BASE_URL", "http://localhost:8100")
+# WebSocket URL derived from HTTP URL
+SLMM_WS_BASE_URL = SLMM_BASE_URL.replace("http://", "ws://").replace("https://", "wss://")
+
+
+@router.get("/health")
+async def check_slmm_health():
+    """
+    Check if the SLMM backend service is reachable and healthy.
+    """
+    try:
+        async with httpx.AsyncClient(timeout=5.0) as client:
+            response = await client.get(f"{SLMM_BASE_URL}/health")
+
+            if response.status_code == 200:
+                data = response.json()
+                return {
+                    "status": "ok",
+                    "slmm_status": "connected",
+                    "slmm_url": SLMM_BASE_URL,
+                    "slmm_version": data.get("version", "unknown"),
+                    "slmm_response": data
+                }
+            else:
+                return {
+                    "status": "degraded",
+                    "slmm_status": "error",
+                    "slmm_url": SLMM_BASE_URL,
+                    "detail": f"SLMM returned status {response.status_code}"
+                }
+
+    except httpx.ConnectError:
+        return {
+            "status": "error",
+            "slmm_status": "unreachable",
+            "slmm_url": SLMM_BASE_URL,
+            "detail": "Cannot connect to SLMM backend. Is it running?"
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "slmm_status": "error",
+            "slmm_url": SLMM_BASE_URL,
+            "detail": str(e)
+        }
+
+
+# WebSocket routes MUST come before the catch-all route
+@router.websocket("/{unit_id}/stream")
+async def proxy_websocket_stream(websocket: WebSocket, unit_id: str):
+    """
+    Proxy WebSocket connections to SLMM's /stream endpoint.
+
+    This allows real-time streaming of measurement data from NL43 devices
+    through the SFM unified interface.
+    """
+    await websocket.accept()
+    logger.info(f"WebSocket connection accepted for SLMM unit {unit_id}")
+
+    # Build target WebSocket URL
+    target_ws_url = f"{SLMM_WS_BASE_URL}/api/nl43/{unit_id}/stream"
+    logger.info(f"Connecting to SLMM WebSocket: {target_ws_url}")
+
+    backend_ws = None
+
+    try:
+        # Connect to SLMM backend WebSocket
+        backend_ws = await websockets.connect(target_ws_url)
+        logger.info(f"Connected to SLMM backend WebSocket for {unit_id}")
+
+        # Create tasks for bidirectional communication
+        async def forward_to_backend():
+            """Forward messages from client to SLMM backend"""
+            try:
+                while True:
+                    data = await websocket.receive_text()
+                    await backend_ws.send(data)
+            except WebSocketDisconnect:
+                logger.info(f"Client WebSocket disconnected for {unit_id}")
+            except Exception as e:
+                logger.error(f"Error forwarding to backend: {e}")
+
+        async def forward_to_client():
+            """Forward messages from SLMM backend to client"""
+            try:
+                async for message in backend_ws:
+                    await websocket.send_text(message)
+            except websockets.exceptions.ConnectionClosed:
+                logger.info(f"Backend WebSocket closed for {unit_id}")
+            except Exception as e:
+                logger.error(f"Error forwarding to client: {e}")
+
+        # Run both forwarding tasks concurrently
+        await asyncio.gather(
+            forward_to_backend(),
+            forward_to_client(),
+            return_exceptions=True
+        )
+
+    except websockets.exceptions.WebSocketException as e:
+        logger.error(f"WebSocket error connecting to SLMM backend: {e}")
+        try:
+            await websocket.send_json({
+                "error": "Failed to connect to SLMM backend",
+                "detail": str(e)
+            })
+        except Exception:
+            pass
+    except Exception as e:
+        logger.error(f"Unexpected error in WebSocket proxy for {unit_id}: {e}")
+        try:
+            await websocket.send_json({
+                "error": "Internal server error",
+                "detail": str(e)
+            })
+        except Exception:
+            pass
+    finally:
+        # Clean up connections
+        if backend_ws:
+            try:
+                await backend_ws.close()
+            except Exception:
+                pass
+        try:
+            await websocket.close()
+        except Exception:
+            pass
+        logger.info(f"WebSocket proxy closed for {unit_id}")
+
+
+@router.websocket("/{unit_id}/live")
+async def proxy_websocket_live(websocket: WebSocket, unit_id: str):
+    """
+    Proxy WebSocket connections to SLMM's /live endpoint.
+
+    Alternative WebSocket endpoint that may be used by some frontend components.
+    """
+    await websocket.accept()
+    logger.info(f"WebSocket connection accepted for SLMM unit {unit_id} (live endpoint)")
+
+    # Build target WebSocket URL - try /stream endpoint as SLMM uses that for WebSocket
+    target_ws_url = f"{SLMM_WS_BASE_URL}/api/nl43/{unit_id}/stream"
+    logger.info(f"Connecting to SLMM WebSocket: {target_ws_url}")
+
+    backend_ws = None
+
+    try:
+        # Connect to SLMM backend WebSocket
+        backend_ws = await websockets.connect(target_ws_url)
+        logger.info(f"Connected to SLMM backend WebSocket for {unit_id} (live endpoint)")
+
+        # Create tasks for bidirectional communication
+        async def forward_to_backend():
+            """Forward messages from client to SLMM backend"""
+            try:
+                while True:
+                    data = await websocket.receive_text()
+                    await backend_ws.send(data)
+            except WebSocketDisconnect:
+                logger.info(f"Client WebSocket disconnected for {unit_id} (live)")
+            except Exception as e:
+                logger.error(f"Error forwarding to backend (live): {e}")
+
+        async def forward_to_client():
+            """Forward messages from SLMM backend to client"""
+            try:
+                async for message in backend_ws:
+                    await websocket.send_text(message)
+            except websockets.exceptions.ConnectionClosed:
+                logger.info(f"Backend WebSocket closed for {unit_id} (live)")
+            except Exception as e:
+                logger.error(f"Error forwarding to client (live): {e}")
+
+        # Run both forwarding tasks concurrently
+        await asyncio.gather(
+            forward_to_backend(),
+            forward_to_client(),
+            return_exceptions=True
+        )
+
+    except websockets.exceptions.WebSocketException as e:
+        logger.error(f"WebSocket error connecting to SLMM backend (live): {e}")
+        try:
+            await websocket.send_json({
+                "error": "Failed to connect to SLMM backend",
+                "detail": str(e)
+            })
+        except Exception:
+            pass
+    except Exception as e:
+        logger.error(f"Unexpected error in WebSocket proxy for {unit_id} (live): {e}")
+        try:
+            await websocket.send_json({
+                "error": "Internal server error",
+                "detail": str(e)
+            })
+        except Exception:
+            pass
+    finally:
+        # Clean up connections
+        if backend_ws:
+            try:
+                await backend_ws.close()
+            except Exception:
+                pass
+        try:
+            await websocket.close()
+        except Exception:
+            pass
+        logger.info(f"WebSocket proxy closed for {unit_id} (live)")
+
+
+# HTTP catch-all route MUST come after specific routes (including WebSocket routes)
+@router.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
+async def proxy_to_slmm(path: str, request: Request):
+    """
+    Proxy all requests to the SLMM backend service.
+
+    This allows SFM to act as a unified frontend for all device types,
+    while SLMM remains a standalone backend service.
+    """
+    # Build target URL
+    target_url = f"{SLMM_BASE_URL}/api/nl43/{path}"
+
+    # Get query parameters
+    query_params = dict(request.query_params)
+
+    # Get request body if present
+    body = None
+    if request.method in ["POST", "PUT", "PATCH"]:
+        try:
+            body = await request.body()
+        except Exception as e:
+            logger.error(f"Failed to read request body: {e}")
+            body = None
+
+    # Get headers (exclude host and other proxy-specific headers)
+    headers = dict(request.headers)
+    headers_to_exclude = ["host", "content-length", "transfer-encoding", "connection"]
+    proxy_headers = {k: v for k, v in headers.items() if k.lower() not in headers_to_exclude}
+
+    logger.info(f"Proxying {request.method} request to SLMM: {target_url}")
+
+    try:
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            # Forward the request to SLMM
+            response = await client.request(
+                method=request.method,
+                url=target_url,
+                params=query_params,
+                headers=proxy_headers,
+                content=body
+            )
+
+            # Return the response from SLMM
+            return Response(
+                content=response.content,
+                status_code=response.status_code,
+                headers=dict(response.headers),
+                media_type=response.headers.get("content-type")
+            )
+
+    except httpx.ConnectError:
+        logger.error(f"Failed to connect to SLMM backend at {SLMM_BASE_URL}")
+        raise HTTPException(
+            status_code=503,
+            detail=f"SLMM backend service unavailable. Is SLMM running on {SLMM_BASE_URL}?"
+        )
+    except httpx.TimeoutException:
+        logger.error(f"Timeout connecting to SLMM backend at {SLMM_BASE_URL}")
+        raise HTTPException(
+            status_code=504,
+            detail="SLMM backend timeout"
+        )
+    except Exception as e:
+        logger.error(f"Error proxying to SLMM: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to proxy request to SLMM: {str(e)}"
+        )

backend/routers/units.py

@@ -3,8 +3,9 @@ from sqlalchemy.orm import Session
 from datetime import datetime
 from typing import Dict, Any
 
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.services.snapshot import emit_status_snapshot
+from backend.services.snapshot import emit_status_snapshot
+from backend.models import RosterUnit
 
 router = APIRouter(prefix="/api", tags=["units"])
 
@@ -42,3 +43,32 @@ def get_unit_detail(unit_id: str, db: Session = Depends(get_db)):
         "note": unit_data.get("note", ""),
         "coordinates": coords
     }
+
+
+@router.get("/units/{unit_id}")
+def get_unit_by_id(unit_id: str, db: Session = Depends(get_db)):
+    """
+    Get unit data directly from the roster (for settings/configuration).
+    """
+    unit = db.query(RosterUnit).filter_by(id=unit_id).first()
+
+    if not unit:
+        raise HTTPException(status_code=404, detail=f"Unit {unit_id} not found")
+
+    return {
+        "id": unit.id,
+        "unit_type": unit.unit_type,
+        "device_type": unit.device_type,
+        "deployed": unit.deployed,
+        "retired": unit.retired,
+        "note": unit.note,
+        "location": unit.location,
+        "address": unit.address,
+        "coordinates": unit.coordinates,
+        "slm_host": unit.slm_host,
+        "slm_tcp_port": unit.slm_tcp_port,
+        "slm_ftp_port": unit.slm_ftp_port,
+        "slm_model": unit.slm_model,
+        "slm_serial_number": unit.slm_serial_number,
+        "deployed_with_modem_id": unit.deployed_with_modem_id
+    }

backend/routes.py

@@ -4,8 +4,8 @@ from pydantic import BaseModel
 from datetime import datetime
 from typing import Optional, List
 
-from app.seismo.database import get_db
+from backend.database import get_db
-from app.seismo.models import Emitter
+from backend.models import Emitter
 
 router = APIRouter()
 

backend/services/alert_service.py

@@ -0,0 +1,462 @@
+"""
+Alert Service
+
+Manages in-app alerts for device status changes and system events.
+Provides foundation for future notification channels (email, webhook).
+"""
+
+import json
+import uuid
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any
+
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_
+
+from backend.models import Alert, RosterUnit
+
+logger = logging.getLogger(__name__)
+
+
+class AlertService:
+    """
+    Service for managing alerts.
+
+    Handles alert lifecycle:
+    - Create alerts from various triggers
+    - Query active alerts
+    - Acknowledge/resolve/dismiss alerts
+    - (Future) Dispatch to notification channels
+    """
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create_alert(
+        self,
+        alert_type: str,
+        title: str,
+        message: str = None,
+        severity: str = "warning",
+        unit_id: str = None,
+        project_id: str = None,
+        location_id: str = None,
+        schedule_id: str = None,
+        metadata: dict = None,
+        expires_hours: int = 24,
+    ) -> Alert:
+        """
+        Create a new alert.
+
+        Args:
+            alert_type: Type of alert (device_offline, device_online, schedule_failed)
+            title: Short alert title
+            message: Detailed description
+            severity: info, warning, or critical
+            unit_id: Related unit ID (optional)
+            project_id: Related project ID (optional)
+            location_id: Related location ID (optional)
+            schedule_id: Related schedule ID (optional)
+            metadata: Additional JSON data
+            expires_hours: Hours until auto-expiry (default 24)
+
+        Returns:
+            Created Alert instance
+        """
+        alert = Alert(
+            id=str(uuid.uuid4()),
+            alert_type=alert_type,
+            title=title,
+            message=message,
+            severity=severity,
+            unit_id=unit_id,
+            project_id=project_id,
+            location_id=location_id,
+            schedule_id=schedule_id,
+            alert_metadata=json.dumps(metadata) if metadata else None,
+            status="active",
+            expires_at=datetime.utcnow() + timedelta(hours=expires_hours),
+        )
+
+        self.db.add(alert)
+        self.db.commit()
+        self.db.refresh(alert)
+
+        logger.info(f"Created alert: {alert.title} ({alert.alert_type})")
+        return alert
+
+    def create_device_offline_alert(
+        self,
+        unit_id: str,
+        consecutive_failures: int = 0,
+        last_error: str = None,
+    ) -> Optional[Alert]:
+        """
+        Create alert when device becomes unreachable.
+
+        Only creates if no active offline alert exists for this device.
+
+        Args:
+            unit_id: The unit that went offline
+            consecutive_failures: Number of consecutive poll failures
+            last_error: Last error message from polling
+
+        Returns:
+            Created Alert or None if alert already exists
+        """
+        # Check if active offline alert already exists
+        existing = self.db.query(Alert).filter(
+            and_(
+                Alert.unit_id == unit_id,
+                Alert.alert_type == "device_offline",
+                Alert.status == "active",
+            )
+        ).first()
+
+        if existing:
+            logger.debug(f"Offline alert already exists for {unit_id}")
+            return None
+
+        # Get unit info for title
+        unit = self.db.query(RosterUnit).filter_by(id=unit_id).first()
+        unit_name = unit.id if unit else unit_id
+
+        # Determine severity based on failure count
+        severity = "critical" if consecutive_failures >= 5 else "warning"
+
+        return self.create_alert(
+            alert_type="device_offline",
+            title=f"{unit_name} is offline",
+            message=f"Device has been unreachable after {consecutive_failures} failed connection attempts."
+                    + (f" Last error: {last_error}" if last_error else ""),
+            severity=severity,
+            unit_id=unit_id,
+            metadata={
+                "consecutive_failures": consecutive_failures,
+                "last_error": last_error,
+            },
+            expires_hours=48,  # Offline alerts stay longer
+        )
+
+    def resolve_device_offline_alert(self, unit_id: str) -> Optional[Alert]:
+        """
+        Auto-resolve offline alert when device comes back online.
+
+        Also creates an "device_online" info alert to notify user.
+
+        Args:
+            unit_id: The unit that came back online
+
+        Returns:
+            The resolved Alert or None if no alert existed
+        """
+        # Find active offline alert
+        alert = self.db.query(Alert).filter(
+            and_(
+                Alert.unit_id == unit_id,
+                Alert.alert_type == "device_offline",
+                Alert.status == "active",
+            )
+        ).first()
+
+        if not alert:
+            return None
+
+        # Resolve the offline alert
+        alert.status = "resolved"
+        alert.resolved_at = datetime.utcnow()
+        self.db.commit()
+
+        logger.info(f"Resolved offline alert for {unit_id}")
+
+        # Create online notification
+        unit = self.db.query(RosterUnit).filter_by(id=unit_id).first()
+        unit_name = unit.id if unit else unit_id
+
+        self.create_alert(
+            alert_type="device_online",
+            title=f"{unit_name} is back online",
+            message="Device connection has been restored.",
+            severity="info",
+            unit_id=unit_id,
+            expires_hours=6,  # Info alerts expire quickly
+        )
+
+        return alert
+
+    def create_schedule_failed_alert(
+        self,
+        schedule_id: str,
+        action_type: str,
+        unit_id: str = None,
+        error_message: str = None,
+        project_id: str = None,
+        location_id: str = None,
+    ) -> Alert:
+        """
+        Create alert when a scheduled action fails.
+
+        Args:
+            schedule_id: The ScheduledAction or RecurringSchedule ID
+            action_type: start, stop, download, cycle
+            unit_id: Related unit
+            error_message: Error from execution
+            project_id: Related project
+            location_id: Related location
+
+        Returns:
+            Created Alert
+        """
+        return self.create_alert(
+            alert_type="schedule_failed",
+            title=f"Scheduled {action_type} failed",
+            message=error_message or f"The scheduled {action_type} action did not complete successfully.",
+            severity="warning",
+            unit_id=unit_id,
+            project_id=project_id,
+            location_id=location_id,
+            schedule_id=schedule_id,
+            metadata={"action_type": action_type},
+            expires_hours=24,
+        )
+
+    def create_schedule_completed_alert(
+        self,
+        schedule_id: str,
+        action_type: str,
+        unit_id: str = None,
+        project_id: str = None,
+        location_id: str = None,
+        metadata: dict = None,
+    ) -> Alert:
+        """
+        Create alert when a scheduled action completes successfully.
+
+        Args:
+            schedule_id: The ScheduledAction ID
+            action_type: start, stop, download, cycle
+            unit_id: Related unit
+            project_id: Related project
+            location_id: Related location
+            metadata: Additional info (e.g., downloaded folder, index numbers)
+
+        Returns:
+            Created Alert
+        """
+        # Build descriptive message based on action type and metadata
+        if action_type == "stop" and metadata:
+            download_folder = metadata.get("downloaded_folder")
+            download_success = metadata.get("download_success", False)
+            if download_success and download_folder:
+                message = f"Measurement stopped and data downloaded ({download_folder})"
+            elif download_success is False and metadata.get("download_attempted"):
+                message = "Measurement stopped but download failed"
+            else:
+                message = "Measurement stopped successfully"
+        elif action_type == "start" and metadata:
+            new_index = metadata.get("new_index")
+            if new_index is not None:
+                message = f"Measurement started (index {new_index:04d})"
+            else:
+                message = "Measurement started successfully"
+        else:
+            message = f"Scheduled {action_type} completed successfully"
+
+        return self.create_alert(
+            alert_type="schedule_completed",
+            title=f"Scheduled {action_type} completed",
+            message=message,
+            severity="info",
+            unit_id=unit_id,
+            project_id=project_id,
+            location_id=location_id,
+            schedule_id=schedule_id,
+            metadata={"action_type": action_type, **(metadata or {})},
+            expires_hours=12,  # Info alerts expire quickly
+        )
+
+    def get_active_alerts(
+        self,
+        project_id: str = None,
+        unit_id: str = None,
+        alert_type: str = None,
+        min_severity: str = None,
+        limit: int = 50,
+    ) -> List[Alert]:
+        """
+        Query active alerts with optional filters.
+
+        Args:
+            project_id: Filter by project
+            unit_id: Filter by unit
+            alert_type: Filter by alert type
+            min_severity: Minimum severity (info, warning, critical)
+            limit: Maximum results
+
+        Returns:
+            List of matching alerts
+        """
+        query = self.db.query(Alert).filter(Alert.status == "active")
+
+        if project_id:
+            query = query.filter(Alert.project_id == project_id)
+
+        if unit_id:
+            query = query.filter(Alert.unit_id == unit_id)
+
+        if alert_type:
+            query = query.filter(Alert.alert_type == alert_type)
+
+        if min_severity:
+            # Map severity to numeric for comparison
+            severity_levels = {"info": 1, "warning": 2, "critical": 3}
+            min_level = severity_levels.get(min_severity, 1)
+
+            if min_level == 2:
+                query = query.filter(Alert.severity.in_(["warning", "critical"]))
+            elif min_level == 3:
+                query = query.filter(Alert.severity == "critical")
+
+        return query.order_by(Alert.created_at.desc()).limit(limit).all()
+
+    def get_all_alerts(
+        self,
+        status: str = None,
+        project_id: str = None,
+        unit_id: str = None,
+        alert_type: str = None,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> List[Alert]:
+        """
+        Query all alerts with optional filters (includes non-active).
+
+        Args:
+            status: Filter by status (active, acknowledged, resolved, dismissed)
+            project_id: Filter by project
+            unit_id: Filter by unit
+            alert_type: Filter by alert type
+            limit: Maximum results
+            offset: Pagination offset
+
+        Returns:
+            List of matching alerts
+        """
+        query = self.db.query(Alert)
+
+        if status:
+            query = query.filter(Alert.status == status)
+
+        if project_id:
+            query = query.filter(Alert.project_id == project_id)
+
+        if unit_id:
+            query = query.filter(Alert.unit_id == unit_id)
+
+        if alert_type:
+            query = query.filter(Alert.alert_type == alert_type)
+
+        return (
+            query.order_by(Alert.created_at.desc())
+            .offset(offset)
+            .limit(limit)
+            .all()
+        )
+
+    def get_active_alert_count(self) -> int:
+        """Get count of active alerts for badge display."""
+        return self.db.query(Alert).filter(Alert.status == "active").count()
+
+    def acknowledge_alert(self, alert_id: str) -> Optional[Alert]:
+        """
+        Mark alert as acknowledged.
+
+        Args:
+            alert_id: Alert to acknowledge
+
+        Returns:
+            Updated Alert or None if not found
+        """
+        alert = self.db.query(Alert).filter_by(id=alert_id).first()
+        if not alert:
+            return None
+
+        alert.status = "acknowledged"
+        alert.acknowledged_at = datetime.utcnow()
+        self.db.commit()
+
+        logger.info(f"Acknowledged alert: {alert.title}")
+        return alert
+
+    def dismiss_alert(self, alert_id: str) -> Optional[Alert]:
+        """
+        Dismiss alert (user chose to ignore).
+
+        Args:
+            alert_id: Alert to dismiss
+
+        Returns:
+            Updated Alert or None if not found
+        """
+        alert = self.db.query(Alert).filter_by(id=alert_id).first()
+        if not alert:
+            return None
+
+        alert.status = "dismissed"
+        self.db.commit()
+
+        logger.info(f"Dismissed alert: {alert.title}")
+        return alert
+
+    def resolve_alert(self, alert_id: str) -> Optional[Alert]:
+        """
+        Manually resolve an alert.
+
+        Args:
+            alert_id: Alert to resolve
+
+        Returns:
+            Updated Alert or None if not found
+        """
+        alert = self.db.query(Alert).filter_by(id=alert_id).first()
+        if not alert:
+            return None
+
+        alert.status = "resolved"
+        alert.resolved_at = datetime.utcnow()
+        self.db.commit()
+
+        logger.info(f"Resolved alert: {alert.title}")
+        return alert
+
+    def cleanup_expired_alerts(self) -> int:
+        """
+        Remove alerts past their expiration time.
+
+        Returns:
+            Number of alerts cleaned up
+        """
+        now = datetime.utcnow()
+        expired = self.db.query(Alert).filter(
+            and_(
+                Alert.expires_at.isnot(None),
+                Alert.expires_at < now,
+                Alert.status == "active",
+            )
+        ).all()
+
+        count = len(expired)
+        for alert in expired:
+            alert.status = "dismissed"
+
+        if count > 0:
+            self.db.commit()
+            logger.info(f"Cleaned up {count} expired alerts")
+
+        return count
+
+
+def get_alert_service(db: Session) -> AlertService:
+    """Get an AlertService instance with the given database session."""
+    return AlertService(db)

backend/services/backup_scheduler.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from typing import Optional
 import logging
 
-from app.seismo.services.database_backup import DatabaseBackupService
+from backend.services.database_backup import DatabaseBackupService
 
 logger = logging.getLogger(__name__)
 

backend/services/device_controller.py

@@ -0,0 +1,603 @@
+"""
+Device Controller Service
+
+Routes device operations to the appropriate backend module:
+- SLMM for sound level meters
+- SFM for seismographs (future implementation)
+
+This abstraction allows Projects system to work with any device type
+without knowing the underlying communication protocol.
+"""
+
+from typing import Dict, Any, Optional, List
+from backend.services.slmm_client import get_slmm_client, SLMMClientError
+
+
+class DeviceControllerError(Exception):
+    """Base exception for device controller errors."""
+    pass
+
+
+class UnsupportedDeviceTypeError(DeviceControllerError):
+    """Raised when device type is not supported."""
+    pass
+
+
+class DeviceController:
+    """
+    Unified interface for controlling all device types.
+
+    Routes commands to appropriate backend module based on device_type.
+
+    Usage:
+        controller = DeviceController()
+        await controller.start_recording("nl43-001", "slm", config={})
+        await controller.stop_recording("seismo-042", "seismograph")
+    """
+
+    def __init__(self):
+        self.slmm_client = get_slmm_client()
+
+    # ========================================================================
+    # Recording Control
+    # ========================================================================
+
+    async def start_recording(
+        self,
+        unit_id: str,
+        device_type: str,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Start recording on a device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+            config: Device-specific recording configuration
+
+        Returns:
+            Response dict from device module
+
+        Raises:
+            UnsupportedDeviceTypeError: Device type not supported
+            DeviceControllerError: Operation failed
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.start_recording(unit_id, config)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            # TODO: Implement SFM client for seismograph control
+            # For now, return a placeholder response
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph recording control not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(
+                f"Device type '{device_type}' is not supported. "
+                f"Supported types: slm, seismograph"
+            )
+
+    async def stop_recording(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Stop recording on a device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.stop_recording(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            # TODO: Implement SFM client
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph recording control not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    async def pause_recording(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Pause recording on a device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.pause_recording(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph pause not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    async def resume_recording(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Resume paused recording on a device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.resume_recording(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph resume not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # Status & Monitoring
+    # ========================================================================
+
+    async def get_device_status(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Get current device status.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Status dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.get_unit_status(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            # TODO: Implement SFM status check
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph status not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    async def get_live_data(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Get live data from device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Live data dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.get_live_data(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph live data not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # Data Download
+    # ========================================================================
+
+    async def download_files(
+        self,
+        unit_id: str,
+        device_type: str,
+        destination_path: str,
+        files: Optional[List[str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Download data files from device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+            destination_path: Local path to save files
+            files: List of filenames, or None for all
+
+        Returns:
+            Download result with file list
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.download_files(
+                    unit_id,
+                    destination_path,
+                    files,
+                )
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            # TODO: Implement SFM file download
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph file download not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # FTP Control
+    # ========================================================================
+
+    async def enable_ftp(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Enable FTP server on device.
+
+        Must be called before downloading files.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict with status
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.enable_ftp(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph FTP not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    async def disable_ftp(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Disable FTP server on device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict with status
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.disable_ftp(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph FTP not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # Device Configuration
+    # ========================================================================
+
+    async def update_device_config(
+        self,
+        unit_id: str,
+        device_type: str,
+        config: Dict[str, Any],
+    ) -> Dict[str, Any]:
+        """
+        Update device configuration.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+            config: Configuration parameters
+
+        Returns:
+            Updated config from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.update_unit_config(
+                    unit_id,
+                    host=config.get("host"),
+                    tcp_port=config.get("tcp_port"),
+                    ftp_port=config.get("ftp_port"),
+                    ftp_username=config.get("ftp_username"),
+                    ftp_password=config.get("ftp_password"),
+                )
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph config update not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # Store/Index Management
+    # ========================================================================
+
+    async def increment_index(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Increment the store/index number on a device.
+
+        For SLMs, this increments the store name to prevent "overwrite data?" prompts.
+        Should be called before starting a new measurement if auto_increment_index is enabled.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict with old_index and new_index
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.increment_index(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            # Seismographs may not have the same concept of store index
+            return {
+                "status": "not_applicable",
+                "message": "Index increment not applicable for seismographs",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    async def get_index_number(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> Dict[str, Any]:
+        """
+        Get current store/index number from device.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            Response dict with current index_number
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.get_index_number(unit_id)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_applicable",
+                "message": "Index number not applicable for seismographs",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # Cycle Commands (for scheduled automation)
+    # ========================================================================
+
+    async def start_cycle(
+        self,
+        unit_id: str,
+        device_type: str,
+        sync_clock: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Execute complete start cycle for scheduled automation.
+
+        This handles the full pre-recording workflow:
+        1. Sync device clock to server time
+        2. Find next safe index (with overwrite protection)
+        3. Start measurement
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+            sync_clock: Whether to sync device clock to server time
+
+        Returns:
+            Response dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.start_cycle(unit_id, sync_clock)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph start cycle not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    async def stop_cycle(
+        self,
+        unit_id: str,
+        device_type: str,
+        download: bool = True,
+    ) -> Dict[str, Any]:
+        """
+        Execute complete stop cycle for scheduled automation.
+
+        This handles the full post-recording workflow:
+        1. Stop measurement
+        2. Enable FTP
+        3. Download measurement folder
+        4. Verify download
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+            download: Whether to download measurement data
+
+        Returns:
+            Response dict from device module
+        """
+        if device_type == "slm":
+            try:
+                return await self.slmm_client.stop_cycle(unit_id, download)
+            except SLMMClientError as e:
+                raise DeviceControllerError(f"SLMM error: {str(e)}")
+
+        elif device_type == "seismograph":
+            return {
+                "status": "not_implemented",
+                "message": "Seismograph stop cycle not yet implemented",
+                "unit_id": unit_id,
+            }
+
+        else:
+            raise UnsupportedDeviceTypeError(f"Unsupported device type: {device_type}")
+
+    # ========================================================================
+    # Health Check
+    # ========================================================================
+
+    async def check_device_connectivity(
+        self,
+        unit_id: str,
+        device_type: str,
+    ) -> bool:
+        """
+        Check if device is reachable.
+
+        Args:
+            unit_id: Unit identifier
+            device_type: "slm" | "seismograph"
+
+        Returns:
+            True if device is reachable, False otherwise
+        """
+        if device_type == "slm":
+            try:
+                status = await self.slmm_client.get_unit_status(unit_id)
+                return status.get("last_seen") is not None
+            except:
+                return False
+
+        elif device_type == "seismograph":
+            # TODO: Implement SFM connectivity check
+            return False
+
+        else:
+            return False
+
+
+# Singleton instance
+_default_controller: Optional[DeviceController] = None
+
+
+def get_device_controller() -> DeviceController:
+    """
+    Get the default device controller instance.
+
+    Returns:
+        DeviceController instance
+    """
+    global _default_controller
+    if _default_controller is None:
+        _default_controller = DeviceController()
+    return _default_controller

backend/services/device_status_monitor.py

@@ -0,0 +1,184 @@
+"""
+Device Status Monitor
+
+Background task that monitors device reachability via SLMM polling status
+and triggers alerts when devices go offline or come back online.
+
+This service bridges SLMM's device polling with Terra-View's alert system.
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import Optional, Dict
+
+from backend.database import SessionLocal
+from backend.services.slmm_client import get_slmm_client, SLMMClientError
+from backend.services.alert_service import get_alert_service
+
+logger = logging.getLogger(__name__)
+
+
+class DeviceStatusMonitor:
+    """
+    Monitors device reachability via SLMM's polling status endpoint.
+
+    Detects state transitions (online→offline, offline→online) and
+    triggers AlertService to create/resolve alerts.
+
+    Usage:
+        monitor = DeviceStatusMonitor()
+        await monitor.start()  # Start background monitoring
+        monitor.stop()  # Stop monitoring
+    """
+
+    def __init__(self, check_interval: int = 60):
+        """
+        Initialize the monitor.
+
+        Args:
+            check_interval: Seconds between status checks (default: 60)
+        """
+        self.check_interval = check_interval
+        self.running = False
+        self.task: Optional[asyncio.Task] = None
+        self.slmm_client = get_slmm_client()
+
+        # Track previous device states to detect transitions
+        self._device_states: Dict[str, bool] = {}
+
+    async def start(self):
+        """Start the monitoring background task."""
+        if self.running:
+            logger.warning("DeviceStatusMonitor is already running")
+            return
+
+        self.running = True
+        self.task = asyncio.create_task(self._monitor_loop())
+        logger.info(f"DeviceStatusMonitor started (checking every {self.check_interval}s)")
+
+    def stop(self):
+        """Stop the monitoring background task."""
+        self.running = False
+        if self.task:
+            self.task.cancel()
+        logger.info("DeviceStatusMonitor stopped")
+
+    async def _monitor_loop(self):
+        """Main monitoring loop."""
+        while self.running:
+            try:
+                await self._check_all_devices()
+            except Exception as e:
+                logger.error(f"Error in device status monitor: {e}", exc_info=True)
+
+            # Sleep in small intervals for graceful shutdown
+            for _ in range(self.check_interval):
+                if not self.running:
+                    break
+                await asyncio.sleep(1)
+
+        logger.info("DeviceStatusMonitor loop exited")
+
+    async def _check_all_devices(self):
+        """
+        Fetch polling status from SLMM and detect state transitions.
+
+        Uses GET /api/slmm/_polling/status (proxied to SLMM)
+        """
+        try:
+            # Get status from SLMM
+            status_response = await self.slmm_client.get_polling_status()
+            devices = status_response.get("devices", [])
+
+            if not devices:
+                logger.debug("No devices in polling status response")
+                return
+
+            db = SessionLocal()
+            try:
+                alert_service = get_alert_service(db)
+
+                for device in devices:
+                    unit_id = device.get("unit_id")
+                    if not unit_id:
+                        continue
+
+                    is_reachable = device.get("is_reachable", True)
+                    previous_reachable = self._device_states.get(unit_id)
+
+                    # Skip if this is the first check (no previous state)
+                    if previous_reachable is None:
+                        self._device_states[unit_id] = is_reachable
+                        logger.debug(f"Initial state for {unit_id}: reachable={is_reachable}")
+                        continue
+
+                    # Detect offline transition (was online, now offline)
+                    if previous_reachable and not is_reachable:
+                        logger.warning(f"Device {unit_id} went OFFLINE")
+                        alert_service.create_device_offline_alert(
+                            unit_id=unit_id,
+                            consecutive_failures=device.get("consecutive_failures", 0),
+                            last_error=device.get("last_error"),
+                        )
+
+                    # Detect online transition (was offline, now online)
+                    elif not previous_reachable and is_reachable:
+                        logger.info(f"Device {unit_id} came back ONLINE")
+                        alert_service.resolve_device_offline_alert(unit_id)
+
+                    # Update tracked state
+                    self._device_states[unit_id] = is_reachable
+
+                # Cleanup expired alerts while we're here
+                alert_service.cleanup_expired_alerts()
+
+            finally:
+                db.close()
+
+        except SLMMClientError as e:
+            logger.warning(f"Could not reach SLMM for status check: {e}")
+        except Exception as e:
+            logger.error(f"Error checking device status: {e}", exc_info=True)
+
+    def get_tracked_devices(self) -> Dict[str, bool]:
+        """
+        Get the current tracked device states.
+
+        Returns:
+            Dict mapping unit_id to is_reachable status
+        """
+        return dict(self._device_states)
+
+    def clear_tracked_devices(self):
+        """Clear all tracked device states (useful for testing)."""
+        self._device_states.clear()
+
+
+# Singleton instance
+_monitor_instance: Optional[DeviceStatusMonitor] = None
+
+
+def get_device_status_monitor() -> DeviceStatusMonitor:
+    """
+    Get the device status monitor singleton instance.
+
+    Returns:
+        DeviceStatusMonitor instance
+    """
+    global _monitor_instance
+    if _monitor_instance is None:
+        _monitor_instance = DeviceStatusMonitor()
+    return _monitor_instance
+
+
+async def start_device_status_monitor():
+    """Start the global device status monitor."""
+    monitor = get_device_status_monitor()
+    await monitor.start()
+
+
+def stop_device_status_monitor():
+    """Stop the global device status monitor."""
+    monitor = get_device_status_monitor()
+    monitor.stop()

backend/services/fleet_calendar_service.py

@@ -0,0 +1,668 @@
+"""
+Fleet Calendar Service
+
+Business logic for:
+- Calculating unit availability on any given date
+- Calibration status tracking (valid, expiring soon, expired)
+- Job reservation management
+- Conflict detection (calibration expires mid-job)
+"""
+
+from datetime import date, datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+from sqlalchemy.orm import Session
+from sqlalchemy import and_, or_
+
+from backend.models import (
+    RosterUnit, JobReservation, JobReservationUnit,
+    UserPreferences, Project
+)
+
+
+def get_calibration_status(
+    unit: RosterUnit,
+    check_date: date,
+    warning_days: int = 30
+) -> str:
+    """
+    Determine calibration status for a unit on a specific date.
+
+    Returns:
+        "valid" - Calibration is good on this date
+        "expiring_soon" - Within warning_days of expiry
+        "expired" - Calibration has expired
+        "needs_calibration" - No calibration date set
+    """
+    if not unit.last_calibrated:
+        return "needs_calibration"
+
+    # Calculate expiry date (1 year from last calibration)
+    expiry_date = unit.last_calibrated + timedelta(days=365)
+
+    if check_date >= expiry_date:
+        return "expired"
+    elif check_date >= expiry_date - timedelta(days=warning_days):
+        return "expiring_soon"
+    else:
+        return "valid"
+
+
+def get_unit_reservations_on_date(
+    db: Session,
+    unit_id: str,
+    check_date: date
+) -> List[JobReservation]:
+    """Get all reservations that include this unit on the given date."""
+
+    # Get reservation IDs that have this unit assigned
+    assigned_reservation_ids = db.query(JobReservationUnit.reservation_id).filter(
+        JobReservationUnit.unit_id == unit_id
+    ).subquery()
+
+    # Get reservations that:
+    # 1. Have this unit assigned AND date is within range
+    reservations = db.query(JobReservation).filter(
+        JobReservation.id.in_(assigned_reservation_ids),
+        JobReservation.start_date <= check_date,
+        JobReservation.end_date >= check_date
+    ).all()
+
+    return reservations
+
+
+def is_unit_available_on_date(
+    db: Session,
+    unit: RosterUnit,
+    check_date: date,
+    warning_days: int = 30
+) -> Tuple[bool, str, Optional[str]]:
+    """
+    Check if a unit is available on a specific date.
+
+    Returns:
+        (is_available, status, reservation_name)
+        - is_available: True if unit can be assigned to new work
+        - status: "available", "reserved", "expired", "retired", "needs_calibration"
+        - reservation_name: Name of blocking reservation (if any)
+    """
+    # Check if retired
+    if unit.retired:
+        return False, "retired", None
+
+    # Check calibration status
+    cal_status = get_calibration_status(unit, check_date, warning_days)
+    if cal_status == "expired":
+        return False, "expired", None
+    if cal_status == "needs_calibration":
+        return False, "needs_calibration", None
+
+    # Check if already reserved
+    reservations = get_unit_reservations_on_date(db, unit.id, check_date)
+    if reservations:
+        return False, "reserved", reservations[0].name
+
+    # Unit is available (even if expiring soon - that's just a warning)
+    return True, "available", None
+
+
+def get_day_summary(
+    db: Session,
+    check_date: date,
+    device_type: str = "seismograph"
+) -> Dict:
+    """
+    Get a complete summary of fleet status for a specific day.
+
+    Returns dict with:
+        - available_units: List of available unit IDs with calibration info
+        - reserved_units: List of reserved unit IDs with reservation info
+        - expired_units: List of units with expired calibration
+        - expiring_soon_units: List of units expiring within warning period
+        - reservations: List of active reservations on this date
+        - counts: Summary counts
+    """
+    # Get user preferences for warning days
+    prefs = db.query(UserPreferences).filter_by(id=1).first()
+    warning_days = prefs.calibration_warning_days if prefs else 30
+
+    # Get all non-retired units of the specified device type
+    units = db.query(RosterUnit).filter(
+        RosterUnit.device_type == device_type,
+        RosterUnit.retired == False
+    ).all()
+
+    available_units = []
+    reserved_units = []
+    expired_units = []
+    expiring_soon_units = []
+    needs_calibration_units = []
+    cal_expiring_today = []  # Units whose calibration expires ON this day
+
+    for unit in units:
+        is_avail, status, reservation_name = is_unit_available_on_date(
+            db, unit, check_date, warning_days
+        )
+
+        cal_status = get_calibration_status(unit, check_date, warning_days)
+        expiry_date = None
+        if unit.last_calibrated:
+            expiry_date = (unit.last_calibrated + timedelta(days=365)).isoformat()
+
+        unit_info = {
+            "id": unit.id,
+            "last_calibrated": unit.last_calibrated.isoformat() if unit.last_calibrated else None,
+            "expiry_date": expiry_date,
+            "calibration_status": cal_status,
+            "deployed": unit.deployed,
+            "note": unit.note or ""
+        }
+
+        # Check if calibration expires ON this specific day
+        if unit.last_calibrated:
+            unit_expiry_date = unit.last_calibrated + timedelta(days=365)
+            if unit_expiry_date == check_date:
+                cal_expiring_today.append(unit_info)
+
+        if status == "available":
+            available_units.append(unit_info)
+            if cal_status == "expiring_soon":
+                expiring_soon_units.append(unit_info)
+        elif status == "reserved":
+            unit_info["reservation_name"] = reservation_name
+            reserved_units.append(unit_info)
+            if cal_status == "expiring_soon":
+                expiring_soon_units.append(unit_info)
+        elif status == "expired":
+            expired_units.append(unit_info)
+        elif status == "needs_calibration":
+            needs_calibration_units.append(unit_info)
+
+    # Get active reservations on this date
+    reservations = db.query(JobReservation).filter(
+        JobReservation.device_type == device_type,
+        JobReservation.start_date <= check_date,
+        JobReservation.end_date >= check_date
+    ).all()
+
+    reservation_list = []
+    for res in reservations:
+        # Count assigned units for this reservation
+        assigned_count = db.query(JobReservationUnit).filter(
+            JobReservationUnit.reservation_id == res.id
+        ).count()
+
+        reservation_list.append({
+            "id": res.id,
+            "name": res.name,
+            "start_date": res.start_date.isoformat(),
+            "end_date": res.end_date.isoformat(),
+            "assignment_type": res.assignment_type,
+            "quantity_needed": res.quantity_needed,
+            "assigned_count": assigned_count,
+            "color": res.color,
+            "project_id": res.project_id
+        })
+
+    return {
+        "date": check_date.isoformat(),
+        "device_type": device_type,
+        "available_units": available_units,
+        "reserved_units": reserved_units,
+        "expired_units": expired_units,
+        "expiring_soon_units": expiring_soon_units,
+        "needs_calibration_units": needs_calibration_units,
+        "cal_expiring_today": cal_expiring_today,
+        "reservations": reservation_list,
+        "counts": {
+            "available": len(available_units),
+            "reserved": len(reserved_units),
+            "expired": len(expired_units),
+            "expiring_soon": len(expiring_soon_units),
+            "needs_calibration": len(needs_calibration_units),
+            "cal_expiring_today": len(cal_expiring_today),
+            "total": len(units)
+        }
+    }
+
+
+def get_calendar_year_data(
+    db: Session,
+    year: int,
+    device_type: str = "seismograph"
+) -> Dict:
+    """
+    Get calendar data for an entire year.
+
+    For performance, this returns summary counts per day rather than
+    full unit lists. Use get_day_summary() for detailed day data.
+    """
+    # Get user preferences
+    prefs = db.query(UserPreferences).filter_by(id=1).first()
+    warning_days = prefs.calibration_warning_days if prefs else 30
+
+    # Get all units
+    units = db.query(RosterUnit).filter(
+        RosterUnit.device_type == device_type,
+        RosterUnit.retired == False
+    ).all()
+
+    # Get all reservations that overlap with this year
+    # Include TBD reservations (end_date is null) that started before year end
+    year_start = date(year, 1, 1)
+    year_end = date(year, 12, 31)
+
+    reservations = db.query(JobReservation).filter(
+        JobReservation.device_type == device_type,
+        JobReservation.start_date <= year_end,
+        or_(
+            JobReservation.end_date >= year_start,
+            JobReservation.end_date == None  # TBD reservations
+        )
+    ).all()
+
+    # Get all unit assignments for these reservations
+    reservation_ids = [r.id for r in reservations]
+    assignments = db.query(JobReservationUnit).filter(
+        JobReservationUnit.reservation_id.in_(reservation_ids)
+    ).all() if reservation_ids else []
+
+    # Build a lookup: unit_id -> list of (start_date, end_date, reservation_name)
+    # For TBD reservations, use estimated_end_date if available, or a far future date
+    unit_reservations = {}
+    for res in reservations:
+        res_assignments = [a for a in assignments if a.reservation_id == res.id]
+        for assignment in res_assignments:
+            unit_id = assignment.unit_id
+            # Use unit-specific dates if set, otherwise use reservation dates
+            start_d = assignment.unit_start_date or res.start_date
+            if assignment.unit_end_tbd or (assignment.unit_end_date is None and res.end_date_tbd):
+                # TBD: use estimated date or far future for availability calculation
+                end_d = res.estimated_end_date or date(year + 5, 12, 31)
+            else:
+                end_d = assignment.unit_end_date or res.end_date or date(year + 5, 12, 31)
+
+            if unit_id not in unit_reservations:
+                unit_reservations[unit_id] = []
+            unit_reservations[unit_id].append((start_d, end_d, res.name))
+
+    # Generate data for each month
+    months_data = {}
+
+    for month in range(1, 13):
+        # Get first and last day of month
+        first_day = date(year, month, 1)
+        if month == 12:
+            last_day = date(year, 12, 31)
+        else:
+            last_day = date(year, month + 1, 1) - timedelta(days=1)
+
+        days_data = {}
+        current_day = first_day
+
+        while current_day <= last_day:
+            available = 0
+            reserved = 0
+            expired = 0
+            expiring_soon = 0
+            needs_cal = 0
+            cal_expiring_on_day = 0  # Units whose calibration expires ON this day
+            cal_expired_on_day = 0   # Units whose calibration expired ON this day
+
+            for unit in units:
+                # Check calibration
+                cal_status = get_calibration_status(unit, current_day, warning_days)
+
+                # Check if calibration expires/expired ON this specific day
+                if unit.last_calibrated:
+                    unit_expiry = unit.last_calibrated + timedelta(days=365)
+                    if unit_expiry == current_day:
+                        cal_expiring_on_day += 1
+                    # Check if expired yesterday (first day of being expired)
+                    elif unit_expiry == current_day - timedelta(days=1):
+                        cal_expired_on_day += 1
+
+                if cal_status == "expired":
+                    expired += 1
+                    continue
+                if cal_status == "needs_calibration":
+                    needs_cal += 1
+                    continue
+
+                # Check if reserved
+                is_reserved = False
+                if unit.id in unit_reservations:
+                    for start_d, end_d, _ in unit_reservations[unit.id]:
+                        if start_d <= current_day <= end_d:
+                            is_reserved = True
+                            break
+
+                if is_reserved:
+                    reserved += 1
+                else:
+                    available += 1
+
+                if cal_status == "expiring_soon":
+                    expiring_soon += 1
+
+            days_data[current_day.day] = {
+                "available": available,
+                "reserved": reserved,
+                "expired": expired,
+                "expiring_soon": expiring_soon,
+                "needs_calibration": needs_cal,
+                "cal_expiring_on_day": cal_expiring_on_day,
+                "cal_expired_on_day": cal_expired_on_day
+            }
+
+            current_day += timedelta(days=1)
+
+        months_data[month] = {
+            "name": first_day.strftime("%B"),
+            "short_name": first_day.strftime("%b"),
+            "days": days_data,
+            "first_weekday": first_day.weekday(),  # 0=Monday, 6=Sunday
+            "num_days": last_day.day
+        }
+
+    # Also include reservation summary for the year
+    reservation_list = []
+    for res in reservations:
+        assigned_count = len([a for a in assignments if a.reservation_id == res.id])
+        reservation_list.append({
+            "id": res.id,
+            "name": res.name,
+            "start_date": res.start_date.isoformat(),
+            "end_date": res.end_date.isoformat(),
+            "quantity_needed": res.quantity_needed,
+            "assigned_count": assigned_count,
+            "color": res.color
+        })
+
+    return {
+        "year": year,
+        "device_type": device_type,
+        "months": months_data,
+        "reservations": reservation_list,
+        "total_units": len(units)
+    }
+
+
+def get_rolling_calendar_data(
+    db: Session,
+    start_year: int,
+    start_month: int,
+    device_type: str = "seismograph"
+) -> Dict:
+    """
+    Get calendar data for 12 months starting from a specific month/year.
+
+    This supports the rolling calendar view where users can scroll through
+    months one at a time, viewing any 12-month window.
+    """
+    # Get user preferences
+    prefs = db.query(UserPreferences).filter_by(id=1).first()
+    warning_days = prefs.calibration_warning_days if prefs else 30
+
+    # Get all units
+    units = db.query(RosterUnit).filter(
+        RosterUnit.device_type == device_type,
+        RosterUnit.retired == False
+    ).all()
+
+    # Calculate the date range for 12 months
+    first_date = date(start_year, start_month, 1)
+    # Calculate end date (12 months later)
+    end_year = start_year + 1 if start_month == 1 else start_year
+    end_month = 12 if start_month == 1 else start_month - 1
+    if start_month == 1:
+        end_year = start_year
+        end_month = 12
+    else:
+        # 12 months from start_month means we end at start_month - 1 next year
+        end_year = start_year + 1
+        end_month = start_month - 1
+
+    # Actually, simpler: go 11 months forward from start
+    end_year = start_year + ((start_month + 10) // 12)
+    end_month = ((start_month + 10) % 12) + 1
+    if end_month == 12:
+        last_date = date(end_year, 12, 31)
+    else:
+        last_date = date(end_year, end_month + 1, 1) - timedelta(days=1)
+
+    # Get all reservations that overlap with this 12-month range
+    reservations = db.query(JobReservation).filter(
+        JobReservation.device_type == device_type,
+        JobReservation.start_date <= last_date,
+        or_(
+            JobReservation.end_date >= first_date,
+            JobReservation.end_date == None  # TBD reservations
+        )
+    ).all()
+
+    # Get all unit assignments for these reservations
+    reservation_ids = [r.id for r in reservations]
+    assignments = db.query(JobReservationUnit).filter(
+        JobReservationUnit.reservation_id.in_(reservation_ids)
+    ).all() if reservation_ids else []
+
+    # Build a lookup: unit_id -> list of (start_date, end_date, reservation_name)
+    unit_reservations = {}
+    for res in reservations:
+        res_assignments = [a for a in assignments if a.reservation_id == res.id]
+        for assignment in res_assignments:
+            unit_id = assignment.unit_id
+            start_d = assignment.unit_start_date or res.start_date
+            if assignment.unit_end_tbd or (assignment.unit_end_date is None and res.end_date_tbd):
+                end_d = res.estimated_end_date or date(start_year + 5, 12, 31)
+            else:
+                end_d = assignment.unit_end_date or res.end_date or date(start_year + 5, 12, 31)
+
+            if unit_id not in unit_reservations:
+                unit_reservations[unit_id] = []
+            unit_reservations[unit_id].append((start_d, end_d, res.name))
+
+    # Generate data for each of the 12 months
+    months_data = []
+    current_year = start_year
+    current_month = start_month
+
+    for i in range(12):
+        # Calculate this month's year and month
+        m_year = start_year + ((start_month - 1 + i) // 12)
+        m_month = ((start_month - 1 + i) % 12) + 1
+
+        first_day = date(m_year, m_month, 1)
+        if m_month == 12:
+            last_day = date(m_year, 12, 31)
+        else:
+            last_day = date(m_year, m_month + 1, 1) - timedelta(days=1)
+
+        days_data = {}
+        current_day = first_day
+
+        while current_day <= last_day:
+            available = 0
+            reserved = 0
+            expired = 0
+            expiring_soon = 0
+            needs_cal = 0
+            cal_expiring_on_day = 0
+            cal_expired_on_day = 0
+
+            for unit in units:
+                cal_status = get_calibration_status(unit, current_day, warning_days)
+
+                if unit.last_calibrated:
+                    unit_expiry = unit.last_calibrated + timedelta(days=365)
+                    if unit_expiry == current_day:
+                        cal_expiring_on_day += 1
+                    elif unit_expiry == current_day - timedelta(days=1):
+                        cal_expired_on_day += 1
+
+                if cal_status == "expired":
+                    expired += 1
+                    continue
+                if cal_status == "needs_calibration":
+                    needs_cal += 1
+                    continue
+
+                is_reserved = False
+                if unit.id in unit_reservations:
+                    for start_d, end_d, _ in unit_reservations[unit.id]:
+                        if start_d <= current_day <= end_d:
+                            is_reserved = True
+                            break
+
+                if is_reserved:
+                    reserved += 1
+                else:
+                    available += 1
+
+                if cal_status == "expiring_soon":
+                    expiring_soon += 1
+
+            days_data[current_day.day] = {
+                "available": available,
+                "reserved": reserved,
+                "expired": expired,
+                "expiring_soon": expiring_soon,
+                "needs_calibration": needs_cal,
+                "cal_expiring_on_day": cal_expiring_on_day,
+                "cal_expired_on_day": cal_expired_on_day
+            }
+
+            current_day += timedelta(days=1)
+
+        months_data.append({
+            "year": m_year,
+            "month": m_month,
+            "name": first_day.strftime("%B"),
+            "short_name": first_day.strftime("%b"),
+            "year_short": first_day.strftime("%y"),
+            "days": days_data,
+            "first_weekday": first_day.weekday(),
+            "num_days": last_day.day
+        })
+
+    return {
+        "start_year": start_year,
+        "start_month": start_month,
+        "device_type": device_type,
+        "months": months_data,
+        "total_units": len(units)
+    }
+
+
+def check_calibration_conflicts(
+    db: Session,
+    reservation_id: str
+) -> List[Dict]:
+    """
+    Check if any units assigned to a reservation will have their
+    calibration expire during the reservation period.
+
+    Returns list of conflicts with unit info and expiry date.
+    """
+    reservation = db.query(JobReservation).filter_by(id=reservation_id).first()
+    if not reservation:
+        return []
+
+    # Get assigned units
+    assigned = db.query(JobReservationUnit).filter_by(
+        reservation_id=reservation_id
+    ).all()
+
+    conflicts = []
+    for assignment in assigned:
+        unit = db.query(RosterUnit).filter_by(id=assignment.unit_id).first()
+        if not unit or not unit.last_calibrated:
+            continue
+
+        expiry_date = unit.last_calibrated + timedelta(days=365)
+
+        # Check if expiry falls within reservation period
+        if reservation.start_date < expiry_date <= reservation.end_date:
+            conflicts.append({
+                "unit_id": unit.id,
+                "last_calibrated": unit.last_calibrated.isoformat(),
+                "expiry_date": expiry_date.isoformat(),
+                "reservation_name": reservation.name,
+                "days_into_job": (expiry_date - reservation.start_date).days
+            })
+
+    return conflicts
+
+
+def get_available_units_for_period(
+    db: Session,
+    start_date: date,
+    end_date: date,
+    device_type: str = "seismograph",
+    exclude_reservation_id: Optional[str] = None
+) -> List[Dict]:
+    """
+    Get units that are available for the entire specified period.
+
+    A unit is available if:
+    - Not retired
+    - Calibration is valid through the end date
+    - Not assigned to any other reservation that overlaps the period
+    """
+    prefs = db.query(UserPreferences).filter_by(id=1).first()
+    warning_days = prefs.calibration_warning_days if prefs else 30
+
+    units = db.query(RosterUnit).filter(
+        RosterUnit.device_type == device_type,
+        RosterUnit.retired == False
+    ).all()
+
+    # Get reservations that overlap with this period
+    overlapping_reservations = db.query(JobReservation).filter(
+        JobReservation.device_type == device_type,
+        JobReservation.start_date <= end_date,
+        JobReservation.end_date >= start_date
+    )
+
+    if exclude_reservation_id:
+        overlapping_reservations = overlapping_reservations.filter(
+            JobReservation.id != exclude_reservation_id
+        )
+
+    overlapping_reservations = overlapping_reservations.all()
+
+    # Get all units assigned to overlapping reservations
+    reserved_unit_ids = set()
+    for res in overlapping_reservations:
+        assigned = db.query(JobReservationUnit).filter_by(
+            reservation_id=res.id
+        ).all()
+        for a in assigned:
+            reserved_unit_ids.add(a.unit_id)
+
+    available_units = []
+    for unit in units:
+        # Check if already reserved
+        if unit.id in reserved_unit_ids:
+            continue
+
+        # Check calibration through end of period
+        if not unit.last_calibrated:
+            continue  # Needs calibration
+
+        expiry_date = unit.last_calibrated + timedelta(days=365)
+        if expiry_date <= end_date:
+            continue  # Calibration expires during period
+
+        cal_status = get_calibration_status(unit, end_date, warning_days)
+
+        available_units.append({
+            "id": unit.id,
+            "last_calibrated": unit.last_calibrated.isoformat(),
+            "expiry_date": expiry_date.isoformat(),
+            "calibration_status": cal_status,
+            "deployed": unit.deployed,
+            "note": unit.note or ""
+        })
+
+    return available_units

backend/services/recurring_schedule_service.py

@@ -0,0 +1,611 @@
+"""
+Recurring Schedule Service
+
+Manages recurring schedule definitions and generates ScheduledAction
+instances based on patterns (weekly calendar, simple interval).
+"""
+
+import json
+import uuid
+import logging
+from datetime import datetime, timedelta, date, time
+from typing import Optional, List, Dict, Any, Tuple
+from zoneinfo import ZoneInfo
+
+from sqlalchemy.orm import Session
+from sqlalchemy import and_
+
+from backend.models import RecurringSchedule, ScheduledAction, MonitoringLocation, UnitAssignment, Project
+
+logger = logging.getLogger(__name__)
+
+# Day name mapping
+DAY_NAMES = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"]
+
+
+class RecurringScheduleService:
+    """
+    Service for managing recurring schedules and generating ScheduledActions.
+
+    Supports two schedule types:
+    - weekly_calendar: Specific days with start/end times
+    - simple_interval: Daily stop/download/restart cycles for 24/7 monitoring
+    """
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def create_schedule(
+        self,
+        project_id: str,
+        location_id: str,
+        name: str,
+        schedule_type: str,
+        device_type: str = "slm",
+        unit_id: str = None,
+        weekly_pattern: dict = None,
+        interval_type: str = None,
+        cycle_time: str = None,
+        include_download: bool = True,
+        auto_increment_index: bool = True,
+        timezone: str = "America/New_York",
+        start_datetime: datetime = None,
+        end_datetime: datetime = None,
+    ) -> RecurringSchedule:
+        """
+        Create a new recurring schedule.
+
+        Args:
+            project_id: Project ID
+            location_id: Monitoring location ID
+            name: Schedule name
+            schedule_type: "weekly_calendar", "simple_interval", or "one_off"
+            device_type: "slm" or "seismograph"
+            unit_id: Specific unit (optional, can use assignment)
+            weekly_pattern: Dict of day patterns for weekly_calendar
+            interval_type: "daily" or "hourly" for simple_interval
+            cycle_time: Time string "HH:MM" for cycle
+            include_download: Whether to download data on cycle
+            auto_increment_index: Whether to auto-increment store index before start
+            timezone: Timezone for schedule times
+            start_datetime: Start date+time in UTC (one_off only)
+            end_datetime: End date+time in UTC (one_off only)
+
+        Returns:
+            Created RecurringSchedule
+        """
+        schedule = RecurringSchedule(
+            id=str(uuid.uuid4()),
+            project_id=project_id,
+            location_id=location_id,
+            unit_id=unit_id,
+            name=name,
+            schedule_type=schedule_type,
+            device_type=device_type,
+            weekly_pattern=json.dumps(weekly_pattern) if weekly_pattern else None,
+            interval_type=interval_type,
+            cycle_time=cycle_time,
+            include_download=include_download,
+            auto_increment_index=auto_increment_index,
+            enabled=True,
+            timezone=timezone,
+            start_datetime=start_datetime,
+            end_datetime=end_datetime,
+        )
+
+        # Calculate next occurrence
+        schedule.next_occurrence = self._calculate_next_occurrence(schedule)
+
+        self.db.add(schedule)
+        self.db.commit()
+        self.db.refresh(schedule)
+
+        logger.info(f"Created recurring schedule: {name} ({schedule_type})")
+        return schedule
+
+    def update_schedule(
+        self,
+        schedule_id: str,
+        **kwargs,
+    ) -> Optional[RecurringSchedule]:
+        """
+        Update a recurring schedule.
+
+        Args:
+            schedule_id: Schedule to update
+            **kwargs: Fields to update
+
+        Returns:
+            Updated schedule or None
+        """
+        schedule = self.db.query(RecurringSchedule).filter_by(id=schedule_id).first()
+        if not schedule:
+            return None
+
+        for key, value in kwargs.items():
+            if hasattr(schedule, key):
+                if key == "weekly_pattern" and isinstance(value, dict):
+                    value = json.dumps(value)
+                setattr(schedule, key, value)
+
+        # Recalculate next occurrence
+        schedule.next_occurrence = self._calculate_next_occurrence(schedule)
+
+        self.db.commit()
+        self.db.refresh(schedule)
+
+        logger.info(f"Updated recurring schedule: {schedule.name}")
+        return schedule
+
+    def delete_schedule(self, schedule_id: str) -> bool:
+        """
+        Delete a recurring schedule and its pending generated actions.
+
+        Args:
+            schedule_id: Schedule to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        schedule = self.db.query(RecurringSchedule).filter_by(id=schedule_id).first()
+        if not schedule:
+            return False
+
+        # Delete pending generated actions for this schedule
+        # The schedule_id is stored in the notes field as JSON
+        pending_actions = self.db.query(ScheduledAction).filter(
+            and_(
+                ScheduledAction.execution_status == "pending",
+                ScheduledAction.notes.like(f'%"schedule_id": "{schedule_id}"%'),
+            )
+        ).all()
+
+        deleted_count = len(pending_actions)
+        for action in pending_actions:
+            self.db.delete(action)
+
+        self.db.delete(schedule)
+        self.db.commit()
+
+        logger.info(f"Deleted recurring schedule: {schedule.name} (and {deleted_count} pending actions)")
+        return True
+
+    def enable_schedule(self, schedule_id: str) -> Optional[RecurringSchedule]:
+        """Enable a disabled schedule."""
+        return self.update_schedule(schedule_id, enabled=True)
+
+    def disable_schedule(self, schedule_id: str) -> Optional[RecurringSchedule]:
+        """Disable a schedule and cancel its pending actions."""
+        schedule = self.update_schedule(schedule_id, enabled=False)
+        if schedule:
+            # Cancel all pending actions generated by this schedule
+            pending_actions = self.db.query(ScheduledAction).filter(
+                and_(
+                    ScheduledAction.execution_status == "pending",
+                    ScheduledAction.notes.like(f'%"schedule_id": "{schedule_id}"%'),
+                )
+            ).all()
+
+            for action in pending_actions:
+                action.execution_status = "cancelled"
+
+            if pending_actions:
+                self.db.commit()
+                logger.info(f"Cancelled {len(pending_actions)} pending actions for disabled schedule {schedule.name}")
+
+        return schedule
+
+    def generate_actions_for_schedule(
+        self,
+        schedule: RecurringSchedule,
+        horizon_days: int = 7,
+        preview_only: bool = False,
+    ) -> List[ScheduledAction]:
+        """
+        Generate ScheduledAction entries for the next N days based on pattern.
+
+        Args:
+            schedule: The recurring schedule
+            horizon_days: Days ahead to generate
+            preview_only: If True, don't save to DB (for preview)
+
+        Returns:
+            List of generated ScheduledAction instances
+        """
+        if not schedule.enabled:
+            return []
+
+        if schedule.schedule_type == "weekly_calendar":
+            actions = self._generate_weekly_calendar_actions(schedule, horizon_days)
+        elif schedule.schedule_type == "simple_interval":
+            actions = self._generate_interval_actions(schedule, horizon_days)
+        elif schedule.schedule_type == "one_off":
+            actions = self._generate_one_off_actions(schedule)
+        else:
+            logger.warning(f"Unknown schedule type: {schedule.schedule_type}")
+            return []
+
+        if not preview_only and actions:
+            for action in actions:
+                self.db.add(action)
+
+            schedule.last_generated_at = datetime.utcnow()
+            schedule.next_occurrence = self._calculate_next_occurrence(schedule)
+
+            self.db.commit()
+            logger.info(f"Generated {len(actions)} actions for schedule: {schedule.name}")
+
+        return actions
+
+    def _generate_weekly_calendar_actions(
+        self,
+        schedule: RecurringSchedule,
+        horizon_days: int,
+    ) -> List[ScheduledAction]:
+        """
+        Generate actions from weekly calendar pattern.
+
+        Pattern format:
+        {
+            "monday": {"enabled": true, "start": "19:00", "end": "07:00"},
+            "tuesday": {"enabled": false},
+            ...
+        }
+        """
+        if not schedule.weekly_pattern:
+            return []
+
+        try:
+            pattern = json.loads(schedule.weekly_pattern)
+        except json.JSONDecodeError:
+            logger.error(f"Invalid weekly_pattern JSON for schedule {schedule.id}")
+            return []
+
+        actions = []
+        tz = ZoneInfo(schedule.timezone)
+        now_utc = datetime.utcnow()
+        now_local = now_utc.replace(tzinfo=ZoneInfo("UTC")).astimezone(tz)
+
+        # Get unit_id (from schedule or assignment)
+        unit_id = self._resolve_unit_id(schedule)
+
+        for day_offset in range(horizon_days):
+            check_date = now_local.date() + timedelta(days=day_offset)
+            day_name = DAY_NAMES[check_date.weekday()]
+            day_config = pattern.get(day_name, {})
+
+            if not day_config.get("enabled", False):
+                continue
+
+            start_time_str = day_config.get("start")
+            end_time_str = day_config.get("end")
+
+            if not start_time_str or not end_time_str:
+                continue
+
+            # Parse times
+            start_time = self._parse_time(start_time_str)
+            end_time = self._parse_time(end_time_str)
+
+            if not start_time or not end_time:
+                continue
+
+            # Create start datetime in local timezone
+            start_local = datetime.combine(check_date, start_time, tzinfo=tz)
+            start_utc = start_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+
+            # Handle overnight schedules (end time is next day)
+            if end_time <= start_time:
+                end_date = check_date + timedelta(days=1)
+            else:
+                end_date = check_date
+
+            end_local = datetime.combine(end_date, end_time, tzinfo=tz)
+            end_utc = end_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+
+            # Skip if start time has already passed
+            if start_utc <= now_utc:
+                continue
+
+            # Check if action already exists
+            if self._action_exists(schedule.project_id, schedule.location_id, "start", start_utc):
+                continue
+
+            # Build notes with automation metadata
+            start_notes = json.dumps({
+                "schedule_name": schedule.name,
+                "schedule_id": schedule.id,
+                "auto_increment_index": schedule.auto_increment_index,
+            })
+
+            # Create START action
+            start_action = ScheduledAction(
+                id=str(uuid.uuid4()),
+                project_id=schedule.project_id,
+                location_id=schedule.location_id,
+                unit_id=unit_id,
+                action_type="start",
+                device_type=schedule.device_type,
+                scheduled_time=start_utc,
+                execution_status="pending",
+                notes=start_notes,
+            )
+            actions.append(start_action)
+
+            # Create STOP action (stop_cycle handles download when include_download is True)
+            stop_notes = json.dumps({
+                "schedule_name": schedule.name,
+                "schedule_id": schedule.id,
+                "schedule_type": "weekly_calendar",
+                "include_download": schedule.include_download,
+            })
+            stop_action = ScheduledAction(
+                id=str(uuid.uuid4()),
+                project_id=schedule.project_id,
+                location_id=schedule.location_id,
+                unit_id=unit_id,
+                action_type="stop",
+                device_type=schedule.device_type,
+                scheduled_time=end_utc,
+                execution_status="pending",
+                notes=stop_notes,
+            )
+            actions.append(stop_action)
+
+        return actions
+
+    def _generate_interval_actions(
+        self,
+        schedule: RecurringSchedule,
+        horizon_days: int,
+    ) -> List[ScheduledAction]:
+        """
+        Generate actions from simple interval pattern.
+
+        For daily cycles: stop, download (optional), start at cycle_time each day.
+        """
+        if not schedule.cycle_time:
+            return []
+
+        cycle_time = self._parse_time(schedule.cycle_time)
+        if not cycle_time:
+            return []
+
+        actions = []
+        tz = ZoneInfo(schedule.timezone)
+        now_utc = datetime.utcnow()
+        now_local = now_utc.replace(tzinfo=ZoneInfo("UTC")).astimezone(tz)
+
+        # Get unit_id
+        unit_id = self._resolve_unit_id(schedule)
+
+        for day_offset in range(horizon_days):
+            check_date = now_local.date() + timedelta(days=day_offset)
+
+            # Create cycle datetime in local timezone
+            cycle_local = datetime.combine(check_date, cycle_time, tzinfo=tz)
+            cycle_utc = cycle_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+
+            # Skip if time has passed
+            if cycle_utc <= now_utc:
+                continue
+
+            # Check if cycle action already exists
+            if self._action_exists(schedule.project_id, schedule.location_id, "cycle", cycle_utc):
+                continue
+
+            # Build notes with metadata for cycle action
+            cycle_notes = json.dumps({
+                "schedule_name": schedule.name,
+                "schedule_id": schedule.id,
+                "cycle_type": "daily",
+                "include_download": schedule.include_download,
+                "auto_increment_index": schedule.auto_increment_index,
+            })
+
+            # Create single CYCLE action that handles stop -> download -> start
+            # The scheduler's _execute_cycle method handles the full workflow with delays
+            cycle_action = ScheduledAction(
+                id=str(uuid.uuid4()),
+                project_id=schedule.project_id,
+                location_id=schedule.location_id,
+                unit_id=unit_id,
+                action_type="cycle",
+                device_type=schedule.device_type,
+                scheduled_time=cycle_utc,
+                execution_status="pending",
+                notes=cycle_notes,
+            )
+            actions.append(cycle_action)
+
+        return actions
+
+    def _generate_one_off_actions(
+        self,
+        schedule: RecurringSchedule,
+    ) -> List[ScheduledAction]:
+        """
+        Generate start and stop actions for a one-off recording.
+
+        Unlike recurring types, this generates exactly one start and one stop action
+        using the schedule's start_datetime and end_datetime directly.
+        """
+        if not schedule.start_datetime or not schedule.end_datetime:
+            logger.warning(f"One-off schedule {schedule.id} missing start/end datetime")
+            return []
+
+        actions = []
+        now_utc = datetime.utcnow()
+        unit_id = self._resolve_unit_id(schedule)
+
+        # Skip if end time has already passed
+        if schedule.end_datetime <= now_utc:
+            return []
+
+        # Check if actions already exist for this schedule
+        if self._action_exists(schedule.project_id, schedule.location_id, "start", schedule.start_datetime):
+            return []
+
+        # Create START action (only if start time hasn't passed)
+        if schedule.start_datetime > now_utc:
+            start_notes = json.dumps({
+                "schedule_name": schedule.name,
+                "schedule_id": schedule.id,
+                "schedule_type": "one_off",
+                "auto_increment_index": schedule.auto_increment_index,
+            })
+
+            start_action = ScheduledAction(
+                id=str(uuid.uuid4()),
+                project_id=schedule.project_id,
+                location_id=schedule.location_id,
+                unit_id=unit_id,
+                action_type="start",
+                device_type=schedule.device_type,
+                scheduled_time=schedule.start_datetime,
+                execution_status="pending",
+                notes=start_notes,
+            )
+            actions.append(start_action)
+
+        # Create STOP action
+        stop_notes = json.dumps({
+            "schedule_name": schedule.name,
+            "schedule_id": schedule.id,
+            "schedule_type": "one_off",
+            "include_download": schedule.include_download,
+        })
+
+        stop_action = ScheduledAction(
+            id=str(uuid.uuid4()),
+            project_id=schedule.project_id,
+            location_id=schedule.location_id,
+            unit_id=unit_id,
+            action_type="stop",
+            device_type=schedule.device_type,
+            scheduled_time=schedule.end_datetime,
+            execution_status="pending",
+            notes=stop_notes,
+        )
+        actions.append(stop_action)
+
+        return actions
+
+    def _calculate_next_occurrence(self, schedule: RecurringSchedule) -> Optional[datetime]:
+        """Calculate when the next action should occur."""
+        if not schedule.enabled:
+            return None
+
+        tz = ZoneInfo(schedule.timezone)
+        now_utc = datetime.utcnow()
+        now_local = now_utc.replace(tzinfo=ZoneInfo("UTC")).astimezone(tz)
+
+        if schedule.schedule_type == "weekly_calendar" and schedule.weekly_pattern:
+            try:
+                pattern = json.loads(schedule.weekly_pattern)
+            except:
+                return None
+
+            # Find next enabled day
+            for day_offset in range(8):  # Check up to a week ahead
+                check_date = now_local.date() + timedelta(days=day_offset)
+                day_name = DAY_NAMES[check_date.weekday()]
+                day_config = pattern.get(day_name, {})
+
+                if day_config.get("enabled") and day_config.get("start"):
+                    start_time = self._parse_time(day_config["start"])
+                    if start_time:
+                        start_local = datetime.combine(check_date, start_time, tzinfo=tz)
+                        start_utc = start_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+                        if start_utc > now_utc:
+                            return start_utc
+
+        elif schedule.schedule_type == "simple_interval" and schedule.cycle_time:
+            cycle_time = self._parse_time(schedule.cycle_time)
+            if cycle_time:
+                # Find next cycle time
+                for day_offset in range(2):
+                    check_date = now_local.date() + timedelta(days=day_offset)
+                    cycle_local = datetime.combine(check_date, cycle_time, tzinfo=tz)
+                    cycle_utc = cycle_local.astimezone(ZoneInfo("UTC")).replace(tzinfo=None)
+                    if cycle_utc > now_utc:
+                        return cycle_utc
+
+        elif schedule.schedule_type == "one_off":
+            if schedule.start_datetime and schedule.start_datetime > now_utc:
+                return schedule.start_datetime
+            elif schedule.end_datetime and schedule.end_datetime > now_utc:
+                return schedule.end_datetime
+            return None
+
+        return None
+
+    def _resolve_unit_id(self, schedule: RecurringSchedule) -> Optional[str]:
+        """Get unit_id from schedule or active assignment."""
+        if schedule.unit_id:
+            return schedule.unit_id
+
+        # Try to get from active assignment
+        assignment = self.db.query(UnitAssignment).filter(
+            and_(
+                UnitAssignment.location_id == schedule.location_id,
+                UnitAssignment.status == "active",
+            )
+        ).first()
+
+        return assignment.unit_id if assignment else None
+
+    def _action_exists(
+        self,
+        project_id: str,
+        location_id: str,
+        action_type: str,
+        scheduled_time: datetime,
+    ) -> bool:
+        """Check if an action already exists for this time slot."""
+        # Allow 5-minute window for duplicate detection
+        time_window_start = scheduled_time - timedelta(minutes=5)
+        time_window_end = scheduled_time + timedelta(minutes=5)
+
+        exists = self.db.query(ScheduledAction).filter(
+            and_(
+                ScheduledAction.project_id == project_id,
+                ScheduledAction.location_id == location_id,
+                ScheduledAction.action_type == action_type,
+                ScheduledAction.scheduled_time >= time_window_start,
+                ScheduledAction.scheduled_time <= time_window_end,
+                ScheduledAction.execution_status == "pending",
+            )
+        ).first()
+
+        return exists is not None
+
+    @staticmethod
+    def _parse_time(time_str: str) -> Optional[time]:
+        """Parse time string "HH:MM" to time object."""
+        try:
+            parts = time_str.split(":")
+            return time(int(parts[0]), int(parts[1]))
+        except (ValueError, IndexError):
+            return None
+
+    def get_schedules_for_project(self, project_id: str) -> List[RecurringSchedule]:
+        """Get all recurring schedules for a project."""
+        return self.db.query(RecurringSchedule).filter_by(project_id=project_id).all()
+
+    def get_enabled_schedules(self) -> List[RecurringSchedule]:
+        """Get all enabled recurring schedules for projects that are not on hold or deleted."""
+        active_project_ids = [
+            p.id for p in self.db.query(Project.id).filter(
+                Project.status.notin_(["on_hold", "archived", "deleted"])
+            ).all()
+        ]
+        return self.db.query(RecurringSchedule).filter(
+            RecurringSchedule.enabled == True,
+            RecurringSchedule.project_id.in_(active_project_ids),
+        ).all()
+
+
+def get_recurring_schedule_service(db: Session) -> RecurringScheduleService:
+    """Get a RecurringScheduleService instance."""
+    return RecurringScheduleService(db)

backend/services/scheduler.py

@@ -0,0 +1,842 @@
+"""
+Scheduler Service
+
+Executes scheduled actions for Projects system.
+Monitors pending scheduled actions and executes them by calling device modules (SLMM/SFM).
+
+Extended to support recurring schedules:
+- Generates ScheduledActions from RecurringSchedule patterns
+- Cleans up old completed/failed actions
+
+This service runs as a background task in FastAPI, checking for pending actions
+every minute and executing them when their scheduled time arrives.
+"""
+
+import asyncio
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Optional, List, Dict, Any
+from sqlalchemy.orm import Session
+from sqlalchemy import and_
+
+from backend.database import SessionLocal
+from backend.models import ScheduledAction, MonitoringSession, MonitoringLocation, Project, RecurringSchedule
+from backend.services.device_controller import get_device_controller, DeviceControllerError
+from backend.services.alert_service import get_alert_service
+import uuid
+
+logger = logging.getLogger(__name__)
+
+
+class SchedulerService:
+    """
+    Service for executing scheduled actions.
+
+    Usage:
+        scheduler = SchedulerService()
+        await scheduler.start()  # Start background loop
+        scheduler.stop()  # Stop background loop
+    """
+
+    def __init__(self, check_interval: int = 60):
+        """
+        Initialize scheduler.
+
+        Args:
+            check_interval: Seconds between checks for pending actions (default: 60)
+        """
+        self.check_interval = check_interval
+        self.running = False
+        self.task: Optional[asyncio.Task] = None
+        self.device_controller = get_device_controller()
+
+    async def start(self):
+        """Start the scheduler background task."""
+        if self.running:
+            print("Scheduler is already running")
+            return
+
+        self.running = True
+        self.task = asyncio.create_task(self._run_loop())
+        print(f"Scheduler started (checking every {self.check_interval}s)")
+
+    def stop(self):
+        """Stop the scheduler background task."""
+        self.running = False
+        if self.task:
+            self.task.cancel()
+        print("Scheduler stopped")
+
+    async def _run_loop(self):
+        """Main scheduler loop."""
+        # Track when we last generated recurring actions (do this once per hour)
+        last_generation_check = datetime.utcnow() - timedelta(hours=1)
+
+        while self.running:
+            try:
+                # Execute pending actions
+                await self.execute_pending_actions()
+
+                # Generate actions from recurring schedules (every hour)
+                now = datetime.utcnow()
+                if (now - last_generation_check).total_seconds() >= 3600:
+                    await self.generate_recurring_actions()
+                    last_generation_check = now
+
+                # Cleanup old actions (also every hour, during generation cycle)
+                if (now - last_generation_check).total_seconds() < 60:
+                    await self.cleanup_old_actions()
+
+            except Exception as e:
+                logger.error(f"Scheduler error: {e}", exc_info=True)
+                # Continue running even if there's an error
+
+            await asyncio.sleep(self.check_interval)
+
+    async def execute_pending_actions(self) -> List[Dict[str, Any]]:
+        """
+        Find and execute all pending scheduled actions that are due.
+
+        Returns:
+            List of execution results
+        """
+        db = SessionLocal()
+        results = []
+
+        try:
+            # Find pending actions that are due
+            now = datetime.utcnow()
+
+            # Only execute actions for active/completed projects (not on_hold, archived, or deleted)
+            active_project_ids = [
+                p.id for p in db.query(Project.id).filter(
+                    Project.status.notin_(["on_hold", "archived", "deleted"])
+                ).all()
+            ]
+
+            pending_actions = db.query(ScheduledAction).filter(
+                and_(
+                    ScheduledAction.execution_status == "pending",
+                    ScheduledAction.scheduled_time <= now,
+                    ScheduledAction.project_id.in_(active_project_ids),
+                )
+            ).order_by(ScheduledAction.scheduled_time).all()
+
+            if not pending_actions:
+                return []
+
+            print(f"Found {len(pending_actions)} pending action(s) to execute")
+
+            for action in pending_actions:
+                result = await self._execute_action(action, db)
+                results.append(result)
+
+            db.commit()
+
+        except Exception as e:
+            print(f"Error executing pending actions: {e}")
+            db.rollback()
+        finally:
+            db.close()
+
+        return results
+
+    async def _execute_action(
+        self,
+        action: ScheduledAction,
+        db: Session,
+    ) -> Dict[str, Any]:
+        """
+        Execute a single scheduled action.
+
+        Args:
+            action: ScheduledAction to execute
+            db: Database session
+
+        Returns:
+            Execution result dict
+        """
+        print(f"Executing action {action.id}: {action.action_type} for unit {action.unit_id}")
+
+        result = {
+            "action_id": action.id,
+            "action_type": action.action_type,
+            "unit_id": action.unit_id,
+            "scheduled_time": action.scheduled_time.isoformat(),
+            "success": False,
+            "error": None,
+        }
+
+        try:
+            # Determine which unit to use
+            # If unit_id is specified, use it; otherwise get from location assignment
+            unit_id = action.unit_id
+            if not unit_id:
+                # Get assigned unit from location
+                from backend.models import UnitAssignment
+                assignment = db.query(UnitAssignment).filter(
+                    and_(
+                        UnitAssignment.location_id == action.location_id,
+                        UnitAssignment.status == "active",
+                    )
+                ).first()
+
+                if not assignment:
+                    raise Exception(f"No active unit assigned to location {action.location_id}")
+
+                unit_id = assignment.unit_id
+
+            # Execute the action based on type
+            if action.action_type == "start":
+                response = await self._execute_start(action, unit_id, db)
+            elif action.action_type == "stop":
+                response = await self._execute_stop(action, unit_id, db)
+            elif action.action_type == "download":
+                response = await self._execute_download(action, unit_id, db)
+            elif action.action_type == "cycle":
+                response = await self._execute_cycle(action, unit_id, db)
+            else:
+                raise Exception(f"Unknown action type: {action.action_type}")
+
+            # Mark action as completed
+            action.execution_status = "completed"
+            action.executed_at = datetime.utcnow()
+            action.module_response = json.dumps(response)
+
+            result["success"] = True
+            result["response"] = response
+
+            print(f"✓ Action {action.id} completed successfully")
+
+            # Create success alert
+            try:
+                alert_service = get_alert_service(db)
+                alert_metadata = response.get("cycle_response", {}) if isinstance(response, dict) else {}
+                alert_service.create_schedule_completed_alert(
+                    schedule_id=action.id,
+                    action_type=action.action_type,
+                    unit_id=unit_id,
+                    project_id=action.project_id,
+                    location_id=action.location_id,
+                    metadata=alert_metadata,
+                )
+            except Exception as alert_err:
+                logger.warning(f"Failed to create success alert: {alert_err}")
+
+        except Exception as e:
+            # Mark action as failed
+            action.execution_status = "failed"
+            action.executed_at = datetime.utcnow()
+            action.error_message = str(e)
+
+            result["error"] = str(e)
+
+            print(f"✗ Action {action.id} failed: {e}")
+
+            # Create failure alert
+            try:
+                alert_service = get_alert_service(db)
+                alert_service.create_schedule_failed_alert(
+                    schedule_id=action.id,
+                    action_type=action.action_type,
+                    unit_id=unit_id if 'unit_id' in dir() else action.unit_id,
+                    error_message=str(e),
+                    project_id=action.project_id,
+                    location_id=action.location_id,
+                )
+            except Exception as alert_err:
+                logger.warning(f"Failed to create failure alert: {alert_err}")
+
+        return result
+
+    async def _execute_start(
+        self,
+        action: ScheduledAction,
+        unit_id: str,
+        db: Session,
+    ) -> Dict[str, Any]:
+        """Execute a 'start' action using the start_cycle command.
+
+        start_cycle handles:
+        1. Sync device clock to server time
+        2. Find next safe index (with overwrite protection)
+        3. Start measurement
+        """
+        # Execute the full start cycle via device controller
+        # SLMM handles clock sync, index increment, and start
+        cycle_response = await self.device_controller.start_cycle(
+            unit_id,
+            action.device_type,
+            sync_clock=True,
+        )
+
+        # Create recording session
+        session = MonitoringSession(
+            id=str(uuid.uuid4()),
+            project_id=action.project_id,
+            location_id=action.location_id,
+            unit_id=unit_id,
+            session_type="sound" if action.device_type == "slm" else "vibration",
+            started_at=datetime.utcnow(),
+            status="recording",
+            session_metadata=json.dumps({
+                "scheduled_action_id": action.id,
+                "cycle_response": cycle_response,
+            }),
+        )
+        db.add(session)
+
+        return {
+            "status": "started",
+            "session_id": session.id,
+            "cycle_response": cycle_response,
+        }
+
+    async def _execute_stop(
+        self,
+        action: ScheduledAction,
+        unit_id: str,
+        db: Session,
+    ) -> Dict[str, Any]:
+        """Execute a 'stop' action using the stop_cycle command.
+
+        stop_cycle handles:
+        1. Stop measurement
+        2. Enable FTP
+        3. Download measurement folder to SLMM local storage
+
+        After stop_cycle, if download succeeded, this method fetches the ZIP
+        from SLMM and extracts it into Terra-View's project directory, creating
+        DataFile records for each file.
+        """
+        import hashlib
+        import io
+        import os
+        import zipfile
+        import httpx
+        from pathlib import Path
+        from backend.models import DataFile
+
+        # Parse notes for download preference
+        include_download = True
+        try:
+            if action.notes:
+                notes_data = json.loads(action.notes)
+                include_download = notes_data.get("include_download", True)
+        except json.JSONDecodeError:
+            pass  # Notes is plain text, not JSON
+
+        # Execute the full stop cycle via device controller
+        # SLMM handles stop, FTP enable, and download to SLMM-local storage
+        cycle_response = await self.device_controller.stop_cycle(
+            unit_id,
+            action.device_type,
+            download=include_download,
+        )
+
+        # Find and update the active recording session
+        active_session = db.query(MonitoringSession).filter(
+            and_(
+                MonitoringSession.location_id == action.location_id,
+                MonitoringSession.unit_id == unit_id,
+                MonitoringSession.status == "recording",
+            )
+        ).first()
+
+        if active_session:
+            active_session.stopped_at = datetime.utcnow()
+            active_session.status = "completed"
+            active_session.duration_seconds = int(
+                (active_session.stopped_at - active_session.started_at).total_seconds()
+            )
+            # Store download info in session metadata
+            if cycle_response.get("download_success"):
+                try:
+                    metadata = json.loads(active_session.session_metadata or "{}")
+                    metadata["downloaded_folder"] = cycle_response.get("downloaded_folder")
+                    metadata["local_path"] = cycle_response.get("local_path")
+                    active_session.session_metadata = json.dumps(metadata)
+                except json.JSONDecodeError:
+                    pass
+
+        db.commit()
+
+        # If SLMM downloaded the folder successfully, fetch the ZIP from SLMM
+        # and extract it into Terra-View's project directory, creating DataFile records
+        files_created = 0
+        if include_download and cycle_response.get("download_success") and active_session:
+            folder_name = cycle_response.get("downloaded_folder")  # e.g. "Auto_0058"
+            remote_path = f"/NL-43/{folder_name}"
+
+            try:
+                SLMM_BASE_URL = os.getenv("SLMM_BASE_URL", "http://localhost:8100")
+                async with httpx.AsyncClient(timeout=600.0) as client:
+                    zip_response = await client.post(
+                        f"{SLMM_BASE_URL}/api/nl43/{unit_id}/ftp/download-folder",
+                        json={"remote_path": remote_path}
+                    )
+
+                if zip_response.is_success and len(zip_response.content) > 22:
+                    base_dir = Path(f"data/Projects/{action.project_id}/{active_session.id}/{folder_name}")
+                    base_dir.mkdir(parents=True, exist_ok=True)
+
+                    file_type_map = {
+                        '.wav': 'audio', '.mp3': 'audio',
+                        '.csv': 'data', '.txt': 'data', '.json': 'data', '.dat': 'data',
+                        '.rnd': 'data', '.rnh': 'data',
+                        '.log': 'log',
+                        '.zip': 'archive',
+                        '.jpg': 'image', '.jpeg': 'image', '.png': 'image',
+                        '.pdf': 'document',
+                    }
+
+                    with zipfile.ZipFile(io.BytesIO(zip_response.content)) as zf:
+                        for zip_info in zf.filelist:
+                            if zip_info.is_dir():
+                                continue
+                            file_data = zf.read(zip_info.filename)
+                            file_path = base_dir / zip_info.filename
+                            file_path.parent.mkdir(parents=True, exist_ok=True)
+                            with open(file_path, 'wb') as f:
+                                f.write(file_data)
+                            checksum = hashlib.sha256(file_data).hexdigest()
+                            ext = os.path.splitext(zip_info.filename)[1].lower()
+                            data_file = DataFile(
+                                id=str(uuid.uuid4()),
+                                session_id=active_session.id,
+                                file_path=str(file_path.relative_to("data")),
+                                file_type=file_type_map.get(ext, 'data'),
+                                file_size_bytes=len(file_data),
+                                downloaded_at=datetime.utcnow(),
+                                checksum=checksum,
+                                file_metadata=json.dumps({
+                                    "source": "stop_cycle",
+                                    "remote_path": remote_path,
+                                    "unit_id": unit_id,
+                                    "folder_name": folder_name,
+                                    "relative_path": zip_info.filename,
+                                }),
+                            )
+                            db.add(data_file)
+                            files_created += 1
+
+                    db.commit()
+                    logger.info(f"Created {files_created} DataFile records for session {active_session.id} from {folder_name}")
+                else:
+                    logger.warning(f"ZIP from SLMM for {folder_name} was empty or failed, skipping DataFile creation")
+
+            except Exception as e:
+                logger.error(f"Failed to extract ZIP and create DataFile records for {folder_name}: {e}")
+                # Don't fail the stop action — the device was stopped successfully
+
+        return {
+            "status": "stopped",
+            "session_id": active_session.id if active_session else None,
+            "cycle_response": cycle_response,
+            "files_created": files_created,
+        }
+
+    async def _execute_download(
+        self,
+        action: ScheduledAction,
+        unit_id: str,
+        db: Session,
+    ) -> Dict[str, Any]:
+        """Execute a 'download' action.
+
+        This handles standalone download actions (not part of stop_cycle).
+        The workflow is:
+        1. Enable FTP on device
+        2. Download current measurement folder
+        3. (Optionally disable FTP - left enabled for now)
+        """
+        # Get project and location info for file path
+        location = db.query(MonitoringLocation).filter_by(id=action.location_id).first()
+        project = db.query(Project).filter_by(id=action.project_id).first()
+
+        if not location or not project:
+            raise Exception("Project or location not found")
+
+        # Build destination path (for logging/metadata reference)
+        # Actual download location is managed by SLMM (data/downloads/{unit_id}/)
+        session_timestamp = datetime.utcnow().strftime("%Y-%m-%d-%H%M")
+        location_type_dir = "sound" if action.device_type == "slm" else "vibration"
+
+        destination_path = (
+            f"data/Projects/{project.id}/{location_type_dir}/"
+            f"{location.name}/session-{session_timestamp}/"
+        )
+
+        # Step 1: Disable FTP first to reset any stale connection state
+        # Then enable FTP on device
+        logger.info(f"Resetting FTP on {unit_id} for download (disable then enable)")
+        try:
+            await self.device_controller.disable_ftp(unit_id, action.device_type)
+        except Exception as e:
+            logger.warning(f"FTP disable failed (may already be off): {e}")
+        await self.device_controller.enable_ftp(unit_id, action.device_type)
+
+        # Step 2: Download current measurement folder
+        # The slmm_client.download_files() now automatically determines the correct
+        # folder based on the device's current index number
+        response = await self.device_controller.download_files(
+            unit_id,
+            action.device_type,
+            destination_path,
+            files=None,  # Download all files in current measurement folder
+        )
+
+        # TODO: Create DataFile records for downloaded files
+
+        return {
+            "status": "downloaded",
+            "destination_path": destination_path,
+            "device_response": response,
+        }
+
+    async def _execute_cycle(
+        self,
+        action: ScheduledAction,
+        unit_id: str,
+        db: Session,
+    ) -> Dict[str, Any]:
+        """Execute a full 'cycle' action: stop -> download -> start.
+
+        This combines stop, download, and start into a single action with
+        appropriate delays between steps to ensure device stability.
+
+        Workflow:
+        0. Pause background polling to prevent command conflicts
+        1. Stop measurement (wait 10s)
+        2. Disable FTP to reset state (wait 10s)
+        3. Enable FTP (wait 10s)
+        4. Download current measurement folder
+        5. Wait 30s for device to settle
+        6. Start new measurement cycle
+        7. Re-enable background polling
+
+        Total time: ~70-90 seconds depending on download size
+        """
+        logger.info(f"[CYCLE] === Starting full cycle for {unit_id} ===")
+
+        result = {
+            "status": "cycle_complete",
+            "steps": {},
+            "old_session_id": None,
+            "new_session_id": None,
+            "polling_paused": False,
+        }
+
+        # Step 0: Pause background polling for this device to prevent command conflicts
+        # NL-43 devices only support one TCP connection at a time
+        logger.info(f"[CYCLE] Step 0: Pausing background polling for {unit_id}")
+        polling_was_enabled = False
+        try:
+            if action.device_type == "slm":
+                # Get current polling state to restore later
+                from backend.services.slmm_client import get_slmm_client
+                slmm = get_slmm_client()
+                try:
+                    polling_config = await slmm.get_device_polling_config(unit_id)
+                    polling_was_enabled = polling_config.get("poll_enabled", False)
+                except Exception:
+                    polling_was_enabled = True  # Assume enabled if can't check
+
+                # Disable polling during cycle
+                await slmm.update_device_polling_config(unit_id, poll_enabled=False)
+                result["polling_paused"] = True
+                logger.info(f"[CYCLE] Background polling paused for {unit_id}")
+        except Exception as e:
+            logger.warning(f"[CYCLE] Failed to pause polling (continuing anyway): {e}")
+
+        try:
+            # Step 1: Stop measurement
+            logger.info(f"[CYCLE] Step 1/7: Stopping measurement on {unit_id}")
+            try:
+                stop_response = await self.device_controller.stop_recording(unit_id, action.device_type)
+                result["steps"]["stop"] = {"success": True, "response": stop_response}
+                logger.info(f"[CYCLE] Measurement stopped, waiting 10s...")
+            except Exception as e:
+                logger.warning(f"[CYCLE] Stop failed (may already be stopped): {e}")
+                result["steps"]["stop"] = {"success": False, "error": str(e)}
+
+            await asyncio.sleep(10)
+
+            # Step 2: Disable FTP to reset any stale state
+            logger.info(f"[CYCLE] Step 2/7: Disabling FTP on {unit_id}")
+            try:
+                await self.device_controller.disable_ftp(unit_id, action.device_type)
+                result["steps"]["ftp_disable"] = {"success": True}
+                logger.info(f"[CYCLE] FTP disabled, waiting 10s...")
+            except Exception as e:
+                logger.warning(f"[CYCLE] FTP disable failed (may already be off): {e}")
+                result["steps"]["ftp_disable"] = {"success": False, "error": str(e)}
+
+            await asyncio.sleep(10)
+
+            # Step 3: Enable FTP
+            logger.info(f"[CYCLE] Step 3/7: Enabling FTP on {unit_id}")
+            try:
+                await self.device_controller.enable_ftp(unit_id, action.device_type)
+                result["steps"]["ftp_enable"] = {"success": True}
+                logger.info(f"[CYCLE] FTP enabled, waiting 10s...")
+            except Exception as e:
+                logger.error(f"[CYCLE] FTP enable failed: {e}")
+                result["steps"]["ftp_enable"] = {"success": False, "error": str(e)}
+                # Continue anyway - download will fail but we can still try to start
+
+            await asyncio.sleep(10)
+
+            # Step 4: Download current measurement folder
+            logger.info(f"[CYCLE] Step 4/7: Downloading measurement data from {unit_id}")
+            location = db.query(MonitoringLocation).filter_by(id=action.location_id).first()
+            project = db.query(Project).filter_by(id=action.project_id).first()
+
+            if location and project:
+                session_timestamp = datetime.utcnow().strftime("%Y-%m-%d-%H%M")
+                location_type_dir = "sound" if action.device_type == "slm" else "vibration"
+                destination_path = (
+                    f"data/Projects/{project.id}/{location_type_dir}/"
+                    f"{location.name}/session-{session_timestamp}/"
+                )
+
+                try:
+                    download_response = await self.device_controller.download_files(
+                        unit_id,
+                        action.device_type,
+                        destination_path,
+                        files=None,
+                    )
+                    result["steps"]["download"] = {"success": True, "response": download_response}
+                    logger.info(f"[CYCLE] Download complete")
+                except Exception as e:
+                    logger.error(f"[CYCLE] Download failed: {e}")
+                    result["steps"]["download"] = {"success": False, "error": str(e)}
+            else:
+                result["steps"]["download"] = {"success": False, "error": "Project or location not found"}
+
+            # Close out the old recording session
+            active_session = db.query(MonitoringSession).filter(
+                and_(
+                    MonitoringSession.location_id == action.location_id,
+                    MonitoringSession.unit_id == unit_id,
+                    MonitoringSession.status == "recording",
+                )
+            ).first()
+
+            if active_session:
+                active_session.stopped_at = datetime.utcnow()
+                active_session.status = "completed"
+                active_session.duration_seconds = int(
+                    (active_session.stopped_at - active_session.started_at).total_seconds()
+                )
+                result["old_session_id"] = active_session.id
+
+            # Step 5: Wait for device to settle before starting new measurement
+            logger.info(f"[CYCLE] Step 5/7: Waiting 30s for device to settle...")
+            await asyncio.sleep(30)
+
+            # Step 6: Start new measurement cycle
+            logger.info(f"[CYCLE] Step 6/7: Starting new measurement on {unit_id}")
+            try:
+                cycle_response = await self.device_controller.start_cycle(
+                    unit_id,
+                    action.device_type,
+                    sync_clock=True,
+                )
+                result["steps"]["start"] = {"success": True, "response": cycle_response}
+
+                # Create new recording session
+                new_session = MonitoringSession(
+                    id=str(uuid.uuid4()),
+                    project_id=action.project_id,
+                    location_id=action.location_id,
+                    unit_id=unit_id,
+                    session_type="sound" if action.device_type == "slm" else "vibration",
+                    started_at=datetime.utcnow(),
+                    status="recording",
+                    session_metadata=json.dumps({
+                        "scheduled_action_id": action.id,
+                        "cycle_response": cycle_response,
+                        "action_type": "cycle",
+                    }),
+                )
+                db.add(new_session)
+                result["new_session_id"] = new_session.id
+
+                logger.info(f"[CYCLE] New measurement started, session {new_session.id}")
+
+            except Exception as e:
+                logger.error(f"[CYCLE] Start failed: {e}")
+                result["steps"]["start"] = {"success": False, "error": str(e)}
+                raise  # Re-raise to mark the action as failed
+
+        finally:
+            # Step 7: Re-enable background polling (always runs, even on failure)
+            if result.get("polling_paused") and polling_was_enabled:
+                logger.info(f"[CYCLE] Step 7/7: Re-enabling background polling for {unit_id}")
+                try:
+                    if action.device_type == "slm":
+                        from backend.services.slmm_client import get_slmm_client
+                        slmm = get_slmm_client()
+                        await slmm.update_device_polling_config(unit_id, poll_enabled=True)
+                        logger.info(f"[CYCLE] Background polling re-enabled for {unit_id}")
+                except Exception as e:
+                    logger.error(f"[CYCLE] Failed to re-enable polling: {e}")
+                    # Don't raise - cycle completed, just log the error
+
+        logger.info(f"[CYCLE] === Cycle complete for {unit_id} ===")
+        return result
+
+    # ========================================================================
+    # Recurring Schedule Generation
+    # ========================================================================
+
+    async def generate_recurring_actions(self) -> int:
+        """
+        Generate ScheduledActions from all enabled recurring schedules.
+
+        Runs once per hour to generate actions for the next 7 days.
+
+        Returns:
+            Total number of actions generated
+        """
+        db = SessionLocal()
+        total_generated = 0
+
+        try:
+            from backend.services.recurring_schedule_service import get_recurring_schedule_service
+
+            service = get_recurring_schedule_service(db)
+            schedules = service.get_enabled_schedules()
+
+            if not schedules:
+                logger.debug("No enabled recurring schedules found")
+                return 0
+
+            logger.info(f"Generating actions for {len(schedules)} recurring schedule(s)")
+
+            for schedule in schedules:
+                try:
+                    # Auto-disable one-off schedules whose end time has passed
+                    if schedule.schedule_type == "one_off" and schedule.end_datetime:
+                        if schedule.end_datetime <= datetime.utcnow():
+                            schedule.enabled = False
+                            schedule.next_occurrence = None
+                            db.commit()
+                            logger.info(f"Auto-disabled completed one-off schedule: {schedule.name}")
+                            continue
+
+                    actions = service.generate_actions_for_schedule(schedule, horizon_days=7)
+                    total_generated += len(actions)
+                except Exception as e:
+                    logger.error(f"Error generating actions for schedule {schedule.id}: {e}")
+
+            if total_generated > 0:
+                logger.info(f"Generated {total_generated} scheduled actions from recurring schedules")
+
+        except Exception as e:
+            logger.error(f"Error in generate_recurring_actions: {e}", exc_info=True)
+        finally:
+            db.close()
+
+        return total_generated
+
+    async def cleanup_old_actions(self, retention_days: int = 30) -> int:
+        """
+        Remove old completed/failed actions to prevent database bloat.
+
+        Args:
+            retention_days: Keep actions newer than this many days
+
+        Returns:
+            Number of actions cleaned up
+        """
+        db = SessionLocal()
+        cleaned = 0
+
+        try:
+            cutoff = datetime.utcnow() - timedelta(days=retention_days)
+
+            old_actions = db.query(ScheduledAction).filter(
+                and_(
+                    ScheduledAction.execution_status.in_(["completed", "failed", "cancelled"]),
+                    ScheduledAction.executed_at < cutoff,
+                )
+            ).all()
+
+            cleaned = len(old_actions)
+            for action in old_actions:
+                db.delete(action)
+
+            if cleaned > 0:
+                db.commit()
+                logger.info(f"Cleaned up {cleaned} old scheduled actions (>{retention_days} days)")
+
+        except Exception as e:
+            logger.error(f"Error cleaning up old actions: {e}")
+            db.rollback()
+        finally:
+            db.close()
+
+        return cleaned
+
+    # ========================================================================
+    # Manual Execution (for testing/debugging)
+    # ========================================================================
+
+    async def execute_action_by_id(self, action_id: str) -> Dict[str, Any]:
+        """
+        Manually execute a specific action by ID.
+
+        Args:
+            action_id: ScheduledAction ID
+
+        Returns:
+            Execution result
+        """
+        db = SessionLocal()
+        try:
+            action = db.query(ScheduledAction).filter_by(id=action_id).first()
+            if not action:
+                return {"success": False, "error": "Action not found"}
+
+            result = await self._execute_action(action, db)
+            db.commit()
+            return result
+
+        except Exception as e:
+            db.rollback()
+            return {"success": False, "error": str(e)}
+        finally:
+            db.close()
+
+
+# Singleton instance
+_scheduler_instance: Optional[SchedulerService] = None
+
+
+def get_scheduler() -> SchedulerService:
+    """
+    Get the scheduler singleton instance.
+
+    Returns:
+        SchedulerService instance
+    """
+    global _scheduler_instance
+    if _scheduler_instance is None:
+        _scheduler_instance = SchedulerService()
+    return _scheduler_instance
+
+
+async def start_scheduler():
+    """Start the global scheduler instance."""
+    scheduler = get_scheduler()
+    await scheduler.start()
+
+
+def stop_scheduler():
+    """Stop the global scheduler instance."""
+    scheduler = get_scheduler()
+    scheduler.stop()

backend/services/slm_status_sync.py

@@ -0,0 +1,129 @@
+"""
+SLM Status Synchronization Service
+
+Syncs SLM device status from SLMM backend to Terra-View's Emitter table.
+This bridges SLMM's polling data with Terra-View's status snapshot system.
+
+SLMM tracks device reachability via background polling. This service
+fetches that data and creates/updates Emitter records so SLMs appear
+correctly in the dashboard status snapshot.
+"""
+
+import logging
+from datetime import datetime, timezone
+from typing import Dict, Any
+
+from backend.database import get_db_session
+from backend.models import Emitter
+from backend.services.slmm_client import get_slmm_client, SLMMClientError
+
+logger = logging.getLogger(__name__)
+
+
+async def sync_slm_status_to_emitters() -> Dict[str, Any]:
+    """
+    Fetch SLM status from SLMM and sync to Terra-View's Emitter table.
+
+    For each device in SLMM's polling status:
+    - If last_success exists, create/update Emitter with that timestamp
+    - If not reachable, update Emitter with last known timestamp (or None)
+
+    Returns:
+        Dict with synced_count, error_count, errors list
+    """
+    client = get_slmm_client()
+    synced = 0
+    errors = []
+
+    try:
+        # Get polling status from SLMM
+        status_response = await client.get_polling_status()
+
+        # Handle nested response structure
+        data = status_response.get("data", status_response)
+        devices = data.get("devices", [])
+
+        if not devices:
+            logger.debug("No SLM devices in SLMM polling status")
+            return {"synced_count": 0, "error_count": 0, "errors": []}
+
+        db = get_db_session()
+        try:
+            for device in devices:
+                unit_id = device.get("unit_id")
+                if not unit_id:
+                    continue
+
+                try:
+                    # Get or create Emitter record
+                    emitter = db.query(Emitter).filter(Emitter.id == unit_id).first()
+
+                    # Determine last_seen from SLMM data
+                    last_success_str = device.get("last_success")
+                    is_reachable = device.get("is_reachable", False)
+
+                    if last_success_str:
+                        # Parse ISO format timestamp
+                        last_seen = datetime.fromisoformat(
+                            last_success_str.replace("Z", "+00:00")
+                        )
+                        # Convert to naive UTC for consistency with existing code
+                        if last_seen.tzinfo:
+                            last_seen = last_seen.astimezone(timezone.utc).replace(tzinfo=None)
+                    elif is_reachable:
+                        # Device is reachable but no last_success yet (first poll or just started)
+                        # Use current time so it shows as OK, not Missing
+                        last_seen = datetime.utcnow()
+                    else:
+                        last_seen = None
+
+                    # Status will be recalculated by snapshot.py based on time thresholds
+                    # Just store a provisional status here
+                    status = "OK" if is_reachable else "Missing"
+
+                    # Store last error message if available
+                    last_error = device.get("last_error") or ""
+
+                    if emitter:
+                        # Update existing record
+                        emitter.last_seen = last_seen
+                        emitter.status = status
+                        emitter.unit_type = "slm"
+                        emitter.last_file = last_error
+                    else:
+                        # Create new record
+                        emitter = Emitter(
+                            id=unit_id,
+                            unit_type="slm",
+                            last_seen=last_seen,
+                            last_file=last_error,
+                            status=status
+                        )
+                        db.add(emitter)
+
+                    synced += 1
+
+                except Exception as e:
+                    errors.append(f"{unit_id}: {str(e)}")
+                    logger.error(f"Error syncing SLM {unit_id}: {e}")
+
+            db.commit()
+
+        finally:
+            db.close()
+
+        if synced > 0:
+            logger.info(f"Synced {synced} SLM device(s) to Emitter table")
+
+    except SLMMClientError as e:
+        logger.warning(f"Could not reach SLMM for status sync: {e}")
+        errors.append(f"SLMM unreachable: {str(e)}")
+    except Exception as e:
+        logger.error(f"Error in SLM status sync: {e}", exc_info=True)
+        errors.append(str(e))
+
+    return {
+        "synced_count": synced,
+        "error_count": len(errors),
+        "errors": errors
+    }