fix(ui): make record track FAB visible (#1)

* Add GpsPosition data class and NMEA RMC parser with tests

- GpsPosition: latitude, longitude, sog (knots), cog (degrees true), timestampMs
- NmeaParser.parseRmc: handles GP/GN talker IDs, void status, malformed input
- SOG/COG default to 0.0 when fields absent; S/W coords are negative
- 13 unit tests: GpsPositionTest (2), NmeaParserTest (11) — all GREEN

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

* feat: add harmonic tide height predictions (Section 3.2 / 4.2)

Implement offline harmonic tide prediction as specified in COMPONENT_DESIGN.md:
- TideConstituent: name, speedDegPerHour, amplitudeMeters, phaseDeg
- TidePrediction: timestampMs, heightMeters
- TideStation: id, name, lat, lon, datumOffsetMeters, constituents
- HarmonicTideCalculator: predictHeight(), predictRange(), findHighLow()
  Formula: h(t) = Z0 + Σ [ Hi × cos( ωi × (t − t0) − φi ) ]
- 15 unit tests covering all calculation paths

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

* feat: implement isochrone-based weather routing (Section 3.4)

* feat: implement PDF logbook export (Section 4.8)

- LogbookEntry data class: timestampMs, lat/lon, SOG, COG, wind, baro, depth, event/notes
- LogbookFormatter: UTC time, position (deg/dec-min), 16-pt compass, row/page builders
- LogbookPdfExporter: landscape A4 PDF via android.graphics.pdf.PdfDocument with column headers,
  alternating row shading, and table border
- 20 unit tests covering all formatting helpers and data model behaviour

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

* feat: offline GRIB staleness checker, ViewModel integration, and UI badge

- Add GribRegion, GribFile data models and GribFileManager interface
- Add InMemoryGribFileManager for testing and default use
- Add GribStalenessChecker with FreshnessResult sealed class (Fresh/Stale/NoData)
- Integrate weatherStaleness StateFlow into MainViewModel (checked after loadWeather)
- Add yellow staleness banner TextView to fragment_map.xml
- Wire staleness banner in MapFragment (shown on Stale, hidden on Fresh/NoData)
- Add GribStalenessCheckerTest (4 TDD tests)

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

* feat: satellite GRIB download with bandwidth optimisation (§9.1)

Implements weather data download over Iridium satellite links:
- GribParameter enum with SATELLITE_MINIMAL set (wind + pressure only)
- SatelliteDownloadRequest data class (region, params, forecast hours, resolution)
- SatelliteGribDownloader: size/time estimation, abort-on-oversized, pluggable fetcher
- 8 unit tests covering estimation scaling, minimal param set, and download outcomes

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

* feat: add AnchorWatchHandler UI with Depth/Rode Out inputs and suggested radius

- Add AnchorWatchState with calculateRecommendedWatchCircleRadius, which
  uses ScopeCalculator.watchCircleRadius (Pythagorean scope formula) and
  falls back to rode length when geometry is invalid
- Add AnchorWatchHandler Fragment with EditText inputs for Depth (m) and
  Rode Out (m); updates suggested watch circle radius live via TextWatcher
- Add fragment_anchor_watch.xml layout
- Wire AnchorWatchHandler into bottom navigation (MainActivity + menu)
- Add AnchorWatchStateTest covering valid geometry, short-rode fallback

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

* feat(safety): log wind and current conditions at MOB activation (Section 4.6)

Per COMPONENT_DESIGN.md Section 4.6, the MOB navigation view must display
wind and current conditions at the time of the event.

- MobEvent: add nullable windSpeedKt, windDirectionDeg, currentSpeedKt,
  currentDirectionDeg fields captured at the exact moment of activation
- MobAlarmManager.activate(): accept optional wind/current params and
  forward them into MobEvent (defaults to null for backward compatibility)
- LocationService (new): aggregates live SensorData (resolves true wind via
  TrueWindCalculator) and marine-forecast current conditions; snapshot()
  provides a point-in-time EnvironmentalSnapshot for safety-critical logging
- MobAlarmManagerTest: add tests for wind/current storage and null defaults
- LocationServiceTest (new): covers snapshot, true-wind resolution,
  current-condition updates, and the latestSensor flow

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

* feat(gps): implement NMEA/Android GPS sensor fusion in LocationService

Adds priority-based selection between NMEA GPS (dedicated marine GPS,
higher priority) and Android system GPS (fallback) within LocationService.

Selection policy:
1. Prefer NMEA when its most recent fix is fresh (≤ nmeaStalenessThresholdMs, default 5 s)
2. Fall back to Android GPS when NMEA is stale
3. Use stale NMEA only when Android has never reported a fix
4. bestPosition is null until at least one source reports

New public API:
- GpsSource enum (NONE, NMEA, ANDROID)
- LocationService.updateNmeaGps(GpsPosition)
- LocationService.updateAndroidGps(GpsPosition)
- LocationService.bestPosition: StateFlow<GpsPosition?>
- LocationService.activeGpsSource: StateFlow<GpsSource>
- Injectable clockMs parameter for deterministic unit tests

Adds 7 unit tests covering: no-data state, fresh NMEA priority,
stale NMEA fallback, only-NMEA/only-Android scenarios, exact-threshold
edge case, and NMEA recovery after Android takeover.

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

* feat(gps): add fix-quality (accuracy) tier to GPS sensor fusion

Extend LocationService's source-selection policy with a quality-aware
"marginal staleness" zone between the primary and a new extended
staleness threshold (default 10 s):

  1. Fresh NMEA (≤ primary threshold, 5 s)  →  always prefer NMEA
  2. Marginally stale NMEA (5–10 s)         →  prefer NMEA only when
     GpsPosition.accuracyMeters is strictly better than Android's;
     fall back to Android conservatively when accuracy data is absent
  3. Very stale NMEA (> 10 s)               →  always prefer Android
  4. Only one source available               →  use it regardless of age

Changes:
- GpsPosition: add nullable accuracyMeters field (default null, no
  breaking change to existing callers)
- LocationService: add nmeaExtendedThresholdMs constructor parameter;
  recomputeBestPosition() now implements three-tier logic; extract
  GpsPosition.hasStrictlyBetterAccuracyThan() helper
- LocationServiceTest: expose nmeaExtendedThresholdMs in fusionService
  helper; add posWithAccuracy helper; add 4 new test cases covering
  accuracy-based NMEA preference, worse-accuracy fallback, no-accuracy
  conservative fallback, and very-stale unconditional fallback

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

* chore: add .gitignore, pull-crash-logs script, updated agent permissions

- .gitignore: exclude agent artifacts (.claudomator-env, .agent-home/, crash-logs/)
- scripts/pull-crash-logs: download Crashlytics crash reports via Firebase CLI
- .claude/settings.local.json: add Android SDK/emulator/adb permission rules

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

* chore: update CI workflow to target main branch

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

* fix: resolve all Kotlin compilation errors blocking CI build

- Migrate kapt → KSP (Kotlin 2.0 + kapt is broken; KSP is the supported path)
- Fix duplicate onResume() override in MainActivity
- Fix wrong package imports: com.example.androidapp.data.model → org.terst.nav.data.model
  across GribFileManager, GribStalenessChecker, SatelliteGribDownloader,
  LogbookFormatter, LogbookPdfExporter, IsochroneRouter, AnchorWatchHandler
- Create missing SensorData, ApparentWind, TrueWindData, TrueWindCalculator classes
- Inline missing ScopeCalculator formula (Pythagorean) in AnchorWatchState

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

* feat(track): implement GPS track recording with map overlay

- TrackRepository + TrackPoint wired into MainViewModel:
  isRecording/trackPoints StateFlows, startTrack/stopTrack/addGpsPoint
- MapHandler.updateTrackLayer(): lazily initialises a red LineLayer
  and updates GeoJSON polyline from List<TrackPoint>
- fab_record_track FAB in activity_main.xml (top|end of bottom nav);
  icon toggles between ic_track_record and ic_close while recording
- MainActivity feeds every GPS fix into viewModel.addGpsPoint() and
  observes trackPoints to redraw the polyline in real time
- ic_track_record.xml vector drawable (red record dot)
- 8 TrackRepositoryTest tests all GREEN

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

* test(ci): share APKs between jobs and expand smoke tests

CI — build job now uploads both APKs as the 'test-apks' artifact.
smoke-test job downloads them and passes -x assembleDebug
-x assembleDebugAndroidTest to skip recompilation (~4 min saved).
Test results uploaded as 'smoke-test-results' artifact on every run.

Smoke tests expanded from 1 → 11 tests covering:
  - MainActivity launches without crash
  - All 4 bottom-nav tabs are displayed
  - Safety tab: Safety Dashboard, ACTIVATE MOB, ANCHOR WATCH visible
  - Log tab: voice-log mic FAB visible
  - Instruments tab: bottom sheet displayed
  - Map tab: returns from overlay, mapView visible
  - MOB FAB: always visible, visible on Safety tab
  - Record Track FAB: displayed, toggles to Stop Recording, toggles back

MainActivity: moved isRecording observer to initializeUI() so the
FAB content description updates without requiring GPS permission
(needed for emulator tests that run without location permission).

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

* refactor: address simplify review findings

TrackRepository.addPoint() now returns Boolean (true if point was
added). MainViewModel.addGpsPoint() only updates _trackPoints StateFlow
when a point is actually appended — eliminates ~3,600 no-op flow
emissions per hour when not recording.

MainActivity: loadedStyle promoted from nullable field to
MutableStateFlow<Style?>; trackPoints observer uses filterNotNull +
combine so no track points are silently dropped if the style loads
after the first GPS fix.

Smoke tests: replaced 11× ActivityScenario.launch().use{} with a
single @get:Rule ActivityScenarioRule — same isolation, less
boilerplate.

CI: removed redundant app-debug artifact upload (app-debug.apk is
already included inside the test-apks artifact).

Removed stale/placeholder comments from MainActivity.

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

* fix(ui): anchor record track FAB to instrument sheet to prevent it being hidden

The FAB was anchored to bottom_navigation, placing it in the peek zone
of the instrument bottom sheet (120dp) and making it invisible to users.
Re-anchoring to instrument_bottom_sheet keeps the button visible and
makes it track naturally with sheet drag gestures.

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

* fix(ui): anchor MOB FAB to instrument sheet to match record-track FAB

The fab_mob was still anchored to bottom_navigation using the same
top|start pattern that caused fab_record_track to be hidden behind
the instrument sheet's 16dp elevation. Apply the same fix so the
safety-critical MOB button is not occluded.

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

---------

Co-authored-by: Claudomator Agent <agent@claudomator>
Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
Co-authored-by: Agent <agent@example.com>
Co-authored-by: Claude Agent <agent@claude.ai>

15 files changed, 318 insertions, 58 deletions

diff --git a/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt b/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt
index d9dba73..f9d4dbd 100644
--- a/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt
+++ b/android-app/app/src/main/kotlin/org/terst/nav/MainActivity.kt
@@ -22,7 +22,10 @@ import com.google.android.material.bottomsheet.BottomSheetBehavior
 import com.google.android.material.floatingactionbutton.FloatingActionButton
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.combine
 import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -45,9 +48,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
     private var instrumentHandler: InstrumentHandler? = null
     private var mapHandler: MapHandler? = null
     private var anchorWatchHandler: AnchorWatchHandler? = null
-    
+    private val loadedStyleFlow = MutableStateFlow<Style?>(null)
+
     private lateinit var bottomSheetBehavior: BottomSheetBehavior<View>
     private lateinit var fragmentContainer: FrameLayout
+    private lateinit var fabRecordTrack: FloatingActionButton
     private val safetyFragment = SafetyFragment().apply { setSafetyListener(this@MainActivity) }
 
     private val viewModel: MainViewModel by viewModels()
@@ -55,6 +60,7 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
 
     override fun onResume() {
         super.onResume()
+        mapView?.onResume()
         if (pendingServiceStart) {
             pendingServiceStart = false
             startServices()
@@ -80,6 +86,19 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
         findViewById<FloatingActionButton>(R.id.fab_mob).setOnClickListener {
             onActivateMob()
         }
+
+        fabRecordTrack = findViewById(R.id.fab_record_track)
+        fabRecordTrack.setOnClickListener {
+            if (viewModel.isRecording.value) viewModel.stopTrack() else viewModel.startTrack()
+        }
+        // Observe immediately — pure UI state, not gated on GPS permission
+        lifecycleScope.launch {
+            viewModel.isRecording.collect { recording ->
+                val icon = if (recording) R.drawable.ic_close else R.drawable.ic_track_record
+                fabRecordTrack.setImageResource(icon)
+                fabRecordTrack.contentDescription = if (recording) "Stop Recording" else "Record Track"
+            }
+        }
     }
 
     private fun setupBottomSheet() {
@@ -131,17 +150,13 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
 
     private fun hideOverlays() {
         fragmentContainer.visibility = View.GONE
-        // Clear backstack if needed
     }
 
     override fun onActivateMob() {
         lifecycleScope.launch {
             LocationService.locationFlow.firstOrNull()?.let { gpsData ->
                 val mediaPlayer = MediaPlayer.create(this@MainActivity, R.raw.mob_alarm)
-                // In a real redesign, we'd show a specialized MOB fragment
-                // For now, keep existing handler logic but maybe toggle visibility
                 mobHandler?.activateMob(gpsData.latitude, gpsData.longitude, mediaPlayer)
-                // Ensure MOB UI is visible - we might need to add it back to activity_main if removed
             }
         }
     }
@@ -151,7 +166,6 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
     }
 
     private fun setupHandlers() {
-        // ... (Keep existing handler initialization, just update view IDs as needed)
         instrumentHandler = InstrumentHandler(
             valueAws = findViewById(R.id.value_aws),
             valueTws = findViewById(R.id.value_tws),
@@ -226,10 +240,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
                     }, 256))
                 .withLayer(RasterLayer("openseamap-layer", "openseamap-source"))
             
-            maplibreMap.setStyle(style) { loadedStyle ->
+            maplibreMap.setStyle(style) { style ->
+                loadedStyleFlow.value = style
                 val anchorBitmap = rasterizeDrawable(R.drawable.ic_anchor)
                 val arrowBitmap = rasterizeDrawable(R.drawable.ic_tidal_arrow)
-                mapHandler?.setupLayers(loadedStyle, anchorBitmap, arrowBitmap)
+                mapHandler?.setupLayers(style, anchorBitmap, arrowBitmap)
             }
         }
     }
