fix: nightly update checker never detected an update, at all

Root cause: when I consolidated the Android-only release-android.yml into
release-latest.yml (covering all 4 platforms), I rewrote every job's
release-body text and dropped the explicit "commit: <sha>" line the
original had — the new body just said "Rebuilt from `<sha>`,". That line
is exactly what UpdateChecker.extractCommitSha's regex requires
("commit:" literal + hex chars); without it, every fetched release parsed
with commitSha = null, and isUpdateAvailable short-circuits to false
whenever the fetched commitSha is null. So the checker silently always
reported "no update available," with no error anywhere — it looked
completely broken from the user's side, confirmed live against the actual
GitHub Release body (`gh release view latest`).

Two fixes, layered so this class of regression can't silently recur:
1. Restored the explicit "commit: <sha>" line in all 4 platform jobs'
   release bodies in release-latest.yml.
2. Made extractCommitSha resilient on its own: falls back to matching a
   bare 40-hex-char sha anywhere in the body (unambiguous enough to be
   safe unlabeled, unlike a short sha) if no "commit:"-labeled line is
   found, so a future body-text wording tweak can't quietly break parsing
   again the same way.

Also: versionCode/versionName were hardcoded to 1/"1.0" forever, so every
nightly build was indistinguishable from any other to Android itself (and
to a user checking Settings > App Info) — addressing the "needs to be
based on a build/commit number" ask directly. versionCode now derives from
`git rev-list --count HEAD` (monotonically increasing across this repo's
history by construction); versionName includes it plus the short commit
sha (e.g. "1.0.138-g188c156"). Had to also set `fetch-depth: 0` on
build-android's checkout step — actions/checkout@v4 defaults to a shallow
clone, under which `git rev-list --count HEAD` only ever sees 1 commit and
versionCode would've silently stayed 1 forever in CI regardless of this
fix. Verified locally: a real build now produces
versionCode='138' versionName='1.0.138-g188c156' via aapt2 dump badging,
matching this checkout's actual `git log --oneline | wc -l` and HEAD sha.

3 new tests covering the bare-sha fallback and the labeled-line-still-wins
precedence; 74 tests total, 0 failures.

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

Author: github-actions[bot]

.github/workflows/release-latest.yml

@@ -96,6 +96,12 @@ jobs:
       contents: write
     steps:
       - uses: actions/checkout@v4
+        with:
+          # Full history, not the default shallow (fetch-depth: 1) clone —
+          # mobile/app/build.gradle.kts derives versionCode from
+          # `git rev-list --count HEAD`, which only sees 1 commit (and so
+          # always resolves to versionCode 1, forever) on a shallow clone.
+          fetch-depth: 0
 
       - name: Set up JDK
         uses: actions/setup-java@v4
@@ -118,6 +124,8 @@ jobs:
             Android build is DEBUG-SIGNED (sideload only, not from the Play
             Store) — see docs/PACKAGING.md. Rebuilt from `${{ github.sha }}`,
             replaced on every push to master.
+
+            commit: ${{ github.sha }}
           prerelease: true
           files: dist/metanoia-android-debug.apk
 
@@ -163,6 +171,8 @@ jobs:
             macOS build (unsigned/ad-hoc-signed — see docs/PACKAGING.md for
             the Gatekeeper caveat). Unzip and run Metanoia.app. Rebuilt from
             `${{ github.sha }}`, replaced on every push to master.
+
+            commit: ${{ github.sha }}
           prerelease: true
           files: dist/Metanoia-macos-*.tar.gz
 
@@ -210,6 +220,8 @@ jobs:
             Linux build: universal tarball (with install.sh) + .deb for
             Debian/Ubuntu — see docs/PACKAGING.md. Rebuilt from
             `${{ github.sha }}`, replaced on every push to master.
+
+            commit: ${{ github.sha }}
           prerelease: true
           files: |
             dist/Metanoia-linux-*.tar.gz
@@ -277,5 +289,7 @@ jobs:
           body: |
             Portable Windows build — unzip and run metanoia.exe. Rebuilt
             from `${{ github.sha }}`, replaced on every push to master.
+
+            commit: ${{ github.sha }}
           prerelease: true
           files: dist/Metanoia-latest.zip

mobile/app/build.gradle.kts

@@ -33,8 +33,13 @@ android {
         applicationId = "com.bytecats.metanoia"
         minSdk = 28
         targetSdk = 35
-        versionCode = 1
-        versionName = "1.0"
+        // Was hardcoded to 1/"1.0" forever, so every nightly build looked
+        // identical to Android and to a user checking Settings > App Info —
+        // no way to tell which build is actually installed short of BuildConfig.
+        // versionCode = total commit count: monotonically increasing across
+        // this repo's history by construction, exactly what Android wants.
+        versionCode = gitCommitCount()
+        versionName = "1.0.${gitCommitCount()}-g${gitCommitSha().take(7)}"
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
         buildConfigField("String", "GIT_COMMIT_SHA", "\"${gitCommitSha()}\"")
     }
