Stamp dev builds 0.0.0-dev and suppress update notifications for them

Two related fixes:

1. Dev / from-source builds were stamping MSBuild's default 1.0.0 (no <Version> in csproj), which masqueraded as a real release version in the new Settings > Updates > Current version row. Now stamps 0.0.0-dev. CI's release workflow stamps the real tag via -p:Version=, which wins over the csproj default.

2. With 0.0.0 stamped, BrowserNotifyUpdateService.CheckAsync would otherwise compare against the latest GitHub release (e.g. v1.6.0) and tell the dev they need to update -- a false signal, because tip-of-master is by definition either at or ahead of the most recent published tag. Added a dev-build sentinel check at the top of CheckAsync: when current version is 0.0.0[.0], short-circuit to NoUpdateAvailable without hitting the network.

Added IsDevBuild helper (internal, visible to tests) so the policy lives next to the version comparison rather than scattered. Tested across Version(0,0,0) vs Version(0,0,1)/etc and the corner-case Version(0,0) where Build = -1.

Verified end-to-end locally: dotnet publish -c Release stamps ProductVersion as '0.0.0-dev+<git-hash>' (SourceLink-style hash suffix is automatic when building in a git repo; AppVersionInfo.GetDisplayVersion strips it for display so users see plain '0.0.0-dev').

Tests: 1448 passing (+8 from IsDevBuild theories + the zero-version short-circuit test), 1 skipped. 0 warnings, 0 errors in dotnet build -c Release. CHANGELOG [Unreleased] documents both changes.

AI-Local-Session: 4519f6b6-393a-4476-8efa-410e5396c3a9

AI-Cloud-Session: 72f9e474-60ab-42c2-b2a0-28fee827cbbb

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Geeven Singh

CHANGELOG.md

@@ -20,6 +20,19 @@ body. Keep section headings exact and write notes in Markdown.
   for prereleases), so users can answer "what version am I on?"
   alongside the auto-update settings without leaving the dialog.
 
+### Changed
+
+- **Dev / from-source builds now stamp `0.0.0-dev` as the version**
+  instead of MSBuild's misleading default of `1.0.0`. CI release
+  builds are unaffected — the workflow's `-p:Version=$tag` still
+  wins. Local `dotnet publish` builds now identify themselves
+  honestly in the new Settings → Updates → Current version row.
+- **Dev builds no longer trigger update notifications.** When the
+  current version is `0.0.0`, the update check short-circuits
+  without hitting the GitHub Releases API, so a developer running
+  `dotnet run` against tip-of-master doesn't get a false
+  "update available" banner every launch.
+
 ## [1.6.0] - 2026-05-31
 
 ### Added

DiffViewer.Tests/Services/BrowserNotifyUpdateServiceTests.cs

@@ -233,6 +233,48 @@ public void TryParseVersion_StripsTagPrefixAndSemVerSuffixes(string input, strin
         BrowserNotifyUpdateService.TryParseVersion(input)!.ToString().Should().Be(expected);
     }
 
+    [Theory]
+    [InlineData(0, 0, 0, true)]
+    [InlineData(0, 0, 1, false)]
+    [InlineData(0, 1, 0, false)]
+    [InlineData(1, 0, 0, false)]
+    [InlineData(1, 6, 0, false)]
+    public void IsDevBuild_Identifies_ZeroVersion(int major, int minor, int build, bool expected)
+    {
+        BrowserNotifyUpdateService.IsDevBuild(new Version(major, minor, build))
+            .Should().Be(expected);
+    }
+
+    [Fact]
+    public void IsDevBuild_Handles_TwoComponentVersion()
+    {
+        // System.Version with only Major.Minor gives Build = -1.
+        // The dev-marker check must accept that as "also dev" so
+        // a hypothetical Version(0, 0) sentinel still short-circuits.
+        BrowserNotifyUpdateService.IsDevBuild(new Version(0, 0))
+            .Should().BeTrue();
+    }
+
+    [Fact]
+    public async Task CheckAsync_WhenCurrentVersionIs0_0_0_ReturnsNoUpdateWithoutHittingNetwork()
+    {
+        // Dev builds (csproj defaults Version to 0.0.0-dev). The
+        // service must short-circuit before any HTTP call so
+        // developers running `dotnet run` don't get a false
+        // "update available" banner every launch.
+        var handler = new FakeHttpHandler(new[]
+        {
+            ReleasesJson(new GhRelease("v1.6.0", "https://example/v160", Draft: false, Prerelease: false)),
+        });
+        using var http = new HttpClient(handler);
+        var sut = new BrowserNotifyUpdateService(http, new Version(0, 0, 0), includePreReleases: false);
+
+        var result = await sut.CheckAsync(CancellationToken.None);
+
+        result.Should().BeSameAs(UpdateCheckResult.NoUpdateAvailable);
+        handler.SendCount.Should().Be(0);
+    }
+
     [Theory]
     [InlineData("notaversion")]
     [InlineData("")]
