Merge pull request 'merge watcher from dev to main (0.8.0)' (#34 ) from dev into main

Reviewed-on: #34
2026-03-18 16:05:46 -04:00
19 changed files with 199 additions and 2061 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,63 +5,6 @@ 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.9.1] - 2026-03-23
-
-### Fixed
- **Location slots not persisting**: Empty monitoring location slots (no unit assigned yet) were lost on save/reload. Added `location_slots` JSON column to `job_reservations` to store the full slot list including empty slots.
- **Modems in Recent Alerts**: Modems no longer appear in the dashboard Recent Alerts panel — alerts are for seismographs and SLMs only. Modem status is still tracked internally via paired device inheritance.
-
-### Migration Notes
-Run on each database before deploying:
-```bash
-docker compose exec terra-view python3 backend/migrate_add_location_slots.py
-```
-
---
-
-## [0.9.0] - 2026-03-19
-
-### Added
- **Job Planner**: Full redesign of the Fleet Calendar into a two-tab Job Planner / Calendar interface
-  - **Planner tab**: Create and manage job reservations with name, device type, dates, color, estimated units, and monitoring locations
-  - **Calendar tab**: 12-month rolling heatmap with colored job bars per day; confirmed jobs solid, planned jobs dashed
-  - **Monitoring Locations**: Each job has named location slots (filled = unit assigned, empty = needs a unit); progress shown as `2/5` with colored squares that fill as units are assigned
-  - **Estimated Units**: Separate planning number independent of actual location count; shown prominently on job cards
-  - **Fleet Summary panel**: Unit counts as clickable filter buttons; unit list shows reservation badges with job name, dates, and color
-  - **Available Units panel**: Shows units available for the job's date range when assigning
-  - **Smart color picker**: 18-swatch palette + custom color wheel; new jobs auto-pick a color maximally distant in hue from existing jobs
-  - **Job card progress**: `est. N · X/Y (Z more)` with filled/empty squares; amber → green when fully assigned
-  - **Promote to Project**: Promote a planned job to a tracked project directly from the planner form
-  - **Collapsible job details**: Name, dates, device type, color, project link, and estimated units collapse into a summary header
-  - **Calendar bar tooltips**: Hover any job bar to see job name and date range
-  - **Hash-based tab persistence**: `#cal` in URL restores Calendar tab on refresh; device type toggle preserves active tab
-  - **Auto-scroll to today**: Switching to Calendar tab smooth-scrolls to the current month
-  - **Upcoming project status**: New `upcoming` status for projects promoted from reservations
- **Job device type**: Reservations carry a device type so they only appear on the correct calendar
- **Project filtering by device type**: Projects only appear on the calendar matching their type (vibration → seismograph, sound → SLM, combined → both)
- **Confirmed/Planned toggles**: Independent show/hide toggles for job bar layers on the calendar
- **Cal expire dots toggle**: Calibration expiry dots off by default, togglable
-
-### Changed
- **Renamed**: "Fleet Calendar" / "Reservation Planner" → **"Job Planner"** throughout UI and sidebar
- **Project status dropdown**: Inline `<select>` in project header for quick status changes
- **"All Projects" tab**: Shows everything except deleted; default view excludes archived/completed
- **Toast notifications**: All `alert()` dialogs replaced with non-blocking toasts (green = success, red = error)
-
-### Migration Notes
-Run on each database before deploying:
-```bash
-docker compose exec terra-view python3 -c "
-import sqlite3
-conn = sqlite3.connect('/app/data/seismo_fleet.db')
-conn.execute('ALTER TABLE job_reservations ADD COLUMN estimated_units INTEGER')
-conn.commit()
-conn.close()
-"
-```
-
---
-
 ## [0.8.0] - 2026-03-18

 ### Added
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Terra-View v0.9.1
+# Terra-View v0.8.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
--- a/backend/main.py
+++ b/backend/main.py
@@ -30,7 +30,7 @@ Base.metadata.create_all(bind=engine)
 ENVIRONMENT = os.getenv("ENVIRONMENT", "production")

 # Initialize FastAPI app
-VERSION = "0.9.1"
+VERSION = "0.8.0"
 if ENVIRONMENT == "development":
    _build = os.getenv("BUILD_NUMBER", "0")
    if _build and _build != "0":
--- a/backend/migrate_add_estimated_units.py
+++ b/backend/migrate_add_estimated_units.py
@@ -1,62 +0,0 @@
-"""
-Migration: Add estimated_units to job_reservations
-
-Adds column:
- job_reservations.estimated_units: Estimated number of units for the reservation (nullable integer)
-"""
-
-import sqlite3
-import sys
-from pathlib import Path
-
-# Default database path (matches production pattern)
-DB_PATH = "./data/seismo_fleet.db"
-
-
-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 estimated_units column if it doesn't exist
-        if 'estimated_units' not in existing_cols:
-            print("Adding estimated_units column to job_reservations...")
-            cursor.execute("ALTER TABLE job_reservations ADD COLUMN estimated_units INTEGER")
-        else:
-            print("estimated_units 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 = DB_PATH
-
-    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)
--- a/backend/migrate_add_location_slots.py
+++ b/backend/migrate_add_location_slots.py
@@ -1,24 +0,0 @@
-"""
-Migration: Add location_slots column to job_reservations table.
-Stores the full ordered slot list (including empty/unassigned slots) as JSON.
-Run once per database.
-"""
-import sqlite3
-import os
-
-DB_PATH = os.environ.get("DB_PATH", "/app/data/seismo_fleet.db")
-
-def run():
-    conn = sqlite3.connect(DB_PATH)
-    cursor = conn.cursor()
-    existing = [r[1] for r in cursor.execute("PRAGMA table_info(job_reservations)").fetchall()]
-    if "location_slots" not in existing:
-        cursor.execute("ALTER TABLE job_reservations ADD COLUMN location_slots TEXT")
-        conn.commit()
-        print("Added location_slots column to job_reservations.")
-    else:
-        print("location_slots column already exists, skipping.")
-    conn.close()
-
-if __name__ == "__main__":
-    run()
--- a/backend/models.py
+++ b/backend/models.py
@@ -480,11 +480,6 @@ class JobReservation(Base):
    # For quantity reservations
    device_type = Column(String, default="seismograph")  # seismograph | slm
    quantity_needed = Column(Integer, nullable=True)  # e.g., 8 units