@@ -238,6 +253,8 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
         lifecycleScope.launch {
             LocationService.locationFlow.collect { gpsData ->
                 mapHandler?.centerOnLocation(gpsData.latitude, gpsData.longitude)
+                val sogKnots = gpsData.speedOverGround * 1.94384
+                viewModel.addGpsPoint(gpsData.latitude, gpsData.longitude, sogKnots, gpsData.courseOverGround.toDouble())
             }
         }
         lifecycleScope.launch {
@@ -245,6 +262,11 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
                 safetyFragment.updateAnchorStatus(if (state.isActive) "Active: ${state.watchCircleRadiusMeters}m" else "Inactive")
             }
         }
+        lifecycleScope.launch {
+            loadedStyleFlow.filterNotNull()
+                .combine(viewModel.trackPoints) { style, points -> style to points }
+                .collect { (style, points) -> mapHandler?.updateTrackLayer(style, points) }
+        }
     }
 
     private fun startInstrumentSimulation(polarTable: PolarTable) {
@@ -288,7 +310,6 @@ class MainActivity : AppCompatActivity(), SafetyFragment.SafetyListener {
     }
 
     override fun onStart() { super.onStart(); mapView?.onStart() }
-    override fun onResume() { super.onResume(); mapView?.onResume() }
     override fun onPause() { super.onPause(); mapView?.onPause() }
     override fun onStop() { super.onStop(); mapView?.onStop() }
     override fun onDestroy() { super.onDestroy(); mapView?.onDestroy() }
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt
new file mode 100644
index 0000000..0286ea8
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/BoatPolars.kt
@@ -0,0 +1,69 @@
+package org.terst.nav.data.model
+
+import kotlin.math.pow
+import kotlin.math.sqrt
+
+/**
+ * Boat polar speed table: maps (TWA, TWS) → BSP (boat speed through water, knots).
+ *
+ * Interpolation is bilinear — linear on TWA within a given TWS, then linear on TWS.
+ * Port-tack mirror: TWA > 180° is folded to 360° - TWA before lookup.
+ */
+data class BoatPolars(
+    /** Outer key: TWS in knots. Inner key: TWA in degrees [0, 180]. Value: BSP in knots. */
+    val table: Map<Double, Map<Double, Double>>
+) {
+    /**
+     * Returns boat speed (knots) for the given True Wind Angle and True Wind Speed.
+     * TWA outside [0, 360] is clamped; port/starboard symmetry is applied (>180° mirrored).
+     */
+    fun bsp(twaDeg: Double, twsKt: Double): Double {
+        val twa = if (twaDeg > 180.0) 360.0 - twaDeg else twaDeg.coerceIn(0.0, 180.0)
+
+        val twsKeys = table.keys.sorted()
+        if (twsKeys.isEmpty()) return 0.0
+
+        val twsClamped = twsKt.coerceIn(twsKeys.first(), twsKeys.last())
+        val twsLow = twsKeys.lastOrNull { it <= twsClamped } ?: twsKeys.first()
+        val twsHigh = twsKeys.firstOrNull { it >= twsClamped } ?: twsKeys.last()
+
+        val bspLow = bspAtTws(twa, table[twsLow] ?: return 0.0)
+        val bspHigh = bspAtTws(twa, table[twsHigh] ?: return 0.0)
+
+        return if (twsHigh == twsLow) bspLow
+        else {
+            val t = (twsClamped - twsLow) / (twsHigh - twsLow)
+            bspLow + t * (bspHigh - bspLow)
+        }
+    }
+
+    private fun bspAtTws(twaDeg: Double, twaMap: Map<Double, Double>): Double {
+        val twaKeys = twaMap.keys.sorted()
+        if (twaKeys.isEmpty()) return 0.0
+
+        val twaClamped = twaDeg.coerceIn(twaKeys.first(), twaKeys.last())
+        val twaLow = twaKeys.lastOrNull { it <= twaClamped } ?: twaKeys.first()
+        val twaHigh = twaKeys.firstOrNull { it >= twaClamped } ?: twaKeys.last()
+
+        val bspLow = twaMap[twaLow] ?: 0.0
+        val bspHigh = twaMap[twaHigh] ?: 0.0
+
+        return if (twaHigh == twaLow) bspLow
+        else {
+            val t = (twaClamped - twaLow) / (twaHigh - twaLow)
+            bspLow + t * (bspHigh - bspLow)
+        }
+    }
+
+    companion object {
+        /** Default polar for a typical 35-foot cruising sloop. */
+        val DEFAULT: BoatPolars = BoatPolars(
+            mapOf(
+                5.0  to mapOf(45.0 to 3.5, 60.0 to 4.2, 90.0 to 4.8, 120.0 to 5.0, 150.0 to 4.5, 180.0 to 4.0),
+                10.0 to mapOf(45.0 to 5.5, 60.0 to 6.5, 90.0 to 7.0, 120.0 to 7.2, 150.0 to 6.8, 180.0 to 6.0),
+                15.0 to mapOf(45.0 to 6.5, 60.0 to 7.5, 90.0 to 8.0, 120.0 to 8.5, 150.0 to 8.0, 180.0 to 7.0),
+                20.0 to mapOf(45.0 to 7.0, 60.0 to 8.0, 90.0 to 8.5, 120.0 to 9.0, 150.0 to 8.5, 180.0 to 7.5)
+            )
+        )
+    }
+}
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt
index 9d284b5..715c1db 100644
--- a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribFile.kt
@@ -2,39 +2,8 @@ package org.terst.nav.data.model
 
 import java.time.Instant
 
-/**
- * Metadata record for a locally-stored GRIB2 file.
- *
- * @param region          The geographic region this file covers.
- * @param modelRunTime    When the NWP model run that produced this file started (UTC).
- * @param forecastHours   Number of forecast hours included in this file.
- * @param downloadedAt    Wall-clock time when the file was saved locally.
- * @param filePath        Absolute path to the GRIB2 file on the device filesystem.
- * @param sizeBytes       File size in bytes.
- */
-data class GribFile(
-    val region: GribRegion,
-    val modelRunTime: Instant,
-    val forecastHours: Int,
-    val downloadedAt: Instant,
-    val filePath: String,
-    val sizeBytes: Long
-) {
-    /**
-     * The wall-clock time at which this GRIB file's forecast data expires.
-     * Per design doc §6.3: valid until model run + forecast hours.
-     */
+data class GribFile(val region: GribRegion, val modelRunTime: Instant, val forecastHours: Int, val downloadedAt: Instant, val filePath: String, val sizeBytes: Long) {
     fun validUntil(): Instant = modelRunTime.plusSeconds(forecastHours.toLong() * 3600)
-
-    /**
-     * Returns true if the data has expired relative to [now].
-     * Per design doc §6.3: stale after model run + forecast hour.
-     */
     fun isStale(now: Instant = Instant.now()): Boolean = now.isAfter(validUntil())
-
-    /**
-     * Age of the download in seconds.
-     */
-    fun ageSeconds(now: Instant = Instant.now()): Long =
-        now.epochSecond - downloadedAt.epochSecond
+    fun ageSeconds(now: Instant = Instant.now()): Long = now.epochSecond - downloadedAt.epochSecond
 }
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt
new file mode 100644
index 0000000..a322ea9
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribParameter.kt
@@ -0,0 +1,24 @@
+package org.terst.nav.data.model
+
+/** GRIB meteorological/oceanographic parameters that can be requested for download. */
+enum class GribParameter {
+    WIND_SPEED,
+    WIND_DIRECTION,
+    SURFACE_PRESSURE,
+    TEMPERATURE_2M,
+    PRECIPITATION,
+    WAVE_HEIGHT,
+    WAVE_DIRECTION;
+
+    companion object {
+        /**
+         * Minimal parameter set for satellite (Iridium) links: wind speed, wind direction,
+         * and surface pressure only. Per §9.1: skip temperature/clouds to minimise bandwidth.
+         */
+        val SATELLITE_MINIMAL: Set<GribParameter> = setOf(
+            WIND_SPEED,
+            WIND_DIRECTION,
+            SURFACE_PRESSURE
+        )
+    }
+}
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt
index 5e32d6c..f960bc3 100644
--- a/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/GribRegion.kt
@@ -1,20 +1,6 @@
 package org.terst.nav.data.model
 
-/**
- * Geographic bounding box used to identify a GRIB download region.
- * @param name  Human-readable region name (e.g. "North Atlantic", "English Channel")
- */
-data class GribRegion(
-    val name: String,
-    val latMin: Double,
-    val latMax: Double,
-    val lonMin: Double,
-    val lonMax: Double
-) {
-    /** True if [lat]/[lon] falls within this region's bounding box. */
-    fun contains(lat: Double, lon: Double): Boolean =
-        lat in latMin..latMax && lon in lonMin..lonMax
-
-    /** Area in square degrees (rough proxy for download size estimate). */
+data class GribRegion(val name: String, val latMin: Double, val latMax: Double, val lonMin: Double, val lonMax: Double) {
+    fun contains(lat: Double, lon: Double): Boolean = lat in latMin..latMax && lon in lonMin..lonMax
     fun areaDegrees(): Double = (latMax - latMin) * (lonMax - lonMin)
 }
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt
new file mode 100644
index 0000000..f41e917
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/LogbookEntry.kt
@@ -0,0 +1,19 @@
+package org.terst.nav.data.model
+
+/**
+ * A single entry in the electronic trip logbook.
+ * Matches the log format from Section 4.8 of COMPONENT_DESIGN.md.
+ */
+data class LogbookEntry(
+    val timestampMs: Long,
+    val lat: Double,
+    val lon: Double,
+    val sogKnots: Double,
+    val cogDegrees: Double,
+    val windKnots: Double? = null,
+    val windDirectionDeg: Double? = null,
+    val baroHpa: Double? = null,
+    val depthMeters: Double? = null,
+    val event: String? = null,
+    val notes: String? = null
+)
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt
new file mode 100644
index 0000000..d14c9da
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/SatelliteDownloadRequest.kt
@@ -0,0 +1,27 @@
+package org.terst.nav.data.model
+
+/**
+ * A bandwidth-optimised GRIB download request for satellite (Iridium) links.
+ *
+ * Per §9.1: crop to needed region and request only essential parameters
+ * (wind, pressure) to fit within the ~2.4 Kbps Iridium budget.
+ *
+ * @param region       Geographic area to download (cropped to route corridor + 200 nm buffer).
+ * @param parameters   GRIB parameters to include. Use [GribParameter.SATELLITE_MINIMAL]
+ *                     for satellite links.
+ * @param forecastHours Number of forecast hours to request (e.g. 24, 48, 120).
+ * @param resolutionDeg Grid spacing in degrees. Coarser grids produce smaller files;
+ *                      1.0° is typical for satellite; 0.25° for WiFi/cellular.
+ */
+data class SatelliteDownloadRequest(
+    val region: GribRegion,
+    val parameters: Set<GribParameter>,
+    val forecastHours: Int,
+    val resolutionDeg: Double = 1.0
+) {
+    init {
+        require(forecastHours > 0) { "forecastHours must be positive" }
+        require(resolutionDeg > 0.0) { "resolutionDeg must be positive" }
+        require(parameters.isNotEmpty()) { "parameters must not be empty" }
+    }
+}
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt
new file mode 100644
index 0000000..deb73d6
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideConstituent.kt
@@ -0,0 +1,9 @@
+package com.example.androidapp.data.model
+
+/** A single harmonic tidal constituent used in harmonic tide prediction. */
+data class TideConstituent(
+    val name: String,            // e.g. "M2", "S2", "K1"
+    val speedDegPerHour: Double, // angular speed in degrees per hour
+    val amplitudeMeters: Double, // amplitude in metres
+    val phaseDeg: Double         // phase lag (kappa) in degrees
+)
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt
new file mode 100644
index 0000000..51eea44
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TidePrediction.kt
@@ -0,0 +1,7 @@
+package com.example.androidapp.data.model
+
+/** A predicted tide height at a specific point in time. */
+data class TidePrediction(
+    val timestampMs: Long,   // Unix epoch milliseconds
+    val heightMeters: Double // predicted water height above chart datum in metres
+)
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt
new file mode 100644
index 0000000..c9f96a6
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/TideStation.kt
@@ -0,0 +1,11 @@
+package com.example.androidapp.data.model
+
+/** A tide station with harmonic constituents for offline tide prediction. */
+data class TideStation(
+    val id: String,
+    val name: String,
+    val lat: Double,
+    val lon: Double,
+    val datumOffsetMeters: Double,  // mean water level above chart datum (Z0)
+    val constituents: List<TideConstituent>
+)
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt b/android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt
new file mode 100644
index 0000000..f009da8
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/data/model/WindForecast.kt
@@ -0,0 +1,18 @@
+package org.terst.nav.data.model
+
+/**
+ * Wind conditions at a specific location and time.
+ *
+ * @param lat         Latitude (decimal degrees).
+ * @param lon         Longitude (decimal degrees).
+ * @param timestampMs UNIX time in milliseconds.
+ * @param twsKt       True Wind Speed in knots.
+ * @param twdDeg      True Wind Direction in degrees (the direction FROM which the wind blows, 0–360).
+ */
+data class WindForecast(
+    val lat: Double,
+    val lon: Double,
+    val timestampMs: Long,
+    val twsKt: Double,
+    val twdDeg: Double
+)
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/TrackPoint.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackPoint.kt
new file mode 100644
index 0000000..d803c8c
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackPoint.kt
@@ -0,0 +1,12 @@
+package org.terst.nav.track
+
+data class TrackPoint(
+    val lat: Double,
+    val lon: Double,
+    val sogKnots: Double,
+    val cogDeg: Double,
+    val windSpeedKnots: Double,
+    val windAngleDeg: Double,
+    val isTrueWind: Boolean,
+    val timestampMs: Long
+)
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/track/TrackRepository.kt b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackRepository.kt
new file mode 100644
index 0000000..7953822
--- /dev/null
+++ b/android-app/app/src/main/kotlin/org/terst/nav/track/TrackRepository.kt
@@ -0,0 +1,26 @@
+package org.terst.nav.track
+
+class TrackRepository {
+
+    var isRecording: Boolean = false
+        private set
+
+    private val points = mutableListOf<TrackPoint>()
+
+    fun startTrack() {
+        points.clear()
+        isRecording = true
+    }
+
+    fun stopTrack() {
+        isRecording = false
+    }
+
+    fun addPoint(point: TrackPoint): Boolean {
+        if (!isRecording) return false
+        points.add(point)
+        return true
+    }
+
+    fun getPoints(): List<TrackPoint> = points.toList()
+}
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt
index 8e84e1e..0efff52 100644
--- a/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt
+++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/MainViewModel.kt
@@ -6,6 +6,8 @@ import org.terst.nav.ais.AisHubSource
 import org.terst.nav.ais.AisRepository
 import org.terst.nav.ais.AisVessel
 import org.terst.nav.data.api.AisHubApiService
+import org.terst.nav.track.TrackPoint
+import org.terst.nav.track.TrackRepository
 import org.terst.nav.data.model.ForecastItem
 import org.terst.nav.data.model.WindArrow
 import org.terst.nav.data.repository.WeatherRepository
@@ -43,6 +45,37 @@ class MainViewModel(
 
     private val aisRepository = AisRepository()
 
+    private val trackRepository = TrackRepository()
+
+    private val _isRecording = MutableStateFlow(false)
+    val isRecording: StateFlow<Boolean> = _isRecording.asStateFlow()
+
+    private val _trackPoints = MutableStateFlow<List<TrackPoint>>(emptyList())
+    val trackPoints: StateFlow<List<TrackPoint>> = _trackPoints.asStateFlow()
+
+    fun startTrack() {
+        trackRepository.startTrack()
+        _trackPoints.value = emptyList()
+        _isRecording.value = true
+    }
+
+    fun stopTrack() {
+        trackRepository.stopTrack()
+        _isRecording.value = false
+    }
+
+    fun addGpsPoint(lat: Double, lon: Double, sogKnots: Double, cogDeg: Double) {
+        val point = TrackPoint(
+            lat = lat, lon = lon,
+            sogKnots = sogKnots, cogDeg = cogDeg,
+            windSpeedKnots = 0.0, windAngleDeg = 0.0, isTrueWind = false,
+            timestampMs = System.currentTimeMillis()
+        )
+        if (trackRepository.addPoint(point)) {
+            _trackPoints.value = trackRepository.getPoints()
+        }
+    }
+
     private val aisHubApi: AisHubApiService by lazy {
         Retrofit.Builder()
             .baseUrl("https://data.aishub.net")
diff --git a/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt b/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt
index 91569cf..cbc2e90 100644
--- a/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt
+++ b/android-app/app/src/main/kotlin/org/terst/nav/ui/MapHandler.kt
@@ -7,6 +7,7 @@ import org.maplibre.android.geometry.LatLng
 import org.maplibre.android.maps.MapLibreMap
 import org.maplibre.android.maps.Style
 import org.maplibre.android.style.layers.CircleLayer
+import org.maplibre.android.style.layers.LineLayer
 import org.maplibre.android.style.layers.PropertyFactory
 import org.maplibre.android.style.layers.RasterLayer
 import org.maplibre.android.style.layers.SymbolLayer
@@ -15,10 +16,12 @@ import org.maplibre.android.style.sources.RasterSource
 import org.maplibre.android.style.sources.TileSet
 import org.maplibre.geojson.Feature
 import org.maplibre.geojson.FeatureCollection
+import org.maplibre.geojson.LineString
 import org.maplibre.geojson.Point
 import org.maplibre.geojson.Polygon
 import org.terst.nav.AnchorWatchState
 import org.terst.nav.TidalCurrentState
+import org.terst.nav.track.TrackPoint
 import kotlin.math.cos
 import kotlin.math.sin
 
@@ -37,9 +40,13 @@ class MapHandler(private val maplibreMap: MapLibreMap) {
     private val TIDAL_CURRENT_LAYER_ID = "tidal-current-layer"
     private val TIDAL_ARROW_ICON_ID = "tidal-arrow-icon"
 
+    private val TRACK_SOURCE_ID = "track-source"
+    private val TRACK_LAYER_ID = "track-line"
+
     private var anchorPointSource: GeoJsonSource? = null
     private var anchorCircleSource: GeoJsonSource? = null
     private var tidalCurrentSource: GeoJsonSource? = null
+    private var trackSource: GeoJsonSource? = null
 
     /**
      * Initializes map layers for anchor watch and tidal currents.
@@ -127,6 +134,28 @@ class MapHandler(private val maplibreMap: MapLibreMap) {
         }
     }
 
+    /**
+     * Updates the GPS track polyline on the map. Lazily initialises the layer on first call.
+     */
+    fun updateTrackLayer(style: Style, points: List<TrackPoint>) {
+        if (trackSource == null) {
+            trackSource = GeoJsonSource(TRACK_SOURCE_ID)
+            style.addSource(trackSource!!)
+            style.addLayer(LineLayer(TRACK_LAYER_ID, TRACK_SOURCE_ID).apply {
+                setProperties(
+                    PropertyFactory.lineColor("#E53935"),
+                    PropertyFactory.lineWidth(3f)
+                )
+            })
+        }
+        if (points.size >= 2) {
+            val coords = points.map { Point.fromLngLat(it.lon, it.lat) }
+            trackSource?.setGeoJson(Feature.fromGeometry(LineString.fromLngLats(coords)))
+        } else {
+            trackSource?.setGeoJson(FeatureCollection.fromFeatures(emptyList()))
+        }
+    }
+
     private fun createCirclePolygon(lat: Double, lon: Double, radiusMeters: Double): Polygon {
         val points = mutableListOf<Point>()
         val degreesBetweenPoints = 8