@@ -79,6 +84,16 @@ fun gitCommitSha(): String = try {
     if (output.matches(Regex("^[0-9a-f]{40}$"))) output else "unknown"
 } catch (e: Exception) { "unknown" }
 
+fun gitCommitCount(): Int = try {
+    val process = ProcessBuilder("git", "rev-list", "--count", "HEAD")
+        .directory(rootDir)
+        .redirectErrorStream(true)
+        .start()
+    val output = process.inputStream.bufferedReader().readText().trim()
+    process.waitFor()
+    output.toIntOrNull() ?: 1
+} catch (e: Exception) { 1 }
+
 dependencies {
     implementation("androidx.core:core-ktx:1.15.0")
     implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.8.7")

mobile/app/src/main/java/com/bytecats/metanoia/update/UpdateChecker.kt

@@ -37,6 +37,17 @@ object UpdateChecker {
     // tolerating surrounding whitespace.
     private val COMMIT_SHA_REGEX = Regex("""(?i)commit:\s*([0-9a-f]{7,40})\s*""")
 
+    // Fallback for when the body doesn't have an explicit "commit:" label —
+    // this happened for real: a release-workflow body-text rewrite dropped
+    // the labeled line while still mentioning the sha in prose (e.g.
+    // "Rebuilt from `<sha>`"), which silently made every update check think
+    // no commit sha was ever available (isUpdateAvailable degrades to
+    // "false" when commitSha is null) — the whole checker looked broken
+    // with no error anywhere. A bare 40-hex-char sha is unambiguous enough
+    // to match unlabeled (unlike a short sha, which is too easily confused
+    // with an unrelated hex-looking token), so this is a safe last resort.
+    private val BARE_FULL_SHA_REGEX = Regex("""(?i)\b([0-9a-f]{40})\b""")
+
     /**
      * Parses a GitHub Releases API JSON response body. Returns null on any
      * malformed input (missing/blank tag_name, invalid JSON, unexpected
@@ -79,11 +90,14 @@ object UpdateChecker {
     }
 
     /**
-     * Extracts the 7-40 char hex commit sha out of a "commit: <sha>" line in
-     * the release body, or null if no such line is present.
+     * Extracts a commit sha from the release body: prefers an explicit
+     * "commit: <sha>" line, falls back to a bare 40-char hex sha anywhere in
+     * the text (see BARE_FULL_SHA_REGEX for why), or null if neither is
+     * present.
      */
     fun extractCommitSha(body: String): String? =
         COMMIT_SHA_REGEX.find(body)?.groupValues?.get(1)
+            ?: BARE_FULL_SHA_REGEX.find(body)?.groupValues?.get(1)
 
     /**
      * Pure comparison: is `fetched` a genuinely different build than the one

mobile/app/src/test/java/com/bytecats/metanoia/UpdateCheckerTest.kt

@@ -147,6 +147,34 @@ class UpdateCheckerTest {
         assertNull(UpdateChecker.extractCommitSha("nothing relevant"))
     }
 
+    @Test
+    fun extractCommitShaFallsBackToBareFullShaWhenNoCommitLabel() {
+        // Regression test: release-latest.yml's body text was rewritten to
+        // "Rebuilt from `<sha>`, replaced on every push to master." with no
+        // "commit:" label at all, which silently made every update check
+        // think no update was ever available (see isUpdateAvailable) — the
+        // in-app checker looked completely broken with no visible error.
+        val sha = UpdateChecker.extractCommitSha(
+            "Android build is DEBUG-SIGNED. Rebuilt from `$fullShaOne`, replaced on every push to master."
+        )
+        assertEquals(fullShaOne, sha)
+    }
+
+    @Test
+    fun extractCommitShaPrefersLabeledLineOverBareShaWhenBothPresent() {
+        val otherSha = "9f9f9f9f9f9f9f9f9f9f9f9f9f9f9f9f9f9f9f9f"
+        val sha = UpdateChecker.extractCommitSha("mentions `$otherSha` in passing\ncommit: $fullShaOne")
+        assertEquals(fullShaOne, sha)
+    }
+
+    @Test
+    fun extractCommitShaDoesNotMatchBareShortShaWithoutLabel() {
+        // Short (non-40-char) shas are too easily confused with unrelated
+        // hex-looking tokens to safely match unlabeled — only the labeled
+        // "commit:" form (tested elsewhere) accepts short shas.
+        assertNull(UpdateChecker.extractCommitSha("built from a1b2c3d today"))
+    }
+
     // -------------------------------------------------------------------
     // isUpdateAvailable
     // -------------------------------------------------------------------