fix: report the app's own version in every heartbeat (#42)

* fix: report the app's own version in every heartbeat

system_info carried os, arch, os_version and device_type but never a version.
The server reads system_info.version to decide whether a worker is on a
different release series, so every Android device read as "version unknown" and
there was no way to see which phones were on an outdated build.

That is how two devices sat on a pre-enrollment build for weeks: per-worker key
enrollment shipped in 0.2.0, both phones were older, both were still using the
shared bootstrap key, and the fleet page had no version to show. It surfaced
only when the server started bounding how long an unconfirmed worker may keep
using that key.

Defaults to empty on purpose. An absent version must read as unknown, not as a
match -- the server only calls something a mismatch when both sides are known
releases.

* fix: declare version last so positional destructuring is unchanged

DataClassContractTest destructures SystemInfo positionally, so member order is
part of this class's contract. Adding `version` before `apps` silently changed
what component5() means and broke compilation -- caught by CI, which is exactly
what that test is for.

version now sits after apps, and the destructuring test covers it as component6
so the ordering is a deliberate contract rather than an accident.

Author: GeiserX

CHANGELOG.md

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Fixed
+
+- **The app now reports its own version to the server.** Every heartbeat's `system_info` carried `os`, `arch`, `os_version` and `device_type`, but never a `version`. The CashPilot server reads exactly that key to tell whether a worker is on a different release series from the UI, so every Android device showed as "version unknown" on the fleet page and there was no way to see which phones were running an outdated build.
+
+  That is not cosmetic. Per-worker key enrollment shipped in 0.2.0, but two devices stayed on an older build for weeks, still authenticating with the shared bootstrap key, and nothing surfaced it — the fleet page had no version to show. It only came to light when the server began bounding how long an unconfirmed worker may keep using the shared key.
+
+  An absent version still reads as *unknown*, never as a match: the server only reports a mismatch when both sides are known releases.
+
 ## [0.2.0] - 2026-07-11
 
 ### Added

app/src/main/java/com/cashpilot/android/model/Heartbeat.kt

@@ -36,6 +36,24 @@ data class SystemInfo(
     @SerialName("os_version") val osVersion: String = "",
     @SerialName("device_type") val deviceType: String = "android",
     val apps: List<AppStatus> = emptyList(),
+    /**
+     * This app's own version, e.g. "0.2.1".
+     *
+     * The server reads `system_info.version` to decide whether a worker is on a
+     * different release series from the UI. Android never sent it, so every
+     * device read as "version unknown" and there was no way to see which phones
+     * were on an outdated build -- which is how two devices sat on a
+     * pre-enrollment release for weeks without anyone noticing.
+     *
+     * Defaults to empty on purpose: an ABSENT version must read as unknown, not
+     * as a match. The server's own rule is that both sides must be known
+     * releases before it will call anything a mismatch.
+     *
+     * Declared LAST on purpose: DataClassContractTest destructures SystemInfo
+     * positionally, so member order is part of this class's contract and
+     * inserting anywhere else silently changes what component5() means.
+     */
+    val version: String = "",
 )
 
 @Serializable

app/src/main/java/com/cashpilot/android/service/HeartbeatService.kt

@@ -11,6 +11,7 @@ import android.provider.Settings.Secure
 import android.util.Log
 import androidx.core.app.NotificationCompat
 import com.cashpilot.android.R
+import com.cashpilot.android.BuildConfig
 import com.cashpilot.android.model.AppContainer
 import com.cashpilot.android.model.Settings
 import com.cashpilot.android.model.SystemInfo
@@ -118,6 +119,7 @@ class HeartbeatService : Service() {
                     arch = Build.SUPPORTED_ABIS.firstOrNull() ?: "unknown",
                     osVersion = "Android ${Build.VERSION.RELEASE} (API ${Build.VERSION.SDK_INT})",
                     deviceType = "android",
+                    version = BuildConfig.VERSION_NAME,
                 ),
             )
 

app/src/test/java/com/cashpilot/android/DataClassContractTest.kt

@@ -91,13 +91,18 @@ class DataClassContractTest {
             osVersion = "Android 15",
             deviceType = "android",
             apps = listOf(AppStatus(slug = "test", running = true)),
+            version = "9.9.9",
         )
-        val (os, arch, osVersion, deviceType, apps) = info
+        // version is component6, declared after apps so that adding it did not
+        // shift what component5 means. This test is what makes that ordering a
+        // deliberate contract rather than an accident.
+        val (os, arch, osVersion, deviceType, apps, version) = info
         assertEquals("Android", os)
         assertEquals("arm64-v8a", arch)
         assertEquals("Android 15", osVersion)
         assertEquals("android", deviceType)
         assertEquals(1, apps.size)
+        assertEquals("9.9.9", version)
     }
 
     @Test

app/src/test/java/com/cashpilot/android/SerializationTest.kt

@@ -131,6 +131,33 @@ class SerializationTest {
         assertFalse(encoded.contains("\"deviceType\""))
     }
 
+    // --- version reporting (the app was invisible to the server's skew check) ---
+
+    @Test
+    fun `SystemInfo carries a version field the server can read`() {
+        // The server reads system_info.version to decide whether a worker is on
+        // a different release series. Android never sent it, so every device
+        // read as "version unknown" and two phones sat on a pre-enrollment
+        // build for weeks unnoticed.
+        val encoded = json.encodeToString(SystemInfo(version = "0.2.1"))
+        assertTrue(encoded.contains("\"version\":\"0.2.1\""), encoded)
+    }
+
+    @Test
+    fun `SystemInfo version round-trips`() {
+        val original = SystemInfo(os = "Android", version = "1.2.3")
+        assertEquals(original, json.decodeFromString<SystemInfo>(json.encodeToString(original)))
+    }
+
+    @Test
+    fun `an absent version decodes as empty, never as a match`() {
+        // Absent must read as UNKNOWN. The server only calls something a
+        // mismatch when BOTH sides are known releases, so an empty string here
+        // is the safe value -- inventing one would fabricate agreement.
+        val decoded = json.decodeFromString<SystemInfo>("""{"os":"Android"}""")
+        assertEquals("", decoded.version)
+    }
+
     @Test
     fun `SystemInfo defaults round-trip`() {
         val original = SystemInfo()