-    estimated_units = Column(Integer, nullable=True)
-
-    # Full slot list as JSON: [{"location_name": "North Gate", "unit_id": null}, ...]
-    # Includes empty slots (no unit assigned yet). Filled slots are authoritative in JobReservationUnit.
-    location_slots = Column(Text, nullable=True)

    # Metadata
    notes = Column(Text, nullable=True)
@@ -520,10 +515,3 @@ class JobReservationUnit(Base):
    assignment_source = Column(String, default="specific")  # "specific" | "filled" | "swap"
    assigned_at = Column(DateTime, default=datetime.utcnow)
    notes = Column(Text, nullable=True)  # "Replacing BE17353" etc.
-
-    # Power requirements for this deployment slot
-    power_type = Column(String, nullable=True)  # "ac" | "solar" | None
-
-    # Location identity
-    location_name = Column(String, nullable=True)  # e.g. "North Gate", "Main Entrance"
-    slot_index = Column(Integer, nullable=True)     # Order within reservation (0-based)
--- a/backend/routers/fleet_calendar.py
+++ b/backend/routers/fleet_calendar.py
@@ -19,7 +19,7 @@ import logging
 from backend.database import get_db
 from backend.models import (
    RosterUnit, JobReservation, JobReservationUnit,
-    UserPreferences, Project, MonitoringLocation, UnitAssignment
+    UserPreferences, Project
 )
 from backend.templates_config import templates
 from backend.services.fleet_calendar_service import (
@@ -61,53 +61,9 @@ async def fleet_calendar_page(

    # Get projects for the reservation form dropdown
    projects = db.query(Project).filter(
-        Project.status.in_(["active", "upcoming", "on_hold"])
+        Project.status == "active"
    ).order_by(Project.name).all()

-    # Build a serializable list of items with dates for calendar bars
-    # Includes both tracked Projects (with dates) and Job Reservations (matching device_type)
-    project_colors = ['#3B82F6', '#10B981', '#F59E0B', '#EF4444', '#8B5CF6', '#EC4899', '#06B6D4', '#F97316']
-    # Map calendar device_type to project_type_ids
-    device_type_to_project_types = {
-        "seismograph": ["vibration_monitoring", "combined"],
-        "slm": ["sound_monitoring", "combined"],
-    }
-    relevant_project_types = device_type_to_project_types.get(device_type, [])
-
-    calendar_projects = []
-    for i, p in enumerate(projects):
-        if p.start_date and p.project_type_id in relevant_project_types:
-            calendar_projects.append({
-                "id": p.id,
-                "name": p.name,
-                "start_date": p.start_date.isoformat(),
-                "end_date": p.end_date.isoformat() if p.end_date else None,
-                "color": project_colors[i % len(project_colors)],
-                "confirmed": True,
-            })
-
-    # Add job reservations for this device_type as bars
-    from sqlalchemy import or_ as _or
-    cal_window_end = date(year + ((month + 10) // 12), ((month + 10) % 12) + 1, 1)
-    reservations_for_cal = db.query(JobReservation).filter(
-        JobReservation.device_type == device_type,
-        JobReservation.start_date <= cal_window_end,
-        _or(
-            JobReservation.end_date >= date(year, month, 1),
-            JobReservation.end_date == None,
-        )
-    ).all()
-    for res in reservations_for_cal:
-        end = res.end_date or res.estimated_end_date
-        calendar_projects.append({
-            "id": res.id,
-            "name": res.name,
-            "start_date": res.start_date.isoformat(),
-            "end_date": end.isoformat() if end else None,
-            "color": res.color,
-            "confirmed": bool(res.project_id),
-        })
-
    # 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)
@@ -125,7 +81,6 @@ async def fleet_calendar_page(
            "device_type": device_type,
            "calendar_data": calendar_data,
            "projects": projects,
-            "calendar_projects": calendar_projects,
            "today": today.isoformat()
        }
    )
@@ -212,7 +167,6 @@ async def create_reservation(
    if estimated_end_date and estimated_end_date < start_date:
        raise HTTPException(status_code=400, detail="Estimated end date must be after start date")

-    import json as _json
    reservation = JobReservation(
        id=str(uuid.uuid4()),
        name=data["name"],
@@ -224,8 +178,6 @@ async def create_reservation(
        assignment_type=data["assignment_type"],
        device_type=data.get("device_type", "seismograph"),
        quantity_needed=data.get("quantity_needed"),
-        estimated_units=data.get("estimated_units"),
-        location_slots=_json.dumps(data["location_slots"]) if data.get("location_slots") is not None else None,
        notes=data.get("notes"),
        color=data.get("color", "#3B82F6")
    )
@@ -269,16 +221,8 @@ async def get_reservation(
        reservation_id=reservation_id
    ).all()

-    # Sort assignments by slot_index so order is preserved
-    assignments_sorted = sorted(assignments, key=lambda a: (a.slot_index if a.slot_index is not None else 999))
-    unit_ids = [a.unit_id for a in assignments_sorted]
+    unit_ids = [a.unit_id for a in assignments]
    units = db.query(RosterUnit).filter(RosterUnit.id.in_(unit_ids)).all() if unit_ids else []
-    units_by_id = {u.id: u for u in units}
-    # Build per-unit lookups from assignments
-    assignment_map = {a.unit_id: a for a in assignments_sorted}
-
-    import json as _json
-    stored_slots = _json.loads(reservation.location_slots) if reservation.location_slots else None

    return {
        "id": reservation.id,
@@ -291,21 +235,15 @@ async def get_reservation(
        "assignment_type": reservation.assignment_type,
        "device_type": reservation.device_type,
        "quantity_needed": reservation.quantity_needed,
-        "estimated_units": reservation.estimated_units,
-        "location_slots": stored_slots,
        "notes": reservation.notes,
        "color": reservation.color,
        "assigned_units": [
            {
-                "id": uid,
-                "last_calibrated": units_by_id[uid].last_calibrated.isoformat() if uid in units_by_id and units_by_id[uid].last_calibrated else None,
-                "deployed": units_by_id[uid].deployed if uid in units_by_id else False,
-                "power_type": assignment_map[uid].power_type,
-                "notes": assignment_map[uid].notes,
-                "location_name": assignment_map[uid].location_name,
-                "slot_index": assignment_map[uid].slot_index,
+                "id": u.id,
+                "last_calibrated": u.last_calibrated.isoformat() if u.last_calibrated else None,
+                "deployed": u.deployed
            }
-            for uid in unit_ids
+            for u in units
        ]
    }

@@ -340,11 +278,6 @@ async def update_reservation(
        reservation.assignment_type = data["assignment_type"]
    if "quantity_needed" in data:
        reservation.quantity_needed = data["quantity_needed"]
-    if "estimated_units" in data:
-        reservation.estimated_units = data["estimated_units"]
-    if "location_slots" in data:
-        import json as _json
-        reservation.location_slots = _json.dumps(data["location_slots"]) if data["location_slots"] is not None else None
    if "notes" in data:
        reservation.notes = data["notes"]
    if "color" in data:
@@ -404,57 +337,52 @@ async def assign_units_to_reservation(

    data = await request.json()
    unit_ids = data.get("unit_ids", [])
-    # Optional per-unit dicts keyed by unit_id
-    power_types = data.get("power_types", {})
-    location_notes = data.get("location_notes", {})
-    location_names = data.get("location_names", {})
-    # slot_indices: {"BE17354": 0, "BE9441": 1, ...}
-    slot_indices = data.get("slot_indices", {})

-    # Verify units exist (allow empty list to clear all assignments)
-    if unit_ids:
-        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)}")
+    if not unit_ids:
+        raise HTTPException(status_code=400, detail="No units specified")

-    # Full replace: delete all existing assignments for this reservation first
-    db.query(JobReservationUnit).filter_by(reservation_id=reservation_id).delete()
-    db.flush()
+    # 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 with other reservations and insert new assignments
+    # Check for conflicts (already assigned to overlapping reservations)
    conflicts = []
    for unit_id in unit_ids:
-        # Check overlapping reservations
-        if reservation.end_date:
-            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()
+        # 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

-            if overlapping:
-                conflicts.append({
-                    "unit_id": unit_id,
-                    "conflict_reservation": overlapping.name,
-                    "conflict_dates": f"{overlapping.start_date} - {overlapping.end_date}"
-                })
-                continue
+        # 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",
-            power_type=power_types.get(unit_id),
-            notes=location_notes.get(unit_id),
-            location_name=location_names.get(unit_id),
-            slot_index=slot_indices.get(unit_id),
+            assignment_source="filled" if reservation.assignment_type == "quantity" else "specific"
        )
        db.add(assignment)

@@ -583,7 +511,7 @@ async def get_reservations_list(
    else:
        end_date = date(end_year, end_month + 1, 1) - timedelta(days=1)

-    # Filter by device_type and date window
+    # Include TBD reservations that started before window end
    reservations = db.query(JobReservation).filter(
        JobReservation.device_type == device_type,
        JobReservation.start_date <= end_date,
@@ -596,38 +524,16 @@ async def get_reservations_list(
    # Get assignment counts
    reservation_data = []
    for res in reservations:
-        assignments = db.query(JobReservationUnit).filter_by(
+        assigned_count = db.query(JobReservationUnit).filter_by(
            reservation_id=res.id
-        ).all()
-        assigned_count = len(assignments)
-
-        # Enrich assignments with unit details, sorted by slot_index
-        assignments_sorted = sorted(assignments, key=lambda a: (a.slot_index if a.slot_index is not None else 999))
-        unit_ids = [a.unit_id for a in assignments_sorted]
-        units = db.query(RosterUnit).filter(RosterUnit.id.in_(unit_ids)).all() if unit_ids else []
-        units_by_id = {u.id: u for u in units}
-        assigned_units = [
-            {
-                "id": a.unit_id,
-                "power_type": a.power_type,
-                "notes": a.notes,
-                "location_name": a.location_name,
-                "slot_index": a.slot_index,
-                "deployed": units_by_id[a.unit_id].deployed if a.unit_id in units_by_id else False,
-                "last_calibrated": units_by_id[a.unit_id].last_calibrated if a.unit_id in units_by_id else None,
-            }
-            for a in assignments_sorted
-        ]
+        ).count()

        # Check for calibration conflicts
        conflicts = check_calibration_conflicts(db, res.id)

-        location_count = res.quantity_needed or assigned_count
        reservation_data.append({
            "reservation": res,
            "assigned_count": assigned_count,
-            "location_count": location_count,
-            "assigned_units": assigned_units,
            "has_conflicts": len(conflicts) > 0,
            "conflict_count": len(conflicts)
        })
@@ -643,79 +549,6 @@ async def get_reservations_list(
    )


-@router.get("/api/fleet-calendar/planner-availability", response_class=JSONResponse)
-async def get_planner_availability(
-    device_type: str = "seismograph",
-    start_date: Optional[str] = None,
-    end_date: Optional[str] = None,
-    exclude_reservation_id: Optional[str] = None,
-    db: Session = Depends(get_db)
-):
-    """Get available units for the reservation planner split-panel UI.
-    Dates are optional — if omitted, returns all non-retired units regardless of reservations.
-    """
-    if start_date and end_date:
-        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")
-        units = get_available_units_for_period(db, start, end, device_type, exclude_reservation_id)
-    else:
-        # No dates: return all non-retired units of this type, with current reservation info
-        from backend.models import RosterUnit as RU
-        from datetime import timedelta
-        today = date.today()
-        all_units = db.query(RU).filter(
-            RU.device_type == device_type,
-            RU.retired == False
-        ).all()
-
-        # Build a map: unit_id -> list of active/upcoming reservations
-        active_assignments = db.query(JobReservationUnit).join(
-            JobReservation, JobReservationUnit.reservation_id == JobReservation.id
-        ).filter(
-            JobReservation.device_type == device_type,
-            JobReservation.end_date >= today
-        ).all()
-        unit_reservations = {}
-        for assignment in active_assignments:
-            res = db.query(JobReservation).filter(JobReservation.id == assignment.reservation_id).first()
-            if not res:
-                continue
-            unit_reservations.setdefault(assignment.unit_id, []).append({
-                "reservation_id": res.id,
-                "reservation_name": res.name,
-                "start_date": res.start_date.isoformat() if res.start_date else None,
-                "end_date": res.end_date.isoformat() if res.end_date else None,
-                "color": res.color or "#3B82F6"
-            })
-
-        units = []
-        for u in all_units:
-            expiry = (u.last_calibrated + timedelta(days=365)) if u.last_calibrated else None
-            units.append({
-                "id": u.id,
-                "last_calibrated": u.last_calibrated.isoformat() if u.last_calibrated else None,
-                "expiry_date": expiry.isoformat() if expiry else None,
-                "calibration_status": "needs_calibration" if not u.last_calibrated else "valid",
-                "deployed": u.deployed,
-                "out_for_calibration": u.out_for_calibration or False,
-                "note": u.note or "",
-                "reservations": unit_reservations.get(u.id, [])
-            })
-
-    # Sort: benched first (easier to assign), then deployed, then by ID
-    units.sort(key=lambda u: (1 if u["deployed"] else 0, u["id"]))
-
-    return {
-        "units": units,
-        "start_date": start_date,
-        "end_date": end_date,
-        "count": len(units)
-    }
-
-
@router.get("/api/fleet-calendar/available-units", response_class=HTMLResponse)
 async def get_available_units_partial(
    request: Request,
@@ -775,102 +608,3 @@ async def get_month_partial(
            "today": date.today().isoformat()
        }
    )
-
-
-# ============================================================================
-# Promote Reservation to Project
-# ============================================================================
-
-@router.post("/api/fleet-calendar/reservations/{reservation_id}/promote-to-project", response_class=JSONResponse)
-async def promote_reservation_to_project(
-    reservation_id: str,
-    request: Request,
-    db: Session = Depends(get_db)
-):
-    """
-    Promote a job reservation to a full project in the projects DB.
-    Creates: Project + MonitoringLocations + UnitAssignments.
-    """
-    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()
-    project_number = data.get("project_number") or None
-    client_name = data.get("client_name") or None
-
-    # Map device_type to project_type_id
-    if reservation.device_type == "slm":
-        project_type_id = "sound_monitoring"
-        location_type = "sound"
-    else:
-        project_type_id = "vibration_monitoring"
-        location_type = "vibration"
-
-    # Check for duplicate project name
-    existing = db.query(Project).filter_by(name=reservation.name).first()
-    if existing:
-        raise HTTPException(status_code=409, detail=f"A project named '{reservation.name}' already exists.")
-
-    # Create the project
-    project_id = str(uuid.uuid4())
-    project = Project(
-        id=project_id,
-        name=reservation.name,
-        project_number=project_number,
-        client_name=client_name,
-        project_type_id=project_type_id,
-        status="upcoming",
-        start_date=reservation.start_date,
-        end_date=reservation.end_date,
-        description=reservation.notes,
-    )
-    db.add(project)
-    db.flush()
-
-    # Load assignments sorted by slot_index
-    assignments = db.query(JobReservationUnit).filter_by(reservation_id=reservation_id).all()
-    assignments_sorted = sorted(assignments, key=lambda a: (a.slot_index if a.slot_index is not None else 999))
-
-    locations_created = 0
-    units_assigned = 0
-
-    for i, assignment in enumerate(assignments_sorted):
-        loc_num = str(i + 1).zfill(3)
-        loc_name = assignment.location_name or f"Location {i + 1}"
-
-        location = MonitoringLocation(
-            id=str(uuid.uuid4()),
-            project_id=project_id,
-            location_type=location_type,
-            name=loc_name,
-            description=assignment.notes,
-        )
-        db.add(location)
-        db.flush()
-        locations_created += 1
-
-        if assignment.unit_id:
-            unit_assignment = UnitAssignment(
-                id=str(uuid.uuid4()),
-                unit_id=assignment.unit_id,
-                location_id=location.id,
-                project_id=project_id,
-                device_type=reservation.device_type or "seismograph",
-                status="active",
-                notes=f"Power: {assignment.power_type}" if assignment.power_type else None,
-            )
-            db.add(unit_assignment)
-            units_assigned += 1
-
-    db.commit()
-
-    logger.info(f"Promoted reservation '{reservation.name}' to project {project_id}")
-
-    return {
-        "success": True,
-        "project_id": project_id,
-        "project_name": reservation.name,
-        "locations_created": locations_created,
-        "units_assigned": units_assigned,
-    }
--- a/backend/routers/projects.py
+++ b/backend/routers/projects.py
@@ -373,13 +373,11 @@ async def get_projects_list(
    """
    query = db.query(Project)

-    # Filter by status if provided; otherwise exclude archived/deleted from default view
-    if status == "all":
-        query = query.filter(Project.status != "deleted")
-    elif status:
+    # Filter by status if provided; otherwise exclude soft-deleted projects
+    if status:
        query = query.filter(Project.status == status)
    else:
-        query = query.filter(Project.status.notin_(["deleted", "archived", "completed"]))
+        query = query.filter(Project.status != "deleted")

    # Filter by project type if provided
    if project_type_id:
@@ -440,7 +438,6 @@ async def get_projects_stats(request: Request, db: Session = Depends(get_db)):
    """
    # Count projects by status (exclude deleted)
    total_projects = db.query(func.count(Project.id)).filter(Project.status != "deleted").scalar()
-    upcoming_projects = db.query(func.count(Project.id)).filter_by(status="upcoming").scalar()
    active_projects = db.query(func.count(Project.id)).filter_by(status="active").scalar()
    on_hold_projects = db.query(func.count(Project.id)).filter_by(status="on_hold").scalar()
    completed_projects = db.query(func.count(Project.id)).filter_by(status="completed").scalar()
@@ -462,7 +459,6 @@ async def get_projects_stats(request: Request, db: Session = Depends(get_db)):
        "request": request,
        "total_projects": total_projects,
        "active_projects": active_projects,
-        "upcoming_projects": upcoming_projects,
        "on_hold_projects": on_hold_projects,
        "completed_projects": completed_projects,
        "total_locations": total_locations,
--- a/backend/routes.py
+++ b/backend/routes.py
@@ -267,8 +267,7 @@ async def series4_heartbeat(request: Request, db: Session = Depends(get_db)):
    """
    payload = await request.json()

-    # Accept source_id (new standard field) with fallback to legacy "source" key
-    source = payload.get("source_id") or payload.get("source", "series4_emitter")
+    source = payload.get("source", "series4_emitter")
    units = payload.get("units", [])
    version = payload.get("version")
    log_tail = payload.get("log_tail")
--- a/backend/services/fleet_calendar_service.py
+++ b/backend/services/fleet_calendar_service.py
@@ -646,20 +646,22 @@ def get_available_units_for_period(
        if unit.id in reserved_unit_ids:
            continue

-        if unit.last_calibrated:
-            expiry_date = unit.last_calibrated + timedelta(days=365)
-            cal_status = get_calibration_status(unit, end_date, warning_days)
-        else:
-            expiry_date = None
-            cal_status = "needs_calibration"
+        # 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() if unit.last_calibrated else None,
-            "expiry_date": expiry_date.isoformat() if expiry_date else None,
+            "last_calibrated": unit.last_calibrated.isoformat(),
+            "expiry_date": expiry_date.isoformat(),
            "calibration_status": cal_status,
            "deployed": unit.deployed,
-            "out_for_calibration": unit.out_for_calibration or False,
            "note": unit.note or ""
        })

--- a/templates/base.html
+++ b/templates/base.html
@@ -85,7 +85,7 @@

    <div class="flex h-screen overflow-hidden">
        <!-- Sidebar (Responsive) -->
-        <aside id="sidebar" class="sidebar w-64 bg-white dark:bg-slate-800 shadow-lg flex flex-col{% if request.query_params.get('embed') == '1' %} hidden{% endif %}">
+        <aside id="sidebar" class="sidebar w-64 bg-white dark:bg-slate-800 shadow-lg flex flex-col">
            <!-- Logo -->
            <div class="p-6 border-b border-gray-200 dark:border-gray-700">
                <a href="/" class="block">
@@ -155,7 +155,7 @@
                    <svg class="w-5 h-5 mr-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"></path>
                    </svg>
-                    Job Planner
+                    Fleet Calendar
                </a>

                <a href="/settings" class="flex items-center px-4 py-3 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700 {% if request.url.path == '/settings' %}bg-gray-100 dark:bg-gray-700{% endif %}">
@@ -193,14 +193,14 @@

        <!-- Main content -->
        <main class="main-content flex-1 overflow-y-auto">
-            <div class="{% if request.query_params.get('embed') == '1' %}p-4{% else %}p-8{% endif %}">
+            <div class="p-8">
                {% block content %}{% endblock %}
            </div>
        </main>
    </div>

    <!-- Bottom Navigation (Mobile Only) -->
-    <nav class="bottom-nav{% if request.query_params.get('embed') == '1' %} hidden{% endif %}">
+    <nav class="bottom-nav">
        <div class="grid grid-cols-4 h-16">
            <button id="hamburgerBtn" class="bottom-nav-btn" onclick="toggleMenu()" aria-label="Menu">
                <svg fill="none" stroke="currentColor" viewBox="0 0 24 24">
--- a/templates/dashboard.html
+++ b/templates/dashboard.html
@@ -509,7 +509,7 @@ function renderFilteredDashboard(data) {
 // Update the Recent Alerts section with filtering
 function updateAlertsFiltered(filteredActive) {
    const alertsList = document.getElementById('alerts-list');
-    const missingUnits = Object.entries(filteredActive).filter(([_, u]) => u.status === 'Missing' && u.device_type !== 'modem');
+    const missingUnits = Object.entries(filteredActive).filter(([_, u]) => u.status === 'Missing');

    if (!missingUnits.length) {
        // Check if this is because of filters or genuinely no alerts
--- a/templates/fleet_calendar.html
+++ b/templates/fleet_calendar.html
--- a/templates/partials/fleet_calendar/reservations_list.html
+++ b/templates/partials/fleet_calendar/reservations_list.html
@@ -1,203 +1,100 @@
 <!-- Reservations List -->
 {% if reservations %}
-<div class="space-y-2">
+<div class="space-y-3">
    {% for item in reservations %}
    {% set res = item.reservation %}
-    {% set card_id = "res-card-" ~ res.id %}
-    {% set detail_id = "res-detail-" ~ res.id %}
-
-    <div class="rounded-lg border border-gray-200 dark:border-gray-700"
+    <div class="flex items-center justify-between p-4 rounded-lg border border-gray-200 dark:border-gray-700 hover:bg-gray-50 dark:hover:bg-gray-700/50 transition-colors"
         style="border-left: 4px solid {{ res.color }};">
-
-        <!-- Header row (always visible, clickable) -->
-        <div class="res-card-header flex items-center justify-between p-4 cursor-pointer hover:bg-gray-50 dark:hover:bg-gray-700/50 transition-colors select-none"
-             data-res-id="{{ res.id }}"
-             onclick="toggleResCard('{{ res.id }}')">
-
-            <div class="flex-1 min-w-0">
-                <div class="flex items-center gap-2 flex-wrap">
-                    <h3 class="font-semibold text-gray-900 dark:text-white">{{ res.name }}</h3>
-                    {% if res.device_type == 'slm' %}
-                    <span class="px-2 py-0.5 text-xs font-medium bg-purple-100 dark:bg-purple-900/30 text-purple-700 dark:text-purple-400 rounded">SLM</span>
-                    {% else %}
-                    <span class="px-2 py-0.5 text-xs font-medium bg-blue-100 dark:bg-blue-900/30 text-blue-700 dark:text-blue-400 rounded">Seismograph</span>
-                    {% endif %}
-                    {% if item.has_conflicts %}
-                    <span class="px-2 py-0.5 text-xs font-medium bg-amber-100 dark:bg-amber-900/30 text-amber-700 dark:text-amber-400 rounded"
-                          title="{{ item.conflict_count }} unit(s) will need a calibration swap during this job">
-                        {{ item.conflict_count }} cal swap{{ 's' if item.conflict_count != 1 else '' }}
-                    </span>
-                    {% endif %}
-                </div>
-                <p class="text-sm text-gray-500 dark:text-gray-400 mt-0.5">
-                    {{ res.start_date.strftime('%b %d, %Y') }} –
-                    {% if res.end_date %}
-                        {{ res.end_date.strftime('%b %d, %Y') }}
-                    {% elif res.end_date_tbd %}
-                        <span class="text-yellow-600 dark:text-yellow-400 font-medium">TBD</span>
-                        {% if res.estimated_end_date %}
-                        <span class="text-gray-400">(est. {{ res.estimated_end_date.strftime('%b %d, %Y') }})</span>
-                        {% endif %}
-                    {% else %}
-                        <span class="text-yellow-600 dark:text-yellow-400">Ongoing</span>
-                    {% endif %}
-                </p>
-            </div>
-
-            <!-- Counts -->
-            <div class="flex flex-col items-end gap-1 mx-4 flex-shrink-0">
-                {% set full = item.assigned_count == item.location_count and item.location_count > 0 %}
-                {% set remaining = item.location_count - item.assigned_count %}
-                <!-- Number row -->
-                <div class="flex items-baseline gap-2">
-                    <span class="text-xs text-gray-400 dark:text-gray-500">est. {% if res.estimated_units %}{{ res.estimated_units }}{% else %}—{% endif %}</span>
-                    <span class="text-gray-300 dark:text-gray-600">·</span>
-                    <span class="text-base font-bold {% if full %}text-green-600 dark:text-green-400{% elif item.assigned_count == 0 %}text-gray-400 dark:text-gray-500{% else %}text-amber-500 dark:text-amber-400{% endif %}">
-                        {{ item.assigned_count }}/{{ item.location_count }}
-                    </span>
-                    {% if remaining > 0 %}
-                    <span class="text-xs text-amber-500 dark:text-amber-400 whitespace-nowrap">({{ remaining }} more)</span>
-                    {% endif %}
-                </div>
-                <!-- Progress squares -->
-                {% if item.location_count > 0 %}
-                <div class="flex gap-0.5">
-                    {% for i in range(item.location_count) %}
-                    <span class="w-3 h-3 rounded-sm {% if i < item.assigned_count %}{% if full %}bg-green-500{% else %}bg-amber-500{% endif %}{% else %}bg-gray-300 dark:bg-gray-600{% endif %}"></span>
-                    {% endfor %}
-                </div>
-                {% endif %}
-            </div>
-
-            <!-- Action buttons -->
-            <div class="flex items-center gap-1 flex-shrink-0">
-                <!-- Assign units (always visible) -->
-                <button onclick="event.stopPropagation(); openPlanner('{{ res.id }}')"
-                        class="p-2 text-gray-400 hover:text-green-600 dark:hover:text-green-400 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700"
-                        title="Assign units">
-                    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2h2a2 2 0 012 2m-3 7h3m-3 4h3m-6-4h.01M9 16h.01"/>
-                    </svg>
-                </button>
-
-                <!-- "..." overflow menu -->
-                <div class="relative" onclick="event.stopPropagation()">
-                    <button onclick="toggleResMenu('{{ res.id }}')"
-                            class="p-2 text-gray-400 hover:text-gray-600 dark:hover:text-gray-300 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700"
-                            title="More options">
-                        <svg class="w-4 h-4" fill="currentColor" viewBox="0 0 24 24">
-                            <circle cx="5" cy="12" r="1.5"/><circle cx="12" cy="12" r="1.5"/><circle cx="19" cy="12" r="1.5"/>
-                        </svg>
-                    </button>
-                    <div id="res-menu-{{ res.id }}"
-                         class="hidden absolute right-0 top-8 z-20 w-44 bg-white dark:bg-slate-800 border border-gray-200 dark:border-gray-700 rounded-lg shadow-lg py-1">
-                        <button onclick="openPromoteModal('{{ res.id }}', '{{ res.name }}'); toggleResMenu('{{ res.id }}')"
-                                class="w-full text-left px-4 py-2 text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-slate-700 flex items-center gap-2">
-                            <svg class="w-4 h-4 text-emerald-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M5 10l7-7m0 0l7 7m-7-7v18"/>
-                            </svg>
-                            Promote to Project
-                        </button>
-                        <button onclick="editReservation('{{ res.id }}'); toggleResMenu('{{ res.id }}')"
-                                class="w-full text-left px-4 py-2 text-sm text-gray-700 dark:text-gray-300 hover:bg-gray-50 dark:hover:bg-slate-700 flex items-center gap-2">
-                            <svg class="w-4 h-4 text-blue-500" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"/>
-                            </svg>
-                            Edit
-                        </button>
-                        <div class="border-t border-gray-100 dark:border-gray-700 my-1"></div>
-                        <button onclick="deleteReservation('{{ res.id }}', '{{ res.name }}'); toggleResMenu('{{ res.id }}')"
-                                class="w-full text-left px-4 py-2 text-sm text-red-600 dark:text-red-400 hover:bg-red-50 dark:hover:bg-red-900/20 flex items-center gap-2">
-                            <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                                <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
-                            </svg>
-                            Delete
-                        </button>
-                    </div>
-                </div>
-
-                <!-- Chevron -->
-                <svg id="chevron-{{ res.id }}" class="w-4 h-4 text-gray-400 transition-transform duration-200 ml-1 pointer-events-none" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>
-                </svg>
-            </div>
-        </div>
-
-        <!-- Expandable detail panel -->
-        <div id="{{ detail_id }}" class="hidden border-t border-gray-100 dark:border-gray-700 bg-gray-50 dark:bg-slate-800/60 px-4 py-3">
-
-            {% if res.notes %}
-            <p class="text-sm text-gray-500 dark:text-gray-400 mb-3 italic">{{ res.notes }}</p>
-            {% endif %}
-
-            <div class="grid grid-cols-2 gap-x-6 gap-y-1 text-sm mb-3">
-                <div class="text-gray-500 dark:text-gray-400">Estimated</div>
-                <div class="font-medium {% if res.estimated_units %}text-gray-800 dark:text-gray-200{% else %}text-gray-400 dark:text-gray-500 italic{% endif %}">
-                    {% if res.estimated_units %}{{ res.estimated_units }} unit{{ 's' if res.estimated_units != 1 else '' }}{% else %}not specified{% endif %}
-                </div>
-                <div class="text-gray-500 dark:text-gray-400">Locations</div>
-                <div class="font-medium text-gray-800 dark:text-gray-200">{{ item.assigned_count }} of {{ item.location_count }} filled</div>
-                {% if item.assigned_count < item.location_count %}
-                <div class="text-gray-500 dark:text-gray-400">Still needed</div>
-                <div class="font-medium text-amber-600 dark:text-amber-400">{{ item.location_count - item.assigned_count }} location{{ 's' if (item.location_count - item.assigned_count) != 1 else '' }} remaining</div>
-                {% endif %}
+        <div class="flex-1">
+            <div class="flex items-center gap-2">
+                <h3 class="font-semibold text-gray-900 dark:text-white">{{ res.name }}</h3>
                {% if item.has_conflicts %}
-                <div class="text-gray-500 dark:text-gray-400">Cal swaps</div>
-                <div class="font-medium text-amber-600 dark:text-amber-400">{{ item.conflict_count }} unit{{ 's' if item.conflict_count != 1 else '' }} will need swapping during job</div>
+                <span class="px-2 py-0.5 text-xs font-medium bg-red-100 dark:bg-red-900/30 text-red-700 dark:text-red-400 rounded-full"
+                      title="{{ item.conflict_count }} unit(s) have calibration expiring during this job">
+                    {{ item.conflict_count }} conflict{{ 's' if item.conflict_count != 1 else '' }}
+                </span>
                {% endif %}
            </div>
-
-            {% if item.assigned_units %}
-            <p class="text-xs font-semibold uppercase tracking-wide text-gray-400 dark:text-gray-500 mb-2">Monitoring Locations</p>
-            <div class="flex flex-col gap-1">
-                {% for u in item.assigned_units %}
-                <div class="rounded bg-white dark:bg-slate-700 border border-gray-100 dark:border-gray-600 text-sm">
-                    <div class="flex items-center gap-3 px-3 py-1.5">
-                        <span class="text-gray-400 dark:text-gray-500 text-xs w-12 flex-shrink-0">Loc. {{ loop.index }}</span>
-                        <div class="flex flex-col min-w-0">
-                            {% if u.location_name %}
-                            <span class="text-xs font-semibold text-gray-700 dark:text-gray-300 truncate">{{ u.location_name }}</span>
-                            {% endif %}
-                            <button onclick="openUnitDetailModal('{{ u.id }}')"
-                                    class="font-medium text-blue-600 dark:text-blue-400 hover:underline text-left text-sm">{{ u.id }}</button>
-                        </div>
-                        <span class="flex-1"></span>
-                        {% if u.power_type == 'ac' %}
-                        <span class="text-xs px-1.5 py-0.5 bg-blue-50 dark:bg-blue-900/20 text-blue-600 dark:text-blue-400 rounded">A/C</span>
-                        {% elif u.power_type == 'solar' %}
-                        <span class="text-xs px-1.5 py-0.5 bg-yellow-50 dark:bg-yellow-900/20 text-yellow-600 dark:text-yellow-400 rounded">Solar</span>
-                        {% endif %}
-                        {% if u.deployed %}
-                        <span class="text-xs px-1.5 py-0.5 bg-green-50 dark:bg-green-900/20 text-green-600 dark:text-green-400 rounded">Deployed</span>
-                        {% else %}
-                        <span class="text-xs px-1.5 py-0.5 bg-gray-100 dark:bg-gray-600 text-gray-500 dark:text-gray-400 rounded">Benched</span>
-                        {% endif %}
-                        {% if u.last_calibrated %}
-                        <span class="text-xs text-gray-400 dark:text-gray-500">Cal: {{ u.last_calibrated.strftime('%b %d, %Y') }}</span>
-                        {% endif %}
-                    </div>
-                    {% if u.notes %}
-                    <p class="px-3 pb-1.5 text-xs text-gray-400 dark:text-gray-500 italic">{{ u.notes }}</p>
+            <p class="text-sm text-gray-500 dark:text-gray-400 mt-1">
+                {{ res.start_date.strftime('%b %d, %Y') }} -
+                {% if res.end_date %}
+                    {{ res.end_date.strftime('%b %d, %Y') }}
+                {% elif res.end_date_tbd %}
+                    <span class="text-yellow-600 dark:text-yellow-400 font-medium">TBD</span>
+                    {% if res.estimated_end_date %}
+                    <span class="text-gray-400">(est. {{ res.estimated_end_date.strftime('%b %d, %Y') }})</span>
                    {% endif %}
-                </div>
-                {% endfor %}
-            </div>
-            {% else %}
-            <p class="text-sm text-gray-400 dark:text-gray-500 italic">No units assigned yet. Click the clipboard icon to plan.</p>
+                {% else %}
+                    <span class="text-yellow-600 dark:text-yellow-400">Ongoing</span>
+                {% endif %}
+            </p>
+            {% if res.notes %}
+            <p class="text-sm text-gray-400 dark:text-gray-500 mt-1">{{ res.notes }}</p>
            {% endif %}
        </div>
-
+        <div class="text-right ml-4">
+            <p class="text-lg font-bold text-gray-900 dark:text-white">
+                {% if res.assignment_type == 'quantity' %}
+                {{ item.assigned_count }}/{{ res.quantity_needed or '?' }}
+                {% else %}
+                {{ item.assigned_count }}
+                {% endif %}
+            </p>
+            <p class="text-xs text-gray-500 dark:text-gray-400">
+                {{ 'units needed' if res.assignment_type == 'quantity' else 'units assigned' }}
+            </p>
+        </div>
+        <div class="ml-4 flex items-center gap-2">
+            <button onclick="editReservation('{{ res.id }}')"
+                    class="p-2 text-gray-400 hover:text-blue-600 dark:hover:text-blue-400 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700"
+                    title="Edit reservation">
+                <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M11 5H6a2 2 0 00-2 2v11a2 2 0 002 2h11a2 2 0 002-2v-5m-1.414-9.414a2 2 0 112.828 2.828L11.828 15H9v-2.828l8.586-8.586z"/>
+                </svg>
+            </button>
+            <button onclick="deleteReservation('{{ res.id }}', '{{ res.name }}')"
+                    class="p-2 text-gray-400 hover:text-red-600 dark:hover:text-red-400 rounded-lg hover:bg-gray-100 dark:hover:bg-gray-700"
+                    title="Delete reservation">
+                <svg class="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
+                </svg>
+            </button>
+        </div>
    </div>
    {% endfor %}
 </div>

-<!-- toggleResCard, deleteReservation, editReservation, openUnitDetailModal defined in fleet_calendar.html -->
+<script>
+async function deleteReservation(id, name) {
+    if (!confirm(`Delete reservation "${name}"?\n\nThis will remove all unit assignments.`)) {
+        return;
+    }
+
+    try {
+        const response = await fetch(`/api/fleet-calendar/reservations/${id}`, {
+            method: 'DELETE'
+        });
+
+        if (response.ok) {
+            window.location.reload();
+        } else {
+            const data = await response.json();
+            alert('Error: ' + (data.detail || 'Failed to delete'));
+        }
+    } catch (error) {
+        console.error('Error:', error);
+        alert('Error deleting reservation');
+    }
+}
+
+// editReservation is defined in fleet_calendar.html
+</script>
 {% else %}
 <div class="text-center py-8">
    <svg class="w-12 h-12 mx-auto text-gray-400 dark:text-gray-500 mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M8 7V3m8 4V3m-9 8h10M5 21h14a2 2 0 002-2V7a2 2 0 00-2-2H5a2 2 0 00-2 2v12a2 2 0 002 2z"/>
    </svg>
-    <p class="text-gray-500 dark:text-gray-400">No jobs yet</p>
-    <p class="text-sm text-gray-400 dark:text-gray-500 mt-1">Click "New Job" to start planning a deployment</p>
+    <p class="text-gray-500 dark:text-gray-400">No reservations for {{ year }}</p>
+    <p class="text-sm text-gray-400 dark:text-gray-500 mt-1">Click "New Reservation" to plan unit assignments</p>
 </div>
 {% endif %}
--- a/templates/partials/projects/project_dashboard.html
+++ b/templates/partials/projects/project_dashboard.html
@@ -11,9 +11,7 @@
                {% endif %}
            </p>
        </div>
-        {% if project.status == 'upcoming' %}
-            <span class="px-3 py-1 text-xs font-medium bg-purple-100 text-purple-800 dark:bg-purple-900/30 dark:text-purple-300 rounded-full">Upcoming</span>
-        {% elif project.status == 'active' %}
+        {% if project.status == 'active' %}
            <span class="px-3 py-1 text-xs font-medium bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-300 rounded-full">Active</span>
        {% elif project.status == 'on_hold' %}
            <span class="px-3 py-1 text-xs font-medium bg-amber-100 text-amber-800 dark:bg-amber-900/30 dark:text-amber-400 rounded-full">On Hold</span>
--- a/templates/partials/projects/project_header.html
+++ b/templates/partials/projects/project_header.html
@@ -3,26 +3,12 @@
        <div>
            <h1 class="text-3xl font-bold text-gray-900 dark:text-white mb-2">{{ project.name }}</h1>
            <div class="flex items-center gap-4">
-                <div class="relative inline-block">
-                    <select onchange="quickUpdateStatus(this.value)"
-                            class="appearance-none cursor-pointer inline-flex items-center pl-3 pr-7 py-1 rounded-full text-sm font-medium border-0 focus:ring-2 focus:ring-offset-1 focus:ring-blue-500
-                                   {% if project.status == 'upcoming' %}bg-purple-100 text-purple-800 dark:bg-purple-900 dark:text-purple-200
-                                   {% elif project.status == 'active' %}bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200
-                                   {% elif project.status == 'on_hold' %}bg-amber-100 text-amber-800 dark:bg-amber-900 dark:text-amber-200
-                                   {% elif project.status == 'completed' %}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 %}">
-                        <option value="upcoming" {% if project.status == 'upcoming' %}selected{% endif %}>Upcoming</option>
-                        <option value="active" {% if project.status == 'active' %}selected{% endif %}>Active</option>
-                        <option value="on_hold" {% if project.status == 'on_hold' %}selected{% endif %}>On Hold</option>
-                        <option value="completed" {% if project.status == 'completed' %}selected{% endif %}>Completed</option>
-                        <option value="archived" {% if project.status == 'archived' %}selected{% endif %}>Archived</option>
-                    </select>
-                    <span class="pointer-events-none absolute right-2 top-1/2 -translate-y-1/2 text-current opacity-60">
-                        <svg class="w-3 h-3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"/>
-                        </svg>
-                    </span>
-                </div>
+                <span class="inline-flex items-center px-3 py-1 rounded-full text-sm font-medium
+                             {% if project.status == 'active' %}bg-green-100 text-green-800 dark:bg-green-900 dark:text-green-200
+                             {% elif project.status == 'completed' %}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 %}">
+                    {{ project.status|title }}
+                </span>
                {% if project_type %}
                <span class="text-gray-500 dark:text-gray-400">{{ project_type.name }}</span>
                {% endif %}
--- a/templates/partials/projects/project_list_compact.html
+++ b/templates/partials/projects/project_list_compact.html
@@ -14,9 +14,7 @@
                {% endif %}
            </div>

-            {% if item.project.status == 'upcoming' %}
-                <span class="shrink-0 px-2 py-1 text-xs font-medium bg-purple-100 text-purple-800 dark:bg-purple-900/30 dark:text-purple-300 rounded-full">Upcoming</span>
-            {% elif item.project.status == 'active' %}
+            {% if item.project.status == 'active' %}
                <span class="shrink-0 px-2 py-1 text-xs font-medium bg-green-100 text-green-800 dark:bg-green-900/30 dark:text-green-300 rounded-full">Active</span>
            {% elif item.project.status == 'on_hold' %}
                <span class="shrink-0 px-2 py-1 text-xs font-medium bg-amber-100 text-amber-800 dark:bg-amber-900/30 dark:text-amber-400 rounded-full">On Hold</span>
--- a/templates/projects/detail.html
+++ b/templates/projects/detail.html
@@ -328,7 +328,6 @@
                        <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">Status</label>
                        <select name="status" id="settings-status"
                                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">
-                            <option value="upcoming">Upcoming</option>
                            <option value="active">Active</option>
                            <option value="on_hold">On Hold</option>
                            <option value="completed">Completed</option>
@@ -759,24 +758,6 @@ const projectId = "{{ project_id }}";
 let editingLocationId = null;
 let projectTypeId = null;

-async function quickUpdateStatus(newStatus) {
-    try {
-        const response = await fetch(`/api/projects/${projectId}`, {
-            method: 'PUT',
-            headers: {'Content-Type': 'application/json'},
-            body: JSON.stringify({ status: newStatus })
-        });
-        if (response.ok) {
-            // Reload the page to reflect new badge color and any side effects
-            window.location.reload();
-        } else {
-            alert('Failed to update status');
-        }
-    } catch (e) {
-        alert('Error updating status');
-    }
-}
-
 // Tab switching
 function switchTab(tabName) {
    // Hide all tab panels
--- a/templates/projects/overview.html
+++ b/templates/projects/overview.html
@@ -36,17 +36,12 @@
        <nav class="flex space-x-8 px-6" aria-label="Tabs">
            <button onclick="switchTab('all')"
                    id="tab-all"
-                    class="tab-button border-b-2 border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300 px-1 py-4 text-sm font-medium">
+                    class="tab-button border-b-2 border-seismo-orange text-seismo-orange px-1 py-4 text-sm font-medium">
                All Projects
            </button>
-            <button onclick="switchTab('upcoming')"
-                    id="tab-upcoming"
-                    class="tab-button border-b-2 border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300 px-1 py-4 text-sm font-medium">
-                Upcoming
-            </button>
            <button onclick="switchTab('active')"
                    id="tab-active"
-                    class="tab-button border-b-2 border-seismo-orange text-seismo-orange px-1 py-4 text-sm font-medium">
+                    class="tab-button border-b-2 border-transparent text-gray-500 hover:text-gray-700 hover:border-gray-300 px-1 py-4 text-sm font-medium">
                Active
            </button>
            <button onclick="switchTab('on_hold')"
@@ -71,7 +66,7 @@
 <!-- Projects List -->
 <div id="projects-list"
     class="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6"
-     hx-get="/api/projects/list?status=active"
+     hx-get="/api/projects/list"
     hx-trigger="load"
     hx-swap="innerHTML">
    <!-- Loading skeletons -->