fix: v0.1.10 wrongly showed as TooOld when only 1 release behind

User screenshot: running v0.1.10, latest v0.1.11, banner says "v0.1.10
is too old (latest v0.1.11). Uploads are blocked until you update."
With StaleThresholdVersions=2 they should have seen the yellow
"slightly stale" banner — one release behind is well inside the
tolerance.

Root cause: System.Version-shape mismatch in the staleness IndexOf.

  * Assembly.GetName().Version returns 4-part Version(0,1,10,0)
    (Revision=0)
  * TryParseTag("v0.1.10") returns 3-part Version(0,1,10)
    (Revision=-1, "unset" sentinel)
  * List<Version>.IndexOf uses Version.Equals, which compares ALL
    FOUR components → 4-part current never matches 3-part released
    list → idxInRecent = -1 → fell through to TooOld.

The Compare-against-latest branch worked fine (Version.CompareTo
treats Revision=-1 as < Revision=0 but the Build difference
dominated, so we correctly detected "older"). The IndexOf is the
only place where component-exact equality matters, and that's where
it went wrong.

Fix in two places (defensive at source and consumer):

  * UpdateChecker.GetCurrentAssemblyVersion now normalises to
    3-part via new NormalizeToThreePart helper.
  * UpdateChecker.Compute also normalises both currentVersion and
    every element of releasedVersions on entry. Either fix alone
    would have closed the bug; doing both means the function is
    correct in isolation regardless of how the caller shapes
    inputs.

Regression tests:

  * Compute_FourPartCurrentVersionStillMatchesThreePartReleased
    pins exactly the shape that bit production (4-part current vs
    3-part released).
  * Compute_FourPartCurrentEqualsThreePartLatest_IsCurrentNotDevBuild
    pins a related shape — without normalisation,
    Version(0,1,11,0).CompareTo(Version(0,1,11)) > 0 would have
    misclassified a fully up-to-date 4-part install as DevBuild.
  * NormalizeToThreePart_StripsRevisionAndClampsBuild for the
    helper itself, including the 2-part-input edge.

This ships in v0.1.12 (commit goes on top of b33e4d9, both
untagged). Affects every v0.1.8+ install today — the banner has
been showing TooOld whenever the user is 1 or 2 releases behind.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: VortexUK

src/Core/UpdateChecker.cs