@@ -288,13 +330,16 @@ private sealed class FakeHttpHandler : HttpMessageHandler
     {
         private readonly Queue<FakeResponse> _responses;
 
+        public int SendCount { get; private set; }
+
         public FakeHttpHandler(IEnumerable<FakeResponse> responses)
         {
             _responses = new Queue<FakeResponse>(responses);
         }
 
         protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
         {
+            SendCount++;
             if (_responses.Count == 0)
             {
                 // Simulate a network outage for tests that want it.

DiffViewer/DiffViewer.csproj

@@ -9,6 +9,18 @@
     <LangVersion>latest</LangVersion>
     <RootNamespace>DiffViewer</RootNamespace>
     <AssemblyName>DiffViewer</AssemblyName>
+
+    <!-- Dev / from-source builds stamp 0.0.0-dev so the running
+         version is unambiguously "not a real release". CI's release
+         workflow passes -p:Version=$tag which overrides this at
+         release time. The update services treat 0.0.0 as a dev
+         marker and skip the GitHub / Velopack check entirely, so
+         developers don't see a false "update available" banner on
+         every dotnet run. -->
+    <Version>0.0.0-dev</Version>
+    <FileVersion>0.0.0.0</FileVersion>
+    <InformationalVersion>0.0.0-dev</InformationalVersion>
+
     <ApplicationIcon>Assets\diffviewer.ico</ApplicationIcon>
 
     <!-- Velopack requires a hook (VelopackApp.Build().Run()) that

DiffViewer/Services/BrowserNotifyUpdateService.cs

@@ -63,6 +63,18 @@ public BrowserNotifyUpdateService(
 
     public async Task<UpdateCheckResult> CheckAsync(CancellationToken ct)
     {
+        // Dev builds (csproj defaults to 0.0.0-dev when no Version is
+        // stamped) short-circuit the check. A developer on tip-of-master
+        // is by definition either at or ahead of the most recent
+        // published release, so a banner saying "update available" would
+        // be misleading. CI's release workflow stamps a real version
+        // via -p:Version=$tag, so this only affects developer machines
+        // and bespoke from-source builds.
+        if (IsDevBuild(_currentVersion))
+        {
+            return UpdateCheckResult.NoUpdateAvailable;
+        }
+
         try
         {
             using var req = new HttpRequestMessage(HttpMethod.Get, GitHubApiUrl + "?per_page=10");
@@ -162,6 +174,19 @@ private static void OpenUrlInDefaultBrowser(string url)
         return Version.TryParse(trimmed, out var v) ? v : null;
     }
 
+    /// <summary>
+    /// True when <paramref name="version"/> is the 0.0.0[.0] sentinel
+    /// stamped on dev / from-source builds by
+    /// <c>DiffViewer.csproj</c>'s default <c>&lt;Version&gt;</c>.
+    /// Major == Minor == Build == 0 is sufficient; Revision varies
+    /// by stamping path (AssemblyVersion gives 0.0.0.0; the
+    /// informational-version Version.Parse path gives 0.0.0). A
+    /// genuinely-released v0.0.0 would also match, but DiffViewer
+    /// will never tag one, so the trade-off is acceptable.
+    /// </summary>
+    internal static bool IsDevBuild(Version version) =>
+        version.Major == 0 && version.Minor == 0 && version.Build <= 0;
+
     private static readonly JsonSerializerOptions SerializerOptions = new()
     {
         PropertyNameCaseInsensitive = true,