From c835b596eaca1f7bc2b7e59bc33f8f614e1626b6 Mon Sep 17 00:00:00 2001
From: JingMatrix <jingmatrix@gmail.com>
Date: Fri, 31 Jul 2026 00:16:01 +0200
Subject: [PATCH 1/2] Put the commit first in the build stamp, and compare only
 that

#809 gave the stamp a second half and left the comparison reading the whole
string. A canary reports `JingMatrix-Vector-93d66473` and no release SHA starts
with that, so `divergesFrom` was true for the very release the reader had just
flashed: the install bar warned "same number, other build", the versions sheet
coloured that row divergent, and since installed is sameNumber && !diverged, no
row was ever marked as installed. The `-dirty` branch it still tested had become
unreachable in the same commit.

The stamp now leads with the commit -- `93d66473-JingMatrix-Vector` -- so
reading it back is a prefix and nothing more, whatever hyphens a repository or a
machine turns out to have in its name. A modified tree is marked `+` rather than
`-`, in semver's sense of build metadata: after a `-` is a repository holding
this exact commit, after a `+` are changes no repository holds. Without that
distinction a hand-built framework would claim to be the release it was merely
started from.

`buildStamp` takes one apart, and `isCommit` compares as a prefix in either
direction, since a stamp carries git's short form and a release the full SHA.
Where a build was made is deliberately not compared: a fork building the same
commit builds the same code. A stamp that names no commit -- "unknown", or the
shape published between #809 and here -- is "I cannot tell" rather than
divergence, so the canaries already flashed claim neither.

On the status page the commit keeps the size it is read at and the rest is set
smaller and muted, since it is two thirds of the characters and almost never
what the row is looked up for. Copying the page still yields the whole stamp;
de-emphasising it must not shorten it.
---
 build.gradle.kts                              | 38 +++++++---
 manager/README.md                             |  7 +-
 .../vector/manager/data/model/BuildStamp.kt   | 74 +++++++++++++++++++
 .../repository/FrameworkUpdateRepository.kt   | 22 ++++--
 .../manager/ui/screens/home/HomeViewModel.kt  |  7 +-
 .../ui/screens/home/SystemStatusScreen.kt     | 69 +++++++++++++----
 .../org/lsposed/lspd/ILSPManagerService.aidl  |  9 ++-
 7 files changed, 188 insertions(+), 38 deletions(-)
 create mode 100644 manager/src/main/kotlin/org/matrix/vector/manager/data/model/BuildStamp.kt

diff --git a/build.gradle.kts b/build.gradle.kts
index b9ef7d796..5e85fae41 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -61,18 +61,26 @@ abstract class GitLatestTagValueSource : ValueSource<String, ValueSourceParamete
 }
 
 /**
- * Which build this is, in one string: where it was built and from what commit.
+ * Which build this is, in one string: what commit it came from and where it was built.
  *
  * The version code is the commit count on origin/master, so every branch build carries master's
  * number: a build flashed from a feature branch and one flashed from master both report "v2.0
  * (3052)" and cannot be told apart on the device. That is not hypothetical — it cost a real
  * investigation to establish which of the two was installed.
  *
- * Two shapes, because "where did this binary come from" has two different answers:
+ * **The commit always comes first, and what follows always says where.** Both readers of this string
+ * want the commit and nothing else — the manager compares it against the SHA a release was cut from
+ * to answer "am I running this build", and the status page sets it in a type the rest is not given
+ * — and for both it is now simply the head of the string. No rule has to work out which part is
+ * which, so none can get it wrong when a repository or a machine turns out to have a hyphen in its
+ * name.
  *
- * *On GitHub Actions*, `JingMatrix-Vector-93d66473` — the repository the code came from, then the
- * commit. Forks build the same code from the same commits, so the hash alone identifies a
- * *revision* and not a *build*, and a fork's artifact was indistinguishable from ours.
+ * The separator says which kind of "where" follows, because they mean opposite things about whether
+ * the commit describes the binary:
+ *
+ * *On GitHub Actions*, `93d66473-JingMatrix-Vector` — the commit, then the repository the code came
+ * from. Forks build the same code from the same commits, so the hash alone identifies a *revision*
+ * and not a *build*, and a fork's artifact was indistinguishable from ours.
  *
  * Both halves are the *head* ones, and neither is read from the environment GitHub sets by default,
  * because on a pull request both defaults name something other than the code that was built:
@@ -91,11 +99,17 @@ abstract class GitLatestTagValueSource : ValueSource<String, ValueSourceParamete
  * when there is not — outside a pull request the two agree anyway. Absent either, this falls back to
  * what the environment says and to `HEAD`, which covers a workflow too old to set them.
  *
- * *Locally*, the bare `93d66473`, or `93d66473-thinkpad` when the tree has uncommitted changes.
- * That build corresponds to no commit at all, so naming the commit alone would name something the
- * binary does not match — and whoever is looking at it is far better served by the machine it was
- * built on than by the word "dirty", since a device that has a hand-built framework on it usually
- * has exactly one candidate author.
+ * *Locally*, the bare `93d66473`, or `93d66473+thinkpad` when the tree has uncommitted changes. That
+ * build corresponds to no commit at all, so naming the commit alone would name something the binary
+ * does not match — and whoever is looking at it is far better served by the machine it was built on
+ * than by the word "dirty", since a device that has a hand-built framework on it usually has exactly
+ * one candidate author.
+ *
+ * `+` rather than `-` for that one, in semver's sense of build metadata: after a `-` is a repository
+ * that holds this exact commit, and after a `+` is a change that is in no repository at all. That is
+ * the one distinction a reader of the stamp cannot afford to lose — a modified build matches no
+ * release, and read as a CI build it would claim to be the release it was merely started from.
+ * Neither character can occur inside a host name or an `owner/repo`, so the two shapes stay apart.
  *
  * The dirty check is deliberately not applied on CI. The workflow's own "Write key" step appends
  * the signing credentials to the tracked `gradle.properties` before Gradle starts, so every master
@@ -165,7 +179,7 @@ abstract class GitCommitHashValueSource : ValueSource<String, GitCommitHashValue
         val repository = parameters.buildRepository.getOrElse("")
         if (repository.isBlank()) {
             val dirty = capture("git", "status", "--porcelain", "--untracked-files=no") != null
-            return if (dirty) "$head-${hostname()}" else head
+            return if (dirty) "$head+${hostname()}" else head
         }
 
         // The pushed commit is an ancestor of the merge that was checked out, so it is in the
@@ -174,7 +188,7 @@ abstract class GitCommitHashValueSource : ValueSource<String, GitCommitHashValue
         val pushed = parameters.buildCommit.getOrElse("").takeIf { it.isNotBlank() }
         val short =
             pushed?.let { capture("git", "rev-parse", "--short", it) ?: it.take(head.length) } ?: head
-        return repository.replace('/', '-') + "-" + short
+        return short + "-" + repository.replace('/', '-')
     }
 }
 
diff --git a/manager/README.md b/manager/README.md
index 2be524467..3849de2e2 100644
--- a/manager/README.md
+++ b/manager/README.md
@@ -86,8 +86,11 @@ asserting the old meaning until someone notices, which can be a long time.
 ```
 
 The version code is `git rev-list --count refs/remotes/origin/master`, so a branch build and a
-master build can share one; `module.prop` carries the commit, marked `-dirty` when the tree was not
-clean, which is often the only way to tell two builds apart on a device.
+master build can share one; `module.prop` and the status page carry a build stamp, which is often
+the only way to tell two builds apart on a device. It names where the build came from as well as
+what it was built from. The commit leads and what follows says where: `93d66473-JingMatrix-Vector`
+for a CI build, the bare `93d66473` for a local one, and `93d66473+thinkpad` — the machine that made
+it — when the tree was not clean.
 
 Debug builds add a second launcher activity — a demo mode with scripted device states, in
 `src/debug` and absent from release builds, so it cannot be used to make a release report a healthy
diff --git a/manager/src/main/kotlin/org/matrix/vector/manager/data/model/BuildStamp.kt b/manager/src/main/kotlin/org/matrix/vector/manager/data/model/BuildStamp.kt
new file mode 100644
index 000000000..aa19cfc3e
--- /dev/null
+++ b/manager/src/main/kotlin/org/matrix/vector/manager/data/model/BuildStamp.kt
@@ -0,0 +1,74 @@
+package org.matrix.vector.manager.data.model
+
+/**
+ * A build stamp, taken apart: which commit a build came from, and where it was built.
+ *
+ * The framework and the manager both report one — `BuildConfig.VERSION_HASH`, and
+ * `getFrameworkCommit()` across the binder — because the version code cannot tell two builds apart:
+ * it is the commit count on origin/master, so every branch build at the same depth wears the same
+ * number as the official build it was never made from.
+ *
+ * Only the commit is taken out. Where a build was made is for a person to read, and it is exactly
+ * the rest of the string — a caller that wants it takes what follows the commit, separator and all.
+ *
+ * @property commit the commit the build was made from, abbreviated as git abbreviated it, or null
+ *   when the stamp names none — "unknown" from a build made outside a git checkout, and anything
+ *   else this does not recognise. That is a third answer, distinct from "these differ".
+ * @property modified whether the tree had uncommitted changes. Such a build was made from no commit
+ *   at all: [commit] names the one it departed from, not one the binary corresponds to.
+ */
+data class BuildStamp(val commit: String?, val modified: Boolean) {
+
+    /**
+     * Whether this build and [other] were made from the same commit.
+     *
+     * A modified tree matches nothing, including itself. Otherwise it is a prefix test in either
+     * direction, because the two sides need not be abbreviated to the same length: a stamp carries
+     * git's short form and a GitHub release carries the full SHA.
+     *
+     * **Where the build was made is deliberately not compared.** A fork building the same commit
+     * builds the same code; the repository is in the stamp to identify a *binary* to someone
+     * reading a bug report, which is a different question from "is this the build that release
+     * published".
+     */
+    fun isCommit(other: String?): Boolean {
+        if (modified || other == null) return false
+        val ours = commit ?: return false
+        return other.startsWith(ours) || ours.startsWith(other)
+    }
+}
+
+/**
+ * Reads a build stamp.
+ *
+ * The commit leads, always, and the separator says what follows it — `-` a repository that holds
+ * this exact commit, `+` a machine that holds changes no repository does. So the commit is the head
+ * and there is nothing to guess: neither character can occur inside a host name or an `owner/repo`,
+ * and a hyphen inside either is harmless because everything after the first one is the origin.
+ *
+ * - `93d66473` — a local build of a clean tree.
+ * - `93d66473-JingMatrix-Vector` — CI, from `JingMatrix/Vector`.
+ * - `93d66473+thinkpad` — a local build with uncommitted changes, named by the machine that made it.
+ *
+ * A stamp that does not start with a commit yields a null one, which everywhere it is asked means
+ * "I cannot tell" rather than "these differ". That covers the shape shipped between #809 and this
+ * change, `JingMatrix-Vector-93d66473`, which is what the canaries already on people's devices
+ * carry: they are shown as they were recorded and claimed to be neither installed nor divergent,
+ * which is the truthful answer for a build whose stamp this cannot read.
+ */
+fun buildStamp(reported: String): BuildStamp {
+    val stamp = reported.trim()
+    val head = stamp.takeWhile { it != '-' && it != '+' }
+    if (!head.isAbbreviatedSha()) return BuildStamp(null, modified = false)
+    return BuildStamp(commit = head, modified = stamp.getOrNull(head.length) == '+')
+}
+
+/**
+ * Whether this could be a commit as git abbreviates one.
+ *
+ * Seven is git's own floor for an abbreviation and forty is a full SHA. Lower case only, which git
+ * emits and which is what keeps the word "unknown" — a build made where git could not be asked —
+ * from being mistaken for one.
+ */
+private fun String.isAbbreviatedSha(): Boolean =
+    length in 7..40 && all { it.isDigit() || it in 'a'..'f' }
diff --git a/manager/src/main/kotlin/org/matrix/vector/manager/data/repository/FrameworkUpdateRepository.kt b/manager/src/main/kotlin/org/matrix/vector/manager/data/repository/FrameworkUpdateRepository.kt
index b807a3522..cf836d1ef 100644
--- a/manager/src/main/kotlin/org/matrix/vector/manager/data/repository/FrameworkUpdateRepository.kt
+++ b/manager/src/main/kotlin/org/matrix/vector/manager/data/repository/FrameworkUpdateRepository.kt
@@ -5,6 +5,7 @@ import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.asStateFlow
 import org.matrix.vector.manager.data.github.FrameworkRelease
 import org.matrix.vector.manager.data.github.GitHubRepository
+import org.matrix.vector.manager.data.model.buildStamp
 
 /**
  * Whether a newer build of the framework exists, and which one this reader may be offered.
@@ -70,7 +71,12 @@ class FrameworkUpdateRepository(private val github: GitHubRepository) {
  */
 data class FrameworkUpdateState(
     val installedVersionCode: Long = 0,
-    /** The commit the running daemon was built from, when it recorded one. */
+    /**
+     * The build stamp the running daemon reports, when it recorded one.
+     *
+     * Not a bare hash: it names where the build came from as well as what commit it was made from,
+     * in one of the shapes [buildStamp] reads. Nothing here compares it as a string.
+     */
     val installedCommit: String? = null,
     val available: FrameworkRelease? = null,
     /** Every release on this channel, newest first — including ones older than the installed one. */
@@ -93,12 +99,16 @@ enum class ReleaseDirection {
  * Only askable when both sides recorded a commit: the canaries carry a SHA, a hand-made release
  * carries a branch name, and a build made before this existed carries nothing. "I cannot tell" is a
  * third answer and is reported as false rather than as divergence.
+ *
+ * What the framework reports is a *build stamp*, not a bare hash, so the commit is read out of it
+ * before anything is compared. Comparing the whole stamp is what #809 left behind: a CI stamp
+ * carries the repository as well, no release SHA matches that, and so every canary reader was told
+ * they were running "same number, other build" against the very release they had flashed, with no
+ * row anywhere marked as installed.
  */
 fun FrameworkUpdateState.divergesFrom(release: FrameworkRelease?): Boolean {
     if (release == null || release.versionCode != installedVersionCode) return false
-    val mine = installedCommit ?: return false
-    val theirs = release.commit ?: return false
-    // A dirty build matches nothing by definition — it was not built from any commit.
-    if (mine.endsWith("-dirty")) return true
-    return !theirs.startsWith(mine)
+    val mine = buildStamp(installedCommit ?: return false)
+    if (mine.commit == null || release.commit == null) return false
+    return !mine.isCommit(release.commit)
 }
diff --git a/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/HomeViewModel.kt b/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/HomeViewModel.kt
index fddc158f8..098d1fd76 100644
--- a/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/HomeViewModel.kt
+++ b/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/HomeViewModel.kt
@@ -47,13 +47,14 @@ data class FrameworkStatus(
     val sepolicyLoaded: Boolean = false,
     val systemServerInjected: Boolean = false,
     /**
-     * Which build the running framework is: where it came from and from what commit.
+     * Which build the running framework is: what commit it came from and where it was built.
      *
      * The version code is a commit count, so it cannot tell a branch build from the official build
      * of the same depth — and the framework and the manager are flashed separately, so they are
      * not always the same build. Naming both is the difference between a bug report that can be
-     * placed and one that cannot. A CI build reads `JingMatrix-Vector-93d66473`, a clean local one
-     * the bare hash, and a local build from a modified tree adds the machine that made it.
+     * placed and one that cannot. The commit leads: a CI build reads `93d66473-JingMatrix-Vector`,
+     * a clean local one the bare hash, and a local build from a modified tree marks the machine
+     * that made it with a `+`. Taken apart by `buildStamp`; nothing compares it as a string.
      */
     val commit: String? = null,
 ) {
diff --git a/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/SystemStatusScreen.kt b/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/SystemStatusScreen.kt
index 01259660a..2c6c36332 100644
--- a/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/SystemStatusScreen.kt
+++ b/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/home/SystemStatusScreen.kt
@@ -46,7 +46,10 @@ import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.buildAnnotatedString
 import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.text.withStyle
 import androidx.compose.ui.semantics.Role
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
@@ -65,6 +68,7 @@ import org.matrix.vector.manager.R
 import org.matrix.vector.manager.ui.components.FrameworkState
 import org.matrix.vector.manager.data.log.CrashRecorder
 import org.matrix.vector.manager.data.model.XposedApi
+import org.matrix.vector.manager.data.model.buildStamp
 import org.matrix.vector.manager.data.repository.ManagerInstallStep
 import org.matrix.vector.manager.ui.components.SnackbarTone
 import org.matrix.vector.manager.ui.components.VectorSnackbarHost
@@ -149,7 +153,12 @@ fun SystemStatusScreen(
                                 context,
                                 englishSections.joinToString("\n\n") { (heading, items) ->
                                     heading +
-                                        items.joinToString("") { "\n  ${it.label}: ${it.value}" }
+                                        items.joinToString("") {
+                                            // With the detail, which the screen only sets apart
+                                            // rather than shortens. Where a build came from is
+                                            // half of what makes the stamp worth pasting.
+                                            "\n  ${it.label}: ${it.value}${it.detail.orEmpty()}"
+                                        }
                                 },
                             )
                             scope.launch { snackbars.show(copied, SnackbarTone.Success) }
@@ -564,6 +573,12 @@ private fun CrashCard(report: String, onCopy: () -> Unit, onClear: () -> Unit) {
  *
  * A fact that can be good or bad says which by its colour, so the page answers "is anything wrong"
  * before it is read at all.
+ *
+ * A row may end in a [InfoItem.detail], set smaller and in the muted colour. It is part of the same
+ * value and stays in the same line — a reader copying a version out by hand still gets all of it —
+ * but it is not what the row is looked up for. On the build rows that is where the stamp came from;
+ * the commit is what someone comparing two devices reads, and the repository or machine after it is
+ * two thirds of the characters and almost never the answer.
  */
 @Composable
 private fun InfoRow(row: InfoItem) {
@@ -580,7 +595,15 @@ private fun InfoRow(row: InfoItem) {
             )
             Spacer(Modifier.height(2.dp))
             Text(
-                text = row.value,
+                text =
+                    buildAnnotatedString {
+                        append(row.value)
+                        row.detail?.let { detail ->
+                            val muted =
+                                SpanStyle(fontSize = 12.sp, color = colors.onSurfaceVariant)
+                            withStyle(muted) { append(detail) }
+                        }
+                    },
                 style =
                     if (row.monospace) VectorMono.copy(fontSize = 15.sp)
                     else MaterialTheme.typography.bodyLarge,
@@ -616,11 +639,30 @@ private enum class Health {
 private data class InfoItem(
     val label: String,
     val value: String,
+    /** The tail of the value that is context rather than identity; set apart, never dropped. */
+    val detail: String? = null,
     val health: Health = Health.Neutral,
     /** True where the value is an identifier to be compared character by character. */
     val monospace: Boolean = true,
 )
 
+/**
+ * A build row: the version number, the commit, and — set apart — where that build was made.
+ *
+ * The stamp leads with the commit and says where after it, so the split is the commit's own length
+ * and needs no second opinion about which half is which. What is left includes the separator, which
+ * is worth keeping visible: `-` is a repository that holds this exact commit and `+` is a machine
+ * holding changes that no repository does.
+ *
+ * A stamp that names no commit — "unknown", from a build made where git could not be asked — is not
+ * cut at all. It goes to the muted half whole, because none of it is an identifier.
+ */
+private fun buildRow(label: String, number: String, reported: String?): InfoItem {
+    val stamp = reported?.takeIf { it.isNotBlank() } ?: return InfoItem(label, number)
+    val commit = buildStamp(stamp).commit.orEmpty()
+    return InfoItem(label, "$number  ·  $commit", detail = stamp.removePrefix(commit))
+}
+
 /** A heading, so the page reads as three short lists rather than one long one. */
 @Composable
 private fun SectionHeading(text: String) {
@@ -649,24 +691,23 @@ private fun buildSections(
     return listOf(
         str(R.string.info_section_build) to
             listOf(
-                InfoItem(
+                // The exact build, not just its number. Two builds share a version code whenever
+                // they sit at the same depth on different branches, so the stamp names where the
+                // build came from as well as the commit: the repository for a CI build, the machine
+                // for a local one from a modified tree. That is what a bug report needs and what
+                // the number alone cannot give.
+                buildRow(
                     str(R.string.info_framework_version),
-                    buildString {
-                        append(status.versionLabel ?: unknown)
-                        // The exact build, not just its number. Two builds share a version code
-                        // whenever they sit at the same depth on different branches, so this names
-                        // where the build came from as well as the commit: the repository for a CI
-                        // build, the machine for a local one from a modified tree. That is what a
-                        // bug report needs and what the number alone cannot give.
-                        status.commit?.takeIf { it.isNotBlank() }?.let { append("  ·  ").append(it) }
-                    },
+                    status.versionLabel ?: unknown,
+                    status.commit,
                 ),
                 // Named separately from the framework, because they are flashed separately and are
                 // not always the same build. When these two disagree, that is the answer to a whole
                 // class of "it behaves oddly" reports.
-                InfoItem(
+                buildRow(
                     str(R.string.info_manager_version),
-                    "${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})  ·  ${BuildConfig.VERSION_HASH}",
+                    "${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})",
+                    BuildConfig.VERSION_HASH,
                 ),
                 // Named by which scale the number is on. The two share a field and nothing else: 93
                 // is a legacy Xposed API, 101 is a libxposed one, and calling both "Xposed API" is
diff --git a/services/manager-service/src/main/aidl/org/lsposed/lspd/ILSPManagerService.aidl b/services/manager-service/src/main/aidl/org/lsposed/lspd/ILSPManagerService.aidl
index 9b7eb51c7..15ab06767 100644
--- a/services/manager-service/src/main/aidl/org/lsposed/lspd/ILSPManagerService.aidl
+++ b/services/manager-service/src/main/aidl/org/lsposed/lspd/ILSPManagerService.aidl
@@ -148,10 +148,17 @@ interface ILSPManagerService {
     void installFrameworkZip(String zipPath, IFrameworkInstallCallback callback) = 57;
 
     /**
-     * The commit this daemon was built from, short, or null when it was not recorded.
+     * Which build this daemon is, or null when it was not recorded.
      *
      * The version code is the commit count on origin/master, so a branch build and the official
      * build of the same count are indistinguishable by number alone. This is what tells them apart.
+     *
+     * Not a bare hash, despite the name: it is the build stamp, which names where the build came
+     * from as well as what commit it was made from — `93d66473-JingMatrix-Vector` from CI,
+     * `93d66473` from a clean local tree, `93d66473+thinkpad` from a modified one. The commit
+     * always leads, so a caller that wants it takes the head and not the whole string; `-` is
+     * followed by the repository that holds that commit, `+` by the machine holding changes that
+     * no repository does.
      */
     String getFrameworkCommit() = 58;
 

From e1fd95f0cae91222ddc29657a541b7d6e72419a0 Mon Sep 17 00:00:00 2001
From: JingMatrix <jingmatrix@gmail.com>
Date: Fri, 31 Jul 2026 07:10:33 +0200
Subject: [PATCH 2/2] Give the version rows a status column of fixed width

In the versions sheet the status sits in whatever room it needs, so the row
whose build diverges -- a clause where every other row has one word -- takes
that room from the build's name and wraps both the name and its date onto a
second line. One row of five is then twice the height of the rest, and the
column of names it belongs to is no longer a column.

The status now has a width of its own, kept whether or not the row has anything
to say, and the name and date are single-line. The clause wraps inside that
width instead, which costs nothing: three lines of a label are still shorter
than the two lines a name and its date already occupy.
---
 .../screens/update/FrameworkUpdateScreen.kt   | 58 ++++++++++++++-----
 1 file changed, 45 insertions(+), 13 deletions(-)

diff --git a/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/update/FrameworkUpdateScreen.kt b/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/update/FrameworkUpdateScreen.kt
index 01aef5fa6..31bee01e7 100644
--- a/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/update/FrameworkUpdateScreen.kt
+++ b/manager/src/main/kotlin/org/matrix/vector/manager/ui/screens/update/FrameworkUpdateScreen.kt
@@ -22,6 +22,7 @@ import androidx.compose.material.icons.rounded.RadioButtonChecked
 import androidx.compose.material.icons.rounded.History
 import org.matrix.vector.manager.data.github.ZipVariant
 import org.matrix.vector.manager.data.github.CanaryArtifact
+import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.text.style.TextOverflow
 import androidx.compose.material3.SingleChoiceSegmentedButtonRow
 import androidx.compose.material3.SegmentedButtonDefaults
@@ -545,6 +546,16 @@ private fun VariantPicker(
     }
 }
 
+/**
+ * How much of a version row the status on its right may take.
+ *
+ * Wide enough for "Installed" and "Older" on one line in every language shipped, and narrow enough
+ * that what is left still holds a build's name and its date without wrapping on a phone. The
+ * divergence clause is longer than that and wraps inside this width, which is the point of fixing
+ * it: one row's wordier status must not move where the next row's name begins.
+ */
+private val STATUS_WIDTH = 96.dp
+
 /**
  * Every build on this channel, so "no update available" is not a dead end.
  *
@@ -591,7 +602,13 @@ private fun VersionsSheet(
                                 onSelect(release)
                                 onDismiss()
                             },
-                        headlineContent = { Text(release.title) },
+                        // One line each, always. What names the build is the same shape in every
+                        // row — "Vector v2.0 canary 3060", then its date and channel — and a row
+                        // that wraps because of what is beside it reads as a different kind of
+                        // entry when it is not.
+                        headlineContent = {
+                            Text(release.title, maxLines = 1, overflow = TextOverflow.Ellipsis)
+                        },
                         supportingContent = {
                             Text(
                                 listOfNotNull(
@@ -603,7 +620,9 @@ private fun VersionsSheet(
                                             stringResource(R.string.update_channel_release)
                                         },
                                     )
-                                    .joinToString("  ·  ")
+                                    .joinToString("  ·  "),
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
                             )
                         },
                         leadingContent = {
@@ -625,6 +644,13 @@ private fun VersionsSheet(
                                     },
                             )
                         },
+                        // A column of its own width, kept even when this row has nothing to say.
+                        // The status is one word on most rows and a whole clause on the divergent
+                        // one; sized to its content it would take the room the build's name needs
+                        // and wrap that row alone, and a slot that disappears when empty would
+                        // start each row's name in a different place. The label wraps inside its
+                        // column instead, where it costs nothing: three lines of it are still
+                        // shorter than the two the name and its date already occupy.
                         trailingContent = {
                             val label =
                                 when {
@@ -633,17 +659,23 @@ private fun VersionsSheet(
                                     older -> stringResource(R.string.update_older)
                                     else -> null
                                 }
-                            if (label != null) {
-                                Text(
-                                    label,
-                                    style = MaterialTheme.typography.labelSmall,
-                                    color =
-                                        when {
-                                            installed -> colors.primary
-                                            diverged -> colors.tertiary
-                                            else -> colors.onSurfaceVariant
-                                        },
-                                )
+                            Box(
+                                modifier = Modifier.width(STATUS_WIDTH),
+                                contentAlignment = Alignment.CenterEnd,
+                            ) {
+                                if (label != null) {
+                                    Text(
+                                        label,
+                                        style = MaterialTheme.typography.labelSmall,
+                                        textAlign = TextAlign.End,
+                                        color =
+                                            when {
+                                                installed -> colors.primary
+                                                diverged -> colors.tertiary
+                                                else -> colors.onSurfaceVariant
+                                            },
+                                    )
+                                }
                             }
                         },
                         colors = sheetRowColors,