@@ -284,9 +284,18 @@ private static (string Url, string Sha256Hex) FindDllAsset(string releaseBlock)
         /// </summary>
         public static UpdateCheckResult Compute(Version currentVersion, IList<Version> releasedVersions)
         {
+            // Normalise the caller's current version to 3-part so
+            // Version.Equals matches against the 3-part tag-parsed
+            // released-version list. See GetCurrentAssemblyVersion
+            // for the full reasoning — defensive double-application
+            // here so this function is correct in isolation too.
+            var normalizedCurrent = currentVersion == null
+                ? new Version(0, 0, 0)
+                : NormalizeToThreePart(currentVersion);
+
             var result = new UpdateCheckResult
             {
-                CurrentVersion = currentVersion?.ToString(3) ?? "",
+                CurrentVersion = normalizedCurrent.ToString(3),
             };
 
             if (releasedVersions == null || releasedVersions.Count == 0)
@@ -297,9 +306,11 @@ public static UpdateCheckResult Compute(Version currentVersion, IList<Version> r
 
             // Sort descending so [0] is the newest, regardless of what
             // the caller passed in. GitHub already returns newest-first
-            // but we don't rely on that here.
+            // but we don't rely on that here. Normalise each entry too
+            // in case a caller mixes shapes.
             var sorted = releasedVersions
                 .Where(v => v != null)
+                .Select(NormalizeToThreePart)
                 .Distinct()
                 .OrderByDescending(v => v)
                 .ToList();
@@ -321,7 +332,7 @@ public static UpdateCheckResult Compute(Version currentVersion, IList<Version> r
                 return result;
             }
 
-            int cmp = currentVersion.CompareTo(latest);
+            int cmp = normalizedCurrent.CompareTo(latest);
             if (cmp > 0)
             {
                 result.Status = UpdateStatus.DevBuild;
@@ -337,8 +348,10 @@ public static UpdateCheckResult Compute(Version currentVersion, IList<Version> r
             // Tolerant: SlightlyStale means within the top (Threshold+1)
             // released versions — so threshold=2 covers latest + the two
             // before it, which together are "current or within 2 back".
+            // IndexOf uses Version.Equals which compares ALL components,
+            // hence the normalisation on both sides above.
             int allowedRecent = StaleThresholdVersions + 1;
-            int idxInRecent = sorted.Take(allowedRecent).ToList().IndexOf(currentVersion);
+            int idxInRecent = sorted.Take(allowedRecent).ToList().IndexOf(normalizedCurrent);
             result.Status = idxInRecent >= 0 ? UpdateStatus.SlightlyStale : UpdateStatus.TooOld;
             return result;
         }
@@ -386,11 +399,36 @@ public static async Task<UpdateCheckResult> CheckAsync(Version currentVersion, I
         /// Pulls the assembly's runtime version. Centralised so the
         /// SettingsPanel pill and the User-Agent and the UploadClient
         /// gate all agree on what "current" means.
+        ///
+        /// Normalised to a 3-part Version (Major.Minor.Build) on the
+        /// way out. The raw Assembly.GetName().Version is always
+        /// 4-part with Revision=0, but TryParseTag emits 3-part
+        /// (Revision=-1, the "unset" sentinel) from "v0.1.10"-style
+        /// tags. Version.Equals compares all four components, so
+        /// without normalisation the staleness IndexOf check inside
+        /// Compute would never match a 4-part current version
+        /// against a 3-part released-version list — and a user one
+        /// release behind would see TooOld instead of SlightlyStale.
         /// </summary>
         public static Version GetCurrentAssemblyVersion()
         {
             var asm = typeof(UpdateChecker).Assembly;
-            return asm.GetName().Version ?? new Version(0, 0, 0);
+            var raw = asm.GetName().Version ?? new Version(0, 0, 0);
+            return NormalizeToThreePart(raw);
+        }
+
+        /// <summary>
+        /// Strip the Revision component so a Version compares cleanly
+        /// against tag-parsed Versions. <c>Version.Build</c> can be -1
+        /// (unset) on a 2-part input; we clamp to 0.
+        /// </summary>
+        internal static Version NormalizeToThreePart(Version v)
+        {
+            if (v == null) return new Version(0, 0, 0);
+            return new Version(
+                v.Major < 0 ? 0 : v.Major,
+                v.Minor < 0 ? 0 : v.Minor,
+                v.Build < 0 ? 0 : v.Build);
         }
     }
 }

tests/EQ2Lexicon.ACTPlugin.Tests/UpdateCheckerTests.cs

@@ -131,6 +131,55 @@ public void Compute_Unknown_WhenFeedIsEmpty()
             Assert.False(result.UploadBlocked);
         }
 
+        [Fact]
+        public void Compute_FourPartCurrentVersionStillMatchesThreePartReleased()
+        {
+            // Regression test for the v0.1.10-shows-as-TooOld bug.
+            //
+            // Real-world setup: Assembly.GetName().Version is always
+            // 4-part with Revision=0 (e.g. Version(0,1,10,0)).
+            // TryParseTag("v0.1.10") emits 3-part with Revision=-1.
+            // Version.Equals compares ALL FOUR components, so the
+            // IndexOf inside Compute would never match → fell
+            // through to TooOld even though the user was one release
+            // behind. Bug was real, screenshot at the commit message.
+            var result = UpdateChecker.Compute(
+                new Version(0, 1, 10, 0),  // 4-part — exactly what Assembly.GetName().Version returns
+                new[]
+                {
+                    new Version(0, 1, 11),  // 3-part — exactly what TryParseTag returns
+                    new Version(0, 1, 10),
+                    new Version(0, 1, 9),
+                });
+            Assert.Equal(UpdateStatus.SlightlyStale, result.Status);
+            Assert.False(result.UploadBlocked);
+        }
+
+        [Fact]
+        public void Compute_FourPartCurrentEqualsThreePartLatest_IsCurrentNotDevBuild()
+        {
+            // Same shape bug from a different angle: when current is
+            // 4-part Version(0,1,11,0) and latest is 3-part Version(0,1,11),
+            // CompareTo says 0.1.11.0 > 0.1.11 (revision 0 > revision -1)
+            // which would (without normalisation) misclassify a fully
+            // up-to-date install as DevBuild.
+            var result = UpdateChecker.Compute(
+                new Version(0, 1, 11, 0),
+                new[] { new Version(0, 1, 11), new Version(0, 1, 10) });
+            Assert.Equal(UpdateStatus.Current, result.Status);
+        }
+
+        [Fact]
+        public void NormalizeToThreePart_StripsRevisionAndClampsBuild()
+        {
+            Assert.Equal(new Version(1, 2, 3), UpdateChecker.NormalizeToThreePart(new Version(1, 2, 3, 0)));
+            Assert.Equal(new Version(1, 2, 3), UpdateChecker.NormalizeToThreePart(new Version(1, 2, 3, 999)));
+            // 2-part input → Build is -1, must clamp to 0.
+            Assert.Equal(new Version(1, 2, 0), UpdateChecker.NormalizeToThreePart(new Version(1, 2)));
+            // Null defensiveness.
+            Assert.Equal(new Version(0, 0, 0), UpdateChecker.NormalizeToThreePart(null!));
+        }
+
         [Fact]
         public void Compute_HandlesUnsortedInput()
         {