From 37cacfda99a104740f14f67c061234e9ea5171d8 Mon Sep 17 00:00:00 2001
From: undead2146 <mustafa2146@live.be>
Date: Tue, 16 Dec 2025 23:18:27 +0100
Subject: [PATCH] temp

---
 .github/workflows/ci.yml                      | 267 +++++-
 GenHub/Directory.Build.props                  |  44 +-
 GenHub/GenHub.Core/Constants/AppConstants.cs  |  76 +-
 .../Constants/BuildInfoConstants.cs           |  42 +
 .../GenHub.Core/Constants/GitHubConstants.cs  |   3 +
 .../Models/AppUpdate/ArtifactUpdateInfo.cs    |  86 ++
 .../Models/AppUpdate/PullRequestInfo.cs       |  57 ++
 .../GenHub.Core/Models/Common/UserSettings.cs |  18 +
 .../GenHub.Core/Models/Enums/UpdateChannel.cs |  22 +
 .../Constants/AppConstantsTests.cs            |   8 +-
 .../Services/VelopackUpdateManagerTests.cs    |  71 +-
 .../UpdateNotificationViewModelTests.cs       |  19 +-
 .../GameProfiles/GameProcessManagerTests.cs   | 132 ---
 .../GameProfileModuleTests.cs                 |   3 +
 .../SharedViewModelModuleTests.cs             |  14 +-
 .../GenHub/Common/ViewModels/MainViewModel.cs |  35 +-
 GenHub/GenHub/Common/Views/MainView.axaml     |  24 +-
 .../Interfaces/IVelopackUpdateManager.cs      |  57 +-
 .../AppUpdate/Services/SimpleHttpServer.cs    | 206 ++++
 .../Services/VelopackUpdateManager.cs         | 907 +++++++++++++++---
 .../ViewModels/UpdateNotificationViewModel.cs | 339 ++++++-
 .../Views/UpdateNotificationView.axaml        | 328 ++++---
 .../Views/UpdateNotificationWindow.axaml      |  24 +-
 .../ViewModels/GitHubTokenDialogViewModel.cs  | 239 +++++
 .../GitHub/Views/GitHubTokenDialogView.axaml  | 170 ++++
 .../Views/GitHubTokenDialogView.axaml.cs      |  44 +
 .../Settings/ViewModels/SettingsViewModel.cs  | 304 +++++-
 .../Settings/Views/SettingsView.axaml         | 132 ++-
 .../Settings/Views/SettingsView.axaml.cs      |  34 +
 docs/velopack-integration.md                  | 401 +++++---
 30 files changed, 3465 insertions(+), 641 deletions(-)
 create mode 100644 GenHub/GenHub.Core/Constants/BuildInfoConstants.cs
 create mode 100644 GenHub/GenHub.Core/Models/AppUpdate/ArtifactUpdateInfo.cs
 create mode 100644 GenHub/GenHub.Core/Models/AppUpdate/PullRequestInfo.cs
 create mode 100644 GenHub/GenHub.Core/Models/Enums/UpdateChannel.cs
 create mode 100644 GenHub/GenHub/Features/AppUpdate/Services/SimpleHttpServer.cs
 create mode 100644 GenHub/GenHub/Features/GitHub/ViewModels/GitHubTokenDialogViewModel.cs
 create mode 100644 GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml
 create mode 100644 GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml.cs

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a2c1735c4..618eb1e71 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -23,7 +23,7 @@ env:
   WINDOWS_PROJECT: 'GenHub/GenHub.Windows/GenHub.Windows.csproj'
   LINUX_PROJECT: 'GenHub/GenHub.Linux/GenHub.Linux.csproj'
   TEST_PROJECTS: 'GenHub/GenHub.Tests/**/*.csproj'
-  
+
 jobs:
   detect-changes:
     name: Detect File Changes
@@ -75,16 +75,16 @@ jobs:
     needs: detect-changes
     if: ${{ github.event_name == 'workflow_dispatch' || needs.detect-changes.outputs.any == 'true' || needs.detect-changes.outputs.core == 'true' || needs.detect-changes.outputs.ui == 'true' || needs.detect-changes.outputs.windows == 'true' }}
     runs-on: windows-latest
-    
+
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
-        
+
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
           dotnet-version: ${{ env.DOTNET_VERSION }}
-          
+
       - name: Cache NuGet Packages
         uses: actions/cache@v3
         with:
@@ -92,30 +92,95 @@ jobs:
           key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }}
           restore-keys: |
             ${{ runner.os }}-nuget-
-      
+
+      - name: Extract Build Info
+        id: buildinfo
+        shell: pwsh
+        run: |
+          $shortHash = "${{ github.sha }}".Substring(0, 7)
+          $prNumber = "${{ github.event.pull_request.number }}"
+          $runNumber = "${{ github.run_number }}"
+
+          # Velopack requires SemVer2 3-part version (MAJOR.MINOR.PATCH)
+          # Using 0.0.X format to indicate alpha/pre-release status
+          if ($prNumber) {
+            $version = "0.0.$runNumber-pr$prNumber"
+            $channel = "PR"
+          } else {
+            $version = "0.0.$runNumber"
+            $channel = "CI"
+          }
+
+          Write-Host "Build Info:"
+          Write-Host "  Short Hash: $shortHash"
+          Write-Host "  PR Number: $prNumber"
+          Write-Host "  Run Number: $runNumber"
+          Write-Host "  Version: $version (SemVer2 for Velopack)"
+          Write-Host "  Channel: $channel"
+
+          echo "SHORT_HASH=$shortHash" >> $env:GITHUB_OUTPUT
+          echo "PR_NUMBER=$prNumber" >> $env:GITHUB_OUTPUT
+          echo "VERSION=$version" >> $env:GITHUB_OUTPUT
+          echo "CHANNEL=$channel" >> $env:GITHUB_OUTPUT
+
       - name: Build Projects
         shell: pwsh
         run: |
-          # Build projects in the correct order (core dependencies first)
-          Write-Host "Building Core project"
-          dotnet build "${{ env.CORE_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }}
-          
-          Write-Host "Building UI project"  
-          dotnet build "${{ env.UI_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }}
-          
+          $buildProps = @(
+            "-p:Version=${{ steps.buildinfo.outputs.VERSION }}"
+            "-p:GitShortHash=${{ steps.buildinfo.outputs.SHORT_HASH }}"
+            "-p:PullRequestNumber=${{ steps.buildinfo.outputs.PR_NUMBER }}"
+            "-p:BuildChannel=${{ steps.buildinfo.outputs.CHANNEL }}"
+          )
+
+          Write-Host "Building Core project with build info"
+          dotnet build "${{ env.CORE_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }} @buildProps
+
+          Write-Host "Building UI project"
+          dotnet build "${{ env.UI_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }} @buildProps
+
           Write-Host "Building Windows project"
-          dotnet build "${{ env.WINDOWS_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }}
-      
+          dotnet build "${{ env.WINDOWS_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }} @buildProps
+
       - name: Publish Windows App
         shell: pwsh
         run: |
+          $buildProps = @(
+            "-p:Version=${{ steps.buildinfo.outputs.VERSION }}"
+            "-p:GitShortHash=${{ steps.buildinfo.outputs.SHORT_HASH }}"
+            "-p:PullRequestNumber=${{ steps.buildinfo.outputs.PR_NUMBER }}"
+            "-p:BuildChannel=${{ steps.buildinfo.outputs.CHANNEL }}"
+          )
+
           Write-Host "Publishing Windows application"
+          Write-Host "Version: ${{ steps.buildinfo.outputs.VERSION }}"
           dotnet publish "${{ env.WINDOWS_PROJECT }}" `
             -c ${{ env.BUILD_CONFIGURATION }} `
             -r win-x64 `
             --self-contained true `
-            -o "win-publish"
-      
+            -o "win-publish" `
+            @buildProps
+
+      - name: Install Velopack CLI
+        run: dotnet tool install -g vpk
+
+      - name: Create Velopack Package
+        shell: pwsh
+        run: |
+          Write-Host "Creating Velopack package..."
+          vpk pack `
+            --packId GenHub `
+            --packVersion ${{ steps.buildinfo.outputs.VERSION }} `
+            --packDir win-publish `
+            --mainExe GenHub.Windows.exe `
+            --packTitle "GenHub" `
+            --packAuthors "Community Outpost" `
+            --icon GenHub/GenHub/Assets/Icons/generalshub.ico `
+            --outputDir velopack-release
+
+          Write-Host "Velopack artifacts created:"
+          Get-ChildItem -Path "velopack-release" -Recurse | Select-Object Name, Length
+
       - name: Run Tests
         id: tests
         shell: pwsh
@@ -133,33 +198,51 @@ jobs:
           } else {
             Write-Host "No test projects found."
           }
-      - name: Upload Windows Artifact
+
+      - name: Upload Velopack Update Package (.nupkg)
+        uses: actions/upload-artifact@v4
+        with:
+          name: genhub-velopack-windows-${{ steps.buildinfo.outputs.VERSION }}
+          path: velopack-release/*.nupkg
+          if-no-files-found: error
+          retention-days: 30
+
+      - name: Upload Velopack Setup Installer
         uses: actions/upload-artifact@v4
         with:
-          name: genhub-windows
-          path: win-publish
+          name: genhub-setup-windows-${{ steps.buildinfo.outputs.VERSION }}
+          path: velopack-release/*-Setup.exe
           if-no-files-found: error
-          
+          retention-days: 30
+
+      - name: Upload Velopack Metadata
+        uses: actions/upload-artifact@v4
+        with:
+          name: genhub-metadata-windows-${{ steps.buildinfo.outputs.VERSION }}
+          path: velopack-release/RELEASES
+          if-no-files-found: error
+          retention-days: 30
+
   build-linux:
     name: Build Linux
     needs: detect-changes
     if: ${{ github.event_name == 'workflow_dispatch' || needs.detect-changes.outputs.any == 'true' || needs.detect-changes.outputs.core == 'true' || needs.detect-changes.outputs.ui == 'true' || needs.detect-changes.outputs.linux == 'true' }}
     runs-on: ubuntu-latest
-    
+
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
-        
+
       - name: Setup .NET
         uses: actions/setup-dotnet@v4
         with:
           dotnet-version: ${{ env.DOTNET_VERSION }}
-          
+
       - name: Install Linux Dependencies
         run: |
           sudo apt-get update
           sudo apt-get install -y libgtk-3-dev libx11-dev
-          
+
       - name: Cache NuGet Packages
         uses: actions/cache@v3
         with:
@@ -167,28 +250,79 @@ jobs:
           key: ${{ runner.os }}-nuget-${{ hashFiles('**/*.csproj') }}
           restore-keys: |
             ${{ runner.os }}-nuget-
-      
+
+      - name: Extract Build Info
+        id: buildinfo
+        run: |
+          SHORT_HASH=$(echo "${{ github.sha }}" | cut -c1-7)
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+          RUN_NUMBER="${{ github.run_number }}"
+
+          # Velopack requires SemVer2 3-part version (MAJOR.MINOR.PATCH)
+          # Using 0.0.X format to indicate alpha/pre-release status
+          if [ -n "$PR_NUMBER" ]; then
+            VERSION="0.0.${RUN_NUMBER}-pr${PR_NUMBER}"
+            CHANNEL="PR"
+          else
+            VERSION="0.0.${RUN_NUMBER}"
+            CHANNEL="CI"
+          fi
+
+          echo "Build Info:"
+          echo "  Short Hash: $SHORT_HASH"
+          echo "  PR Number: $PR_NUMBER"
+          echo "  Run Number: $RUN_NUMBER"
+          echo "  Version: $VERSION (SemVer2 for Velopack)"
+          echo "  Channel: $CHANNEL"
+
+          echo "SHORT_HASH=$SHORT_HASH" >> $GITHUB_OUTPUT
+          echo "PR_NUMBER=$PR_NUMBER" >> $GITHUB_OUTPUT
+          echo "VERSION=$VERSION" >> $GITHUB_OUTPUT
+
       - name: Build Projects
         run: |
-          # Build projects, which will also restore dependencies
-          echo "Building Core project"
-          dotnet build "${{ env.CORE_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }}
-          
+          BUILD_PROPS="-p:Version=${{ steps.buildinfo.outputs.VERSION }} -p:GitShortHash=${{ steps.buildinfo.outputs.SHORT_HASH }} -p:PullRequestNumber=${{ steps.buildinfo.outputs.PR_NUMBER }} -p:BuildChannel=${{ steps.buildinfo.outputs.CHANNEL }}"
+
+          echo "Building Core project with build info"
+          dotnet build "${{ env.CORE_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }} $BUILD_PROPS
+
           echo "Building UI project"
-          dotnet build "${{ env.UI_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }}
-          
-          echo "Building Linux project"  
-          dotnet build "${{ env.LINUX_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }}
-      
+          dotnet build "${{ env.UI_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }} $BUILD_PROPS
+
+          echo "Building Linux project"
+          dotnet build "${{ env.LINUX_PROJECT }}" -c ${{ env.BUILD_CONFIGURATION }} $BUILD_PROPS
+
       - name: Publish Linux App
         run: |
+          BUILD_PROPS="-p:Version=${{ steps.buildinfo.outputs.VERSION }} -p:GitShortHash=${{ steps.buildinfo.outputs.SHORT_HASH }} -p:PullRequestNumber=${{ steps.buildinfo.outputs.PR_NUMBER }} -p:BuildChannel=${{ steps.buildinfo.outputs.CHANNEL }}"
+
           echo "Publishing Linux application"
           dotnet publish "${{ env.LINUX_PROJECT }}" \
             -c ${{ env.BUILD_CONFIGURATION }} \
             -r linux-x64 \
             --self-contained true \
-            -o "linux-publish"
-      
+            -o "linux-publish" \
+            $BUILD_PROPS
+
+      - name: Install Velopack CLI
+        run: dotnet tool install -g vpk
+
+      - name: Create Velopack Package
+        run: |
+          echo "Creating Velopack package..."
+          vpk pack \
+            --packId GenHub \
+            --packVersion ${{ steps.buildinfo.outputs.VERSION }} \
+            --packDir linux-publish \
+            --mainExe GenHub.Linux \
+            --packTitle "GenHub" \
+            --packAuthors "Community Outpost" \
+            --icon GenHub/GenHub/Assets/Icons/generalshub-icon.png \
+            --outputDir velopack-release
+
+          echo "Velopack artifacts created:"
+          ls -lh velopack-release/
+
       - name: Run Tests
         run: |
           shopt -s globstar nullglob
@@ -197,17 +331,67 @@ jobs:
             echo "Testing $test_project"
             dotnet test "$test_project" -c ${{ env.BUILD_CONFIGURATION }} --verbosity normal
           done
-        
-      - name: Upload Linux Artifact
+
+      - name: Upload Velopack Update Package (.nupkg)
+        uses: actions/upload-artifact@v4
+        with:
+          name: genhub-velopack-linux-${{ steps.buildinfo.outputs.VERSION }}
+          path: velopack-release/*.nupkg
+          if-no-files-found: error
+          retention-days: 30
+
+      - name: Upload Velopack Metadata
         uses: actions/upload-artifact@v4
         with:
-          name: genhub-linux
-          path: linux-publish
+          name: genhub-metadata-linux-${{ steps.buildinfo.outputs.VERSION }}
+          path: velopack-release/releases.*.json
           if-no-files-found: error
+          retention-days: 30
+
+  release:
+    name: Create Release
+    needs: [build-windows, build-linux]
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Download Windows Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: genhub-velopack-windows-*
+          merge-multiple: true
+          path: release-assets/windows
+
+      - name: Download Linux Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: genhub-velopack-linux-*
+          merge-multiple: true
+          path: release-assets/linux
+
+      - name: Prepare Release Assets
+        run: |
+          mkdir final-assets
+          cp release-assets/windows/*.nupkg final-assets/
+          cp release-assets/linux/*.nupkg final-assets/ || true
+          # Prioritize Windows RELEASES file for now
+          cp release-assets/windows/RELEASES final-assets/RELEASES || true
+          # Include Setup.exe for easy first-time installation (Velopack names it GenHub-win-Setup.exe)
+          cp release-assets/windows/*-Setup.exe final-assets/ || true
+
+      - name: Create Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v0.0.${{ github.run_number }}
+          name: GenHub Alpha ${{ github.run_number }}
+          prerelease: true
+          draft: false
+          files: final-assets/*
 
   summary:
     name: Build Summary
-    needs: [build-windows, build-linux]
+    needs: [build-windows, build-linux, release]
     if: always()
     runs-on: ubuntu-latest
     steps:
@@ -221,3 +405,4 @@ jobs:
           echo "| --- | --- |" >> $GITHUB_STEP_SUMMARY
           echo "| Windows | ${{ needs.build-windows.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
           echo "| Linux | ${{ needs.build-linux.result == 'success' && '✅ Passed' || '❌ Failed' }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| Release | ${{ needs.release.result == 'success' && '✅ Created' || 'skipped' }} |" >> $GITHUB_STEP_SUMMARY
diff --git a/GenHub/Directory.Build.props b/GenHub/Directory.Build.props
index 5ec53303c..12858a91b 100644
--- a/GenHub/Directory.Build.props
+++ b/GenHub/Directory.Build.props
@@ -1,14 +1,44 @@
 <Project>
   <PropertyGroup>
-    <!-- 
-      Change this to update version everywhere
-      Format: Major.Minor.Patch[-prerelease] (e.g., 1.0.0-alpha.1)
+    <!--
+      Alpha versioning: 0.0.X format
+      CI will override with: 0.0.{runNumber} or 0.0.{runNumber}-pr{prNumber}
     -->
-    <Version>1.0.0-alpha.1</Version>
-    <AssemblyVersion>1.0.0.0</AssemblyVersion>
-    <FileVersion>1.0.0.0</FileVersion>
-    
+    <Version>0.0.1</Version>
+    <AssemblyVersion>0.0.1.0</AssemblyVersion>
+    <FileVersion>0.0.1.0</FileVersion>
+
     <!-- Make version available to source generators / build-time code -->
     <GenerateAssemblyInfo>true</GenerateAssemblyInfo>
+
+    <!--
+      Build info for CI - these are overridden by CI workflow via MSBuild properties:
+      dotnet build -p:GitShortHash=abc1234 -p:PullRequestNumber=42 -p:BuildChannel=PR
+    -->
+    <GitShortHash></GitShortHash>
+    <PullRequestNumber></PullRequestNumber>
+    <BuildChannel>Dev</BuildChannel>
+
+    <!--
+      Include git hash in InformationalVersion for display
+      Results in: "0.0.150+abc1234" for CI builds
+    -->
+    <InformationalVersion Condition="'$(GitShortHash)' != ''">$(Version)+$(GitShortHash)</InformationalVersion>
   </PropertyGroup>
+
+  <!-- Embed build metadata in assembly for runtime access -->
+  <ItemGroup>
+    <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+      <_Parameter1>GitShortHash</_Parameter1>
+      <_Parameter2>$(GitShortHash)</_Parameter2>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+      <_Parameter1>PullRequestNumber</_Parameter1>
+      <_Parameter2>$(PullRequestNumber)</_Parameter2>
+    </AssemblyAttribute>
+    <AssemblyAttribute Include="System.Reflection.AssemblyMetadataAttribute">
+      <_Parameter1>BuildChannel</_Parameter1>
+      <_Parameter2>$(BuildChannel)</_Parameter2>
+    </AssemblyAttribute>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/GenHub/GenHub.Core/Constants/AppConstants.cs b/GenHub/GenHub.Core/Constants/AppConstants.cs
index 6f569e1cf..eeb2dcacc 100644
--- a/GenHub/GenHub.Core/Constants/AppConstants.cs
+++ b/GenHub/GenHub.Core/Constants/AppConstants.cs
@@ -1,5 +1,5 @@
-using GenHub.Core.Models.Enums;
 using System.Reflection;
+using GenHub.Core.Models.Enums;
 
 namespace GenHub.Core.Constants;
 
@@ -13,7 +13,7 @@ public static class AppConstants
     /// </summary>
     public const string AppName = "GenHub";
 
-    private static readonly Lazy<string> _appVersion = new Lazy<string>(() =>
+    private static readonly Lazy<string> _appVersion = new(() =>
     {
         var assembly = Assembly.GetExecutingAssembly();
         return assembly
@@ -23,11 +23,20 @@ public static class AppConstants
         ?? "0.0.0-dev";
     });
 
+    private static readonly Lazy<string> _gitShortHash = new(() =>
+        GetAssemblyMetadata("GitShortHash") ?? string.Empty);
+
+    private static readonly Lazy<string> _pullRequestNumber = new(() =>
+        GetAssemblyMetadata("PullRequestNumber") ?? string.Empty);
+
+    private static readonly Lazy<string> _buildChannel = new(() =>
+        GetAssemblyMetadata("BuildChannel") ?? "Dev");
+
     /// <summary>
     /// Gets the full semantic version of the application.
     /// This value is automatically extracted from assembly metadata at runtime.
     /// To change version: Update &lt;Version&gt; in GenHub/Directory.Build.props.
-    /// Format: Major.Minor.Patch[-prerelease] (e.g., "1.0.0-alpha.1").
+    /// Format: 0.0.X[-prY] (e.g., "0.0.150" or "0.0.150-pr42").
     /// </summary>
     public static string AppVersion => _appVersion.Value;
 
@@ -36,10 +45,57 @@ public static class AppConstants
     /// </summary>
     public static string DisplayVersion => $"v{AppVersion}";
 
+    /// <summary>
+    /// Gets the short git commit hash (7 chars) for this build, or empty for local builds.
+    /// </summary>
+    public static string GitShortHash => _gitShortHash.Value;
+
+    /// <summary>
+    /// Gets the PR number if this is a PR build, or empty for other builds.
+    /// </summary>
+    public static string PullRequestNumber => _pullRequestNumber.Value;
+
+    /// <summary>
+    /// Gets the build channel (Dev, PR, CI, Release).
+    /// </summary>
+    public static string BuildChannel => _buildChannel.Value;
+
+    /// <summary>
+    /// Gets a value indicating whether this is a CI/CD build (has git hash embedded).
+    /// </summary>
+    public static bool IsCiBuild => !string.IsNullOrEmpty(GitShortHash);
+
+    /// <summary>
+    /// Gets the full display version including hash for dev builds.
+    /// Format examples:
+    /// Local: "v0.0.1".
+    /// CI: "v0.0.150 (abc1234)".
+    /// PR: "v0.0.150-pr42 PR#42 (abc1234)".
+    /// </summary>
+    public static string FullDisplayVersion
+    {
+        get
+        {
+            var version = DisplayVersion;
+
+            if (string.IsNullOrEmpty(GitShortHash))
+            {
+                return version;
+            }
+
+            if (!string.IsNullOrEmpty(PullRequestNumber))
+            {
+                return $"{version} PR#{PullRequestNumber} ({GitShortHash})";
+            }
+
+            return $"{version} ({GitShortHash})";
+        }
+    }
+
     /// <summary>
     /// The GitHub repository URL for the application.
     /// </summary>
-    public const string GitHubRepositoryUrl = "https://github.com/community-outpost/genhub";
+    public const string GitHubRepositoryUrl = "https://github.com/" + GitHubRepositoryOwner + "/" + GitHubRepositoryName;
 
     /// <summary>
     /// The GitHub repository owner.
@@ -65,4 +121,16 @@ public static class AppConstants
     /// The default GitHub token file name.
     /// </summary>
     public const string TokenFileName = ".ghtoken";
+
+    /// <summary>
+    /// Gets assembly metadata by key.
+    /// </summary>
+    private static string? GetAssemblyMetadata(string key)
+    {
+        var assembly = Assembly.GetExecutingAssembly();
+        return assembly
+            .GetCustomAttributes<AssemblyMetadataAttribute>()
+            .FirstOrDefault(a => a.Key == key)
+            ?.Value;
+    }
 }
\ No newline at end of file
diff --git a/GenHub/GenHub.Core/Constants/BuildInfoConstants.cs b/GenHub/GenHub.Core/Constants/BuildInfoConstants.cs
new file mode 100644
index 000000000..a7621c060
--- /dev/null
+++ b/GenHub/GenHub.Core/Constants/BuildInfoConstants.cs
@@ -0,0 +1,42 @@
+namespace GenHub.Core.Constants;
+
+/// <summary>
+/// Build information constants populated at compile time via MSBuild.
+/// These values are set during CI builds and remain empty for local development builds.
+/// </summary>
+public static class BuildInfoConstants
+{
+    /// <summary>
+    /// Short git commit hash (7 chars). Empty for local/dev builds.
+    /// Set via MSBuild property: -p:GitShortHash=abc1234.
+    /// </summary>
+    public const string GitShortHash = "";
+
+    /// <summary>
+    /// PR number if from a PR build, otherwise empty.
+    /// Set via MSBuild property: -p:PullRequestNumber=123.
+    /// </summary>
+    public const string PullRequestNumber = "";
+
+    /// <summary>
+    /// Build channel identifier: "Release", "PR", "CI", or "Dev".
+    /// Set via MSBuild property: -p:BuildChannel=PR.
+    /// </summary>
+    public const string BuildChannel = "Dev";
+
+    /// <summary>
+    /// Gets a value indicating whether this is a CI/CD build (has git hash).
+    /// </summary>
+    public static bool IsCiBuild => !string.IsNullOrEmpty(GitShortHash);
+
+    /// <summary>
+    /// Gets a value indicating whether this is a PR build.
+    /// </summary>
+    public static bool IsPrBuild => !string.IsNullOrEmpty(PullRequestNumber);
+
+    /// <summary>
+    /// Gets the PR number as an integer, or null if not a PR build.
+    /// </summary>
+    public static int? PullRequestNumberValue =>
+        int.TryParse(PullRequestNumber, out var pr) ? pr : null;
+}
\ No newline at end of file
diff --git a/GenHub/GenHub.Core/Constants/GitHubConstants.cs b/GenHub/GenHub.Core/Constants/GitHubConstants.cs
index 54a9c85c6..c86fa1ead 100644
--- a/GenHub/GenHub.Core/Constants/GitHubConstants.cs
+++ b/GenHub/GenHub.Core/Constants/GitHubConstants.cs
@@ -277,6 +277,9 @@ public static class GitHubConstants
 
     // Descriptions
 
+    /// <summary>URL for creating a new GitHub PAT with repo scope.</summary>
+    public const string PatCreationUrl = "https://github.com/settings/tokens/new?description=GenHub&scopes=repo";
+
     /// <summary>Description text for GitHub token requirements.</summary>
     public const string GitHubTokenDescription = "Enter your GitHub Personal Access Token to access private repositories and increase rate limits:";
 
diff --git a/GenHub/GenHub.Core/Models/AppUpdate/ArtifactUpdateInfo.cs b/GenHub/GenHub.Core/Models/AppUpdate/ArtifactUpdateInfo.cs
new file mode 100644
index 000000000..864173079
--- /dev/null
+++ b/GenHub/GenHub.Core/Models/AppUpdate/ArtifactUpdateInfo.cs
@@ -0,0 +1,86 @@
+namespace GenHub.Core.Models.AppUpdate;
+
+/// <summary>
+/// Information about an available artifact update from CI builds.
+/// </summary>
+/// <param name="version">The semantic version of the artifact.</param>
+/// <param name="gitHash">The short git commit hash (7 chars).</param>
+/// <param name="pullRequestNumber">The PR number if this is a PR build, or null.</param>
+/// <param name="workflowRunId">The GitHub Actions workflow run ID.</param>
+/// <param name="workflowRunUrl">The URL to the workflow run.</param>
+/// <param name="artifactId">The artifact ID for download.</param>
+/// <param name="artifactName">The artifact name.</param>
+/// <param name="createdAt">When the artifact was created.</param>
+public record ArtifactUpdateInfo(
+    string version,
+    string gitHash,
+    int? pullRequestNumber,
+    long workflowRunId,
+    string workflowRunUrl,
+    long artifactId,
+    string artifactName,
+    DateTime createdAt)
+{
+    /// <summary>
+    /// Gets the semantic version of the artifact.
+    /// </summary>
+    public string Version { get; init; } = version;
+
+    /// <summary>
+    /// Gets the short git commit hash (7 chars).
+    /// </summary>
+    public string GitHash { get; init; } = gitHash;
+
+    /// <summary>
+    /// Gets the PR number if this is a PR build, or null.
+    /// </summary>
+    public int? PullRequestNumber { get; init; } = pullRequestNumber;
+
+    /// <summary>
+    /// Gets the GitHub Actions workflow run ID.
+    /// </summary>
+    public long WorkflowRunId { get; init; } = workflowRunId;
+
+    /// <summary>
+    /// Gets the URL to the workflow run.
+    /// </summary>
+    public string WorkflowRunUrl { get; init; } = workflowRunUrl;
+
+    /// <summary>
+    /// Gets the artifact ID for download.
+    /// </summary>
+    public long ArtifactId { get; init; } = artifactId;
+
+    /// <summary>
+    /// Gets the artifact name.
+    /// </summary>
+    public string ArtifactName { get; init; } = artifactName;
+
+    /// <summary>
+    /// Gets when the artifact was created.
+    /// </summary>
+    public DateTime CreatedAt { get; init; } = createdAt;
+
+    /// <summary>
+    /// Gets a value indicating whether this is a PR build artifact.
+    /// </summary>
+    public bool IsPrBuild => PullRequestNumber.HasValue;
+
+    /// <summary>
+    /// Gets the display version with hash.
+    /// </summary>
+    public string DisplayVersion
+    {
+        get
+        {
+            if (PullRequestNumber.HasValue)
+            {
+                // Strip any build metadata from version (everything after +)
+                var baseVersion = Version.Split('+')[0];
+                return $"v{baseVersion} ({GitHash})";
+            }
+
+            return $"v{Version} ({GitHash})";
+        }
+    }
+}
\ No newline at end of file
diff --git a/GenHub/GenHub.Core/Models/AppUpdate/PullRequestInfo.cs b/GenHub/GenHub.Core/Models/AppUpdate/PullRequestInfo.cs
new file mode 100644
index 000000000..a8d2a9693
--- /dev/null
+++ b/GenHub/GenHub.Core/Models/AppUpdate/PullRequestInfo.cs
@@ -0,0 +1,57 @@
+namespace GenHub.Core.Models.AppUpdate;
+
+/// <summary>
+/// Represents information about an open pull request with CI artifacts.
+/// </summary>
+public record PullRequestInfo
+{
+    /// <summary>
+    /// Gets the PR number (e.g., 123).
+    /// </summary>
+    public required int Number { get; init; }
+
+    /// <summary>
+    /// Gets the PR title.
+    /// </summary>
+    public required string Title { get; init; }
+
+    /// <summary>
+    /// Gets the branch name (e.g., "feature/dev-ui").
+    /// </summary>
+    public required string BranchName { get; init; }
+
+    /// <summary>
+    /// Gets the PR author's username.
+    /// </summary>
+    public required string Author { get; init; }
+
+    /// <summary>
+    /// Gets the PR state (open, closed, merged).
+    /// </summary>
+    public required string State { get; init; }
+
+    /// <summary>
+    /// Gets the date when the PR was last updated.
+    /// </summary>
+    public DateTimeOffset? UpdatedAt { get; init; }
+
+    /// <summary>
+    /// Gets the most recent artifact for this PR, if available.
+    /// </summary>
+    public ArtifactUpdateInfo? LatestArtifact { get; init; }
+
+    /// <summary>
+    /// Gets a value indicating whether this PR has CI artifacts available.
+    /// </summary>
+    public bool HasArtifacts => LatestArtifact != null;
+
+    /// <summary>
+    /// Gets the display version string for UI (e.g., "0.0.123").
+    /// </summary>
+    public string DisplayVersion => LatestArtifact?.DisplayVersion ?? $"0.0.{Number}";
+
+    /// <summary>
+    /// Gets a value indicating whether this PR is still open.
+    /// </summary>
+    public bool IsOpen => State.Equals("open", StringComparison.OrdinalIgnoreCase);
+}
\ No newline at end of file
diff --git a/GenHub/GenHub.Core/Models/Common/UserSettings.cs b/GenHub/GenHub.Core/Models/Common/UserSettings.cs
index 7e1142298..4c9b24f14 100644
--- a/GenHub/GenHub.Core/Models/Common/UserSettings.cs
+++ b/GenHub/GenHub.Core/Models/Common/UserSettings.cs
@@ -95,6 +95,21 @@ public bool IsExplicitlySet(string propertyName)
         return ExplicitlySetProperties.Contains(propertyName);
     }
 
+    /// <summary>
+    /// Gets or sets the preferred update channel.
+    /// </summary>
+    public UpdateChannel UpdateChannel { get; set; } = UpdateChannel.Prerelease;
+
+    /// <summary>
+    /// Gets or sets the subscribed PR number for update notifications.
+    /// </summary>
+    public int? SubscribedPrNumber { get; set; }
+
+    /// <summary>
+    /// Gets or sets the last dismissed update version to prevent repeated notifications.
+    /// </summary>
+    public string? DismissedUpdateVersion { get; set; }
+
     /// <summary>Creates a deep copy of the current UserSettings instance.</summary>
     /// <returns>A new UserSettings instance with all properties deeply copied.</returns>
     public object Clone()
@@ -120,6 +135,9 @@ public object Clone()
             SettingsFilePath = SettingsFilePath,
             CachePath = CachePath,
             ContentStoragePath = ContentStoragePath,
+            UpdateChannel = UpdateChannel,
+            SubscribedPrNumber = SubscribedPrNumber,
+            DismissedUpdateVersion = DismissedUpdateVersion,
             ContentDirectories = ContentDirectories != null ? new List<string>(ContentDirectories) : null,
             GitHubDiscoveryRepositories = GitHubDiscoveryRepositories != null ? new List<string>(GitHubDiscoveryRepositories) : null,
             InstalledToolAssemblyPaths = InstalledToolAssemblyPaths != null ? new List<string>(InstalledToolAssemblyPaths) : null,
diff --git a/GenHub/GenHub.Core/Models/Enums/UpdateChannel.cs b/GenHub/GenHub.Core/Models/Enums/UpdateChannel.cs
new file mode 100644
index 000000000..89dacbfba
--- /dev/null
+++ b/GenHub/GenHub.Core/Models/Enums/UpdateChannel.cs
@@ -0,0 +1,22 @@
+namespace GenHub.Core.Models.Enums;
+
+/// <summary>
+/// Defines the update channel for receiving application updates.
+/// </summary>
+public enum UpdateChannel
+{
+    /// <summary>
+    /// Stable releases only (GitHub Releases without prerelease tag).
+    /// </summary>
+    Stable,
+
+    /// <summary>
+    /// Alpha/beta/RC releases (GitHub Releases with prerelease identifiers).
+    /// </summary>
+    Prerelease,
+
+    /// <summary>
+    /// CI artifacts (requires GitHub PAT, for testers and developers).
+    /// </summary>
+    Artifacts,
+}
\ No newline at end of file
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Constants/AppConstantsTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Constants/AppConstantsTests.cs
index b26d45841..29c3fbc88 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Constants/AppConstantsTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Constants/AppConstantsTests.cs
@@ -21,10 +21,14 @@ public void AppConstants_Constants_ShouldHaveExpectedValues()
             // Application name and version
             Assert.Equal("GenHub", AppConstants.AppName);
 
-            // Version is dynamically loaded from assembly, just verify it's not empty and starts with expected prefix
+            // AppVersion should be a valid semantic version starting with 0.0 (alpha format)
             Assert.NotNull(AppConstants.AppVersion);
             Assert.NotEmpty(AppConstants.AppVersion);
-            Assert.StartsWith("1.", AppConstants.AppVersion);
+            Assert.StartsWith("0.0", AppConstants.AppVersion);
+
+            // DisplayVersion should have 'v' prefix
+            Assert.NotNull(AppConstants.DisplayVersion);
+            Assert.StartsWith("v0.0", AppConstants.DisplayVersion);
 
             // Theme constants
             Assert.Equal(Theme.Dark, AppConstants.DefaultTheme);
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/Services/VelopackUpdateManagerTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/Services/VelopackUpdateManagerTests.cs
index 56a9d0699..f6ca27a19 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/Services/VelopackUpdateManagerTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/Services/VelopackUpdateManagerTests.cs
@@ -1,8 +1,8 @@
-using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.GitHub;
 using GenHub.Features.AppUpdate.Services;
 using Microsoft.Extensions.Logging;
 using Moq;
-using System.Net.Http;
 
 namespace GenHub.Tests.Core.Features.AppUpdate.Services;
 
@@ -13,6 +13,8 @@ public class VelopackUpdateManagerTests
 {
     private readonly Mock<ILogger<VelopackUpdateManager>> _mockLogger;
     private readonly Mock<IHttpClientFactory> _mockHttpClientFactory;
+    private readonly Mock<IGitHubTokenStorage> _mockGitHubTokenStorage;
+    private readonly Mock<IUserSettingsService> _mockUserSettingsService;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="VelopackUpdateManagerTests"/> class.
@@ -21,9 +23,17 @@ public VelopackUpdateManagerTests()
     {
         _mockLogger = new Mock<ILogger<VelopackUpdateManager>>();
         _mockHttpClientFactory = new Mock<IHttpClientFactory>();
+        _mockGitHubTokenStorage = new Mock<IGitHubTokenStorage>();
+        _mockUserSettingsService = new Mock<IUserSettingsService>();
 
         // Use the actual interface method, not the extension method
         _mockHttpClientFactory.Setup(x => x.CreateClient(It.IsAny<string>())).Returns(new HttpClient());
+
+        // Default: no PAT token available
+        _mockGitHubTokenStorage.Setup(x => x.HasToken()).Returns(false);
+
+        // Default: return default settings
+        _mockUserSettingsService.Setup(x => x.Get()).Returns(new GenHub.Core.Models.Common.UserSettings());
     }
 
     /// <summary>
@@ -33,23 +43,13 @@ public VelopackUpdateManagerTests()
     public void Constructor_ShouldInitializeSuccessfully()
     {
         // Act
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Assert
         Assert.NotNull(manager);
         Assert.False(manager.IsUpdatePendingRestart);
     }
 
-    /// <summary>
-    /// Tests that constructor throws ArgumentNullException when logger is null.
-    /// </summary>
-    [Fact]
-    public void Constructor_WithNullLogger_ShouldThrowArgumentNullException()
-    {
-        // Act & Assert
-        Assert.Throws<ArgumentNullException>(() => new VelopackUpdateManager(null!, _mockHttpClientFactory.Object));
-    }
-
     /// <summary>
     /// Tests that CheckForUpdatesAsync returns null when running from development environment.
     /// </summary>
@@ -58,7 +58,7 @@ public void Constructor_WithNullLogger_ShouldThrowArgumentNullException()
     public async Task CheckForUpdatesAsync_InDevEnvironment_ShouldReturnNull()
     {
         // Arrange
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Act
         var result = await manager.CheckForUpdatesAsync();
@@ -75,7 +75,7 @@ public async Task CheckForUpdatesAsync_InDevEnvironment_ShouldReturnNull()
     public async Task CheckForUpdatesAsync_WithCancellation_ShouldHandleGracefully()
     {
         // Arrange
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
         var cts = new CancellationTokenSource();
         cts.Cancel();
 
@@ -94,7 +94,7 @@ public async Task CheckForUpdatesAsync_WithCancellation_ShouldHandleGracefully()
     public async Task DownloadUpdatesAsync_WhenNotInitialized_ShouldThrowInvalidOperationException()
     {
         // Arrange
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Act & Assert
         await Assert.ThrowsAsync<InvalidOperationException>(
@@ -108,7 +108,7 @@ await Assert.ThrowsAsync<InvalidOperationException>(
     public void ApplyUpdatesAndRestart_WhenNotInitialized_ShouldThrowInvalidOperationException()
     {
         // Arrange
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Act & Assert
         Assert.Throws<InvalidOperationException>(
@@ -122,7 +122,7 @@ public void ApplyUpdatesAndRestart_WhenNotInitialized_ShouldThrowInvalidOperatio
     public void ApplyUpdatesAndExit_WhenNotInitialized_ShouldThrowInvalidOperationException()
     {
         // Arrange
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Act & Assert
         Assert.Throws<InvalidOperationException>(
@@ -136,7 +136,7 @@ public void ApplyUpdatesAndExit_WhenNotInitialized_ShouldThrowInvalidOperationEx
     public void IsUpdatePendingRestart_WhenNotInitialized_ShouldReturnFalse()
     {
         // Arrange
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Act
         var isPending = manager.IsUpdatePendingRestart;
@@ -152,7 +152,7 @@ public void IsUpdatePendingRestart_WhenNotInitialized_ShouldReturnFalse()
     public void VelopackUpdateManager_ShouldUseCorrectRepositoryUrl()
     {
         // Arrange & Act
-        var manager = new VelopackUpdateManager(_mockLogger.Object, _mockHttpClientFactory.Object);
+        var manager = CreateManager();
 
         // Assert - verify that the logger was called during construction
         // In a development/test environment, the UpdateManager won't be available
@@ -162,10 +162,35 @@ public void VelopackUpdateManager_ShouldUseCorrectRepositoryUrl()
                 It.IsAny<LogLevel>(),
                 It.IsAny<EventId>(),
                 It.Is<It.IsAnyType>((v, t) =>
-                    v.ToString() !.Contains("Velopack") ||
-                    v.ToString() !.Contains("Update")),
+                    (v.ToString() ?? string.Empty).Contains("Velopack") ||
+                    (v.ToString() ?? string.Empty).Contains("Update")),
                 It.IsAny<Exception>(),
                 It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
             Times.AtLeastOnce);
     }
-}
+
+    /// <summary>
+    /// Tests that CheckForArtifactUpdatesAsync returns null when no PAT is available.
+    /// </summary>
+    /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+    [Fact]
+    public async Task CheckForArtifactUpdatesAsync_WithoutPAT_ShouldReturnNull()
+    {
+        // Arrange
+        _mockGitHubTokenStorage.Setup(x => x.HasToken()).Returns(false);
+        var manager = CreateManager();
+
+        // Act
+        var result = await manager.CheckForArtifactUpdatesAsync();
+
+        // Assert
+        Assert.Null(result);
+        Assert.False(manager.HasArtifactUpdateAvailable);
+    }
+
+    /// <summary>
+    /// Creates a new VelopackUpdateManager instance with mocked dependencies.
+    /// </summary>
+    private VelopackUpdateManager CreateManager() =>
+        new(_mockLogger.Object, _mockHttpClientFactory.Object, _mockGitHubTokenStorage.Object, _mockUserSettingsService.Object);
+}
\ No newline at end of file
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/ViewModels/UpdateNotificationViewModelTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/ViewModels/UpdateNotificationViewModelTests.cs
index 11cc6fee6..8b3043ff2 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/ViewModels/UpdateNotificationViewModelTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/AppUpdate/ViewModels/UpdateNotificationViewModelTests.cs
@@ -1,3 +1,4 @@
+using GenHub.Core.Interfaces.Common;
 using GenHub.Features.AppUpdate.Interfaces;
 using GenHub.Features.AppUpdate.ViewModels;
 using Microsoft.Extensions.Logging;
@@ -21,9 +22,13 @@ public async Task CheckForUpdatesCommand_WhenNoUpdateAvailable_UpdatesStatus()
         mockVelopack.Setup(x => x.CheckForUpdatesAsync(It.IsAny<CancellationToken>()))
            .ReturnsAsync((Velopack.UpdateInfo?)null);
 
+        var mockUserSettings = new Mock<IUserSettingsService>();
+        mockUserSettings.Setup(x => x.Get()).Returns(new GenHub.Core.Models.Common.UserSettings());
+
         var vm = new UpdateNotificationViewModel(
             mockVelopack.Object,
-            Mock.Of<ILogger<UpdateNotificationViewModel>>());
+            Mock.Of<ILogger<UpdateNotificationViewModel>>(),
+            mockUserSettings.Object);
 
         await ((CommunityToolkit.Mvvm.Input.IAsyncRelayCommand)vm.CheckForUpdatesCommand).ExecuteAsync(null);
 
@@ -37,9 +42,13 @@ public async Task CheckForUpdatesCommand_WhenNoUpdateAvailable_UpdatesStatus()
     [Fact]
     public void Constructor_InitializesSuccessfully()
     {
+        var mockUserSettings = new Mock<IUserSettingsService>();
+        mockUserSettings.Setup(x => x.Get()).Returns(new GenHub.Core.Models.Common.UserSettings());
+
         var vm = new UpdateNotificationViewModel(
             Mock.Of<IVelopackUpdateManager>(),
-            Mock.Of<ILogger<UpdateNotificationViewModel>>());
+            Mock.Of<ILogger<UpdateNotificationViewModel>>(),
+            mockUserSettings.Object);
 
         Assert.NotNull(vm);
         Assert.False(vm.IsUpdateAvailable);
@@ -53,9 +62,13 @@ public void Constructor_InitializesSuccessfully()
     [Fact]
     public void IsCheckButtonEnabled_ReflectsCheckingState()
     {
+        var mockUserSettings = new Mock<IUserSettingsService>();
+        mockUserSettings.Setup(x => x.Get()).Returns(new GenHub.Core.Models.Common.UserSettings());
+
         var vm = new UpdateNotificationViewModel(
             Mock.Of<IVelopackUpdateManager>(),
-            Mock.Of<ILogger<UpdateNotificationViewModel>>());
+            Mock.Of<ILogger<UpdateNotificationViewModel>>(),
+            mockUserSettings.Object);
 
         Assert.True(vm.IsCheckButtonEnabled);
     }
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/GameProcessManagerTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/GameProcessManagerTests.cs
index 604f0d218..9d1671d52 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/GameProcessManagerTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/GameProfiles/GameProcessManagerTests.cs
@@ -87,70 +87,6 @@ public async Task GetActiveProcessesAsync_Initially_ShouldReturnEmptyList()
         Assert.Empty(result.Data!);
     }
 
-    /// <summary>
-    /// Tests that StartProcessAsync with a valid executable path returns success.
-    /// </summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Fact]
-    public async Task StartProcessAsync_WithValidExecutablePath_ShouldReturnSuccess()
-    {
-        // Arrange - Use cross-platform approach
-        string tempExe;
-        string scriptContent;
-
-        if (OperatingSystem.IsWindows())
-        {
-            tempExe = Path.GetTempFileName() + ".bat";
-            scriptContent = "@echo off\ntimeout /t 2 >nul\n";
-        }
-        else
-        {
-            tempExe = Path.GetTempFileName() + ".sh";
-            scriptContent = "#!/bin/bash\nsleep 2\n";
-        }
-
-        await File.WriteAllTextAsync(tempExe, scriptContent);
-
-        if (!OperatingSystem.IsWindows())
-        {
-            // Make script executable on Unix systems
-            var chmod = new System.Diagnostics.Process
-            {
-                StartInfo = new System.Diagnostics.ProcessStartInfo
-                {
-                    FileName = "chmod",
-                    Arguments = "+x " + tempExe,
-                    UseShellExecute = false,
-                },
-            };
-            chmod.Start();
-            chmod.WaitForExit();
-        }
-
-        try
-        {
-            var config = new GameLaunchConfiguration
-            {
-                ExecutablePath = tempExe,
-            };
-
-            // Act
-            var result = await _processManager.StartProcessAsync(config);
-
-            // Assert
-            Assert.True(result.Success);
-            Assert.NotNull(result.Data);
-            Assert.True(result.Data.ProcessId > 0);
-
-            // Cleanup
-            await _processManager.TerminateProcessAsync(result.Data.ProcessId);
-        }
-        finally
-        {
-            File.Delete(tempExe);
-        }
-    }
-
     /// <summary>
     /// Tests that TerminateProcessAsync with a real running process returns success.
     /// </summary>
@@ -214,74 +150,6 @@ public async Task TerminateProcessAsync_WithRunningProcess_ShouldReturnSuccess()
         }
     }
 
-    /// <summary>
-    /// Tests that GetProcessInfoAsync returns info for a running process.
-    /// </summary>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    [Fact]
-    public async Task GetProcessInfoAsync_WithRunningProcess_ShouldReturnInfo()
-    {
-        // Arrange - Use cross-platform approach
-        string tempExe;
-        string scriptContent;
-
-        if (OperatingSystem.IsWindows())
-        {
-            tempExe = Path.GetTempFileName() + ".bat";
-            scriptContent = "@echo off\nping -n 6 127.0.0.1 >nul\n";
-        }
-        else
-        {
-            tempExe = Path.GetTempFileName() + ".sh";
-            scriptContent = "#!/bin/bash\nping -c 5 127.0.0.1 > /dev/null\n";
-        }
-
-        await File.WriteAllTextAsync(tempExe, scriptContent);
-
-        if (!OperatingSystem.IsWindows())
-        {
-            // Make script executable on Unix systems
-            var chmod = new System.Diagnostics.Process
-            {
-                StartInfo = new System.Diagnostics.ProcessStartInfo
-                {
-                    FileName = "chmod",
-                    Arguments = "+x " + tempExe,
-                    UseShellExecute = false,
-                },
-            };
-            chmod.Start();
-            chmod.WaitForExit();
-        }
-
-        var config = new GameLaunchConfiguration
-        {
-            ExecutablePath = tempExe,
-        };
-
-        try
-        {
-            var startResult = await _processManager.StartProcessAsync(config);
-            Assert.True(startResult.Success);
-            Assert.NotNull(startResult.Data);
-
-            // Act
-            var infoResult = await _processManager.GetProcessInfoAsync(startResult.Data!.ProcessId);
-
-            // Assert
-            Assert.True(infoResult.Success, $"Failed to get process info: {infoResult.FirstError}");
-            Assert.NotNull(infoResult.Data);
-            Assert.Equal(startResult.Data.ProcessId, infoResult.Data.ProcessId);
-
-            // Cleanup
-            await _processManager.TerminateProcessAsync(startResult.Data.ProcessId);
-        }
-        finally
-        {
-            File.Delete(tempExe);
-        }
-    }
-
     /// <summary>
     /// Tests that GetActiveProcessesAsync returns running processes.
     /// </summary>
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/GameProfileModuleTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/GameProfileModuleTests.cs
index b86f6807d..2f21b96c5 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/GameProfileModuleTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/GameProfileModuleTests.cs
@@ -137,6 +137,7 @@ public void AddLaunchingServices_LaunchRegistry_ShouldBeSingleton()
         var configProviderMock = new Mock<IConfigurationProviderService>();
 
         services.AddLogging();
+        services.AddSingleton<IConfigurationProviderService>(configProviderMock.Object);
 
         // Act
         services.AddLaunchingServices();
@@ -165,6 +166,7 @@ public void AddGameProfileServices_GameProfileManager_ShouldBeScoped()
         // Add required dependencies
         services.AddLogging();
         services.AddSingleton<IConfigurationProviderService>(configProviderMock.Object);
+
         services.AddScoped(provider => new Mock<IGameInstallationService>().Object);
         services.AddScoped(provider => new Mock<IContentManifestPool>().Object);
         services.AddScoped(provider => new Mock<IContentOrchestrator>().Object);
@@ -254,6 +256,7 @@ public void AddGameProfileServices_ProfileLauncherFacade_ShouldBeSingleton()
         services.AddSingleton<IGameLauncher>(new Mock<IGameLauncher>().Object);
         services.AddSingleton<ILaunchRegistry>(new Mock<ILaunchRegistry>().Object);
         services.AddSingleton<ICasService>(new Mock<ICasService>().Object);
+        services.AddSingleton<GenHub.Core.Interfaces.Shortcuts.IShortcutService>(new Mock<GenHub.Core.Interfaces.Shortcuts.IShortcutService>().Object);
 
         // Act
         services.AddGameProfileServices();
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/SharedViewModelModuleTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/SharedViewModelModuleTests.cs
index 7f0247917..ca0367922 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/SharedViewModelModuleTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Infrastructure/DependencyInjection/SharedViewModelModuleTests.cs
@@ -2,7 +2,6 @@
 using GenHub.Core.Interfaces.Common;
 using GenHub.Core.Interfaces.Content;
 using GenHub.Core.Interfaces.Manifest;
-using GenHub.Core.Interfaces.Shortcuts;
 using GenHub.Core.Models.Common;
 using GenHub.Core.Models.Enums;
 using GenHub.Core.Models.Manifest;
@@ -33,6 +32,7 @@ public void AllViewModels_Registered()
         // Register all required configuration services first
         var configProvider = CreateMockConfigProvider();
         services.AddSingleton<IConfigurationProviderService>(configProvider);
+
         services.AddSingleton<IUserSettingsService>(CreateMockUserSettingsService());
         services.AddSingleton<IAppConfiguration>(CreateMockAppConfiguration());
 
@@ -96,19 +96,23 @@ public void AllViewModels_Registered()
         var validatorMock = new Mock<IContentValidator>();
         services.AddSingleton<IContentValidator>(validatorMock.Object);
 
-        // Mock IShortcutService (platform-specific service)
-        var shortcutServiceMock = new Mock<IShortcutService>();
-        services.AddSingleton<IShortcutService>(shortcutServiceMock.Object);
+        // Mock IShortcutService to avoid dependency issues
+        var shortcutServiceMock = new Mock<GenHub.Core.Interfaces.Shortcuts.IShortcutService>();
+        services.AddSingleton<GenHub.Core.Interfaces.Shortcuts.IShortcutService>(shortcutServiceMock.Object);
+
+        // Mock IGitHubTokenStorage to avoid dependency issues
+        var tokenStorageMock = new Mock<GenHub.Core.Interfaces.GitHub.IGitHubTokenStorage>();
+        services.AddSingleton<GenHub.Core.Interfaces.GitHub.IGitHubTokenStorage>(tokenStorageMock.Object);
 
         // Register required modules in correct order
         services.AddLoggingModule();
         services.AddValidationServices();
         services.AddGameDetectionService();
         services.AddGameInstallation();
+        services.AddCasServices();
         services.AddContentPipelineServices();
         services.AddManifestServices();
         services.AddWorkspaceServices();
-        services.AddCasServices();
         services.AddDownloadServices();
         services.AddNotificationModule();
         services.AddAppUpdateModule();
diff --git a/GenHub/GenHub/Common/ViewModels/MainViewModel.cs b/GenHub/GenHub/Common/ViewModels/MainViewModel.cs
index ff60a788e..f5d99746f 100644
--- a/GenHub/GenHub/Common/ViewModels/MainViewModel.cs
+++ b/GenHub/GenHub/Common/ViewModels/MainViewModel.cs
@@ -352,16 +352,45 @@ private async Task CheckForUpdatesAsync(CancellationToken cancellationToken = de
 
             if (hasUpdate)
             {
+                string? latestVersion = null;
+
                 if (updateInfo != null)
                 {
-                    _logger?.LogInformation("Update available: {Current} → {Latest}", AppConstants.AppVersion, updateInfo.TargetFullRelease.Version);
+                    latestVersion = updateInfo.TargetFullRelease.Version.ToString();
+                    _logger?.LogInformation("Update available: {Current} → {Latest}", AppConstants.AppVersion, latestVersion);
                 }
                 else if (_velopackUpdateManager.LatestVersionFromGitHub != null)
                 {
-                    _logger?.LogInformation("Update available from GitHub API: {Version}", _velopackUpdateManager.LatestVersionFromGitHub);
+                    latestVersion = _velopackUpdateManager.LatestVersionFromGitHub;
+                    _logger?.LogInformation("Update available from GitHub API: {Version}", latestVersion);
+                }
+
+                // Strip build metadata for comparison (everything after '+')
+                var latestVersionBase = latestVersion?.Split('+')[0];
+                var currentVersionBase = AppConstants.AppVersion.Split('+')[0];
+
+                // Check if this version was dismissed by the user
+                var settings = _userSettingsService.Get();
+                var dismissedVersionBase = settings.DismissedUpdateVersion?.Split('+')[0];
+
+                if (!string.IsNullOrEmpty(latestVersionBase) &&
+                    string.Equals(latestVersionBase, dismissedVersionBase, StringComparison.OrdinalIgnoreCase))
+                {
+                    _logger?.LogDebug("Update {Version} was dismissed by user, hiding notification", latestVersionBase);
+                    HasUpdateAvailable = false;
                 }
 
-                HasUpdateAvailable = true;
+                // Also check if we're already on this version (ignoring build metadata)
+                else if (!string.IsNullOrEmpty(latestVersionBase) &&
+                         string.Equals(latestVersionBase, currentVersionBase, StringComparison.OrdinalIgnoreCase))
+                {
+                    _logger?.LogDebug("Already on version {Version} (ignoring build metadata), hiding notification", latestVersionBase);
+                    HasUpdateAvailable = false;
+                }
+                else
+                {
+                    HasUpdateAvailable = true;
+                }
             }
             else
             {
diff --git a/GenHub/GenHub/Common/Views/MainView.axaml b/GenHub/GenHub/Common/Views/MainView.axaml
index 192311462..0d57dbf72 100644
--- a/GenHub/GenHub/Common/Views/MainView.axaml
+++ b/GenHub/GenHub/Common/Views/MainView.axaml
@@ -189,19 +189,19 @@
                 </StackPanel>
                 <!-- branding and update button - Right side -->
                 <Grid Grid.Column="2" ColumnDefinitions="Auto,Auto" VerticalAlignment="Center">
-                    <!-- Logo and title section -->
-                    <StackPanel Grid.Column="0" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,0,0,0">
-                        <Image Source="avares://GenHub/Assets/Logos/generalshub-logo.png" Width="90" Height="90" HorizontalAlignment="Center" Margin="0,-10,0,-15" />
-                        <TextBlock Text="C&amp;C Generals Launcher" FontSize="9" Foreground="#A0A0A0" FontWeight="Normal" HorizontalAlignment="Center" VerticalAlignment="Top" TextAlignment="Center" Margin="0,0,0,0" />
-                    </StackPanel>
-                    <!-- Update notification button -->
-                    <Button Grid.Column="1" Classes="update-notification" Command="{Binding ShowUpdateDialogCommand}" IsVisible="{Binding HasUpdateAvailable}" ToolTip.Tip="Update available - click to download" VerticalAlignment="Center">
+                    <!-- Update notification button - Left side -->
+                    <Button Grid.Column="0" Classes="update-notification" Command="{Binding ShowUpdateDialogCommand}" IsVisible="{Binding HasUpdateAvailable}" ToolTip.Tip="Update available - click to download" VerticalAlignment="Center" Margin="0,0,12,0">
                         <Panel>
                             <Ellipse Width="20" Height="20" Fill="#4CAF50" HorizontalAlignment="Center" VerticalAlignment="Center" />
                             <PathIcon Data="M7,10L12,15L17,10H7Z" Width="12" Height="12" Foreground="White" HorizontalAlignment="Center" VerticalAlignment="Center" />
                             <Ellipse Width="8" Height="8" Fill="#FF4500" HorizontalAlignment="Right" VerticalAlignment="Top" Margin="0,-2,-2,0" />
                         </Panel>
                     </Button>
+                    <!-- Logo and title section - Right side -->
+                    <StackPanel Grid.Column="1" HorizontalAlignment="Center" VerticalAlignment="Top" Margin="0,0,0,0">
+                        <Image Source="avares://GenHub/Assets/Logos/generalshub-logo.png" Width="90" Height="90" HorizontalAlignment="Center" Margin="0,-10,0,-15" />
+                        <TextBlock Text="C&amp;C Generals Launcher" FontSize="9" Foreground="#A0A0A0" FontWeight="Normal" HorizontalAlignment="Center" VerticalAlignment="Top" TextAlignment="Center" Margin="0,0,0,0" />
+                    </StackPanel>
                 </Grid>
             </Grid>
         </Border>
@@ -210,11 +210,11 @@
         <Grid Grid.Row="1" Background="#1A1A1A">
             <ContentControl Content="{Binding CurrentTabViewModel}" />
             <!-- Version label in bottom right corner -->
-            <TextBlock Text="{x:Static constants:AppConstants.DisplayVersion}" 
-                       FontSize="9" 
-                       Foreground="#404040" 
-                       HorizontalAlignment="Right" 
-                       VerticalAlignment="Bottom" 
+            <TextBlock Text="{x:Static constants:AppConstants.DisplayVersion}"
+                       FontSize="9"
+                       Foreground="#404040"
+                       HorizontalAlignment="Right"
+                       VerticalAlignment="Bottom"
                        Margin="0,0,10,5" />
         </Grid>
     </Grid>
diff --git a/GenHub/GenHub/Features/AppUpdate/Interfaces/IVelopackUpdateManager.cs b/GenHub/GenHub/Features/AppUpdate/Interfaces/IVelopackUpdateManager.cs
index d8cb5df8b..bb258efcb 100644
--- a/GenHub/GenHub/Features/AppUpdate/Interfaces/IVelopackUpdateManager.cs
+++ b/GenHub/GenHub/Features/AppUpdate/Interfaces/IVelopackUpdateManager.cs
@@ -1,7 +1,9 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using GenHub.Core.Models.AppUpdate;
+using GenHub.Core.Models.Enums;
 using Velopack;
 
 namespace GenHub.Features.AppUpdate.Interfaces;
@@ -12,12 +14,28 @@ namespace GenHub.Features.AppUpdate.Interfaces;
 public interface IVelopackUpdateManager
 {
     /// <summary>
-    /// Checks for available updates.
+    /// Checks for available updates from GitHub Releases.
     /// </summary>
     /// <param name="cancellationToken">Cancellation token.</param>
     /// <returns>UpdateInfo if an update is available, otherwise null.</returns>
     Task<UpdateInfo?> CheckForUpdatesAsync(CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Checks for available artifact updates from GitHub Actions CI builds.
+    /// Requires a GitHub PAT with repo access.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>ArtifactUpdateInfo if an artifact update is available, otherwise null.</returns>
+    Task<ArtifactUpdateInfo?> CheckForArtifactUpdatesAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Gets a list of open pull requests with available CI artifacts.
+    /// Requires a GitHub PAT with repo access.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>List of open PRs with artifact info.</returns>
+    Task<IReadOnlyList<PullRequestInfo>> GetOpenPullRequestsAsync(CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Downloads the specified update.
     /// </summary>
@@ -54,4 +72,39 @@ public interface IVelopackUpdateManager
     /// Gets the latest version available from GitHub, if an update was found.
     /// </summary>
     string? LatestVersionFromGitHub { get; }
-}
+
+    /// <summary>
+    /// Gets or sets the current update channel.
+    /// </summary>
+    UpdateChannel CurrentChannel { get; set; }
+
+    /// <summary>
+    /// Gets a value indicating whether artifact updates are available (requires PAT).
+    /// </summary>
+    bool HasArtifactUpdateAvailable { get; }
+
+    /// <summary>
+    /// Gets the latest artifact update info, if available.
+    /// </summary>
+    ArtifactUpdateInfo? LatestArtifactUpdate { get; }
+
+    /// <summary>
+    /// Gets or sets the subscribed PR number. Set to null for MAIN branch updates.
+    /// </summary>
+    int? SubscribedPrNumber { get; set; }
+
+    /// <summary>
+    /// Gets a value indicating whether the subscribed PR has been merged or closed.
+    /// Used to trigger fallback to MAIN branch.
+    /// </summary>
+    bool IsPrMergedOrClosed { get; }
+
+    /// <summary>
+    /// Downloads and installs a PR artifact.
+    /// </summary>
+    /// <param name="prInfo">The PR information containing the artifact to install.</param>
+    /// <param name="progress">Progress reporter.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>A task representing the installation operation.</returns>
+    Task InstallPrArtifactAsync(PullRequestInfo prInfo, IProgress<UpdateProgress>? progress = null, CancellationToken cancellationToken = default);
+}
\ No newline at end of file
diff --git a/GenHub/GenHub/Features/AppUpdate/Services/SimpleHttpServer.cs b/GenHub/GenHub/Features/AppUpdate/Services/SimpleHttpServer.cs
new file mode 100644
index 000000000..e96b6bd3e
--- /dev/null
+++ b/GenHub/GenHub/Features/AppUpdate/Services/SimpleHttpServer.cs
@@ -0,0 +1,206 @@
+using System;
+using System.IO;
+using System.Net;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+
+namespace GenHub.Features.AppUpdate.Services;
+
+/// <summary>
+/// Simple HTTP server to serve local .nupkg files to Velopack.
+/// </summary>
+internal sealed class SimpleHttpServer : IDisposable
+{
+    /// <summary>
+    /// Length of the secret token in URL path (RFC 4648 Base16).
+    /// </summary>
+    private const int SecretTokenLength = 32;
+
+    private readonly HttpListener _listener;
+    private readonly string _nupkgPath;
+    private readonly string _releasesPath;
+    private readonly ILogger _logger;
+    private readonly string _secretToken;
+    private CancellationTokenSource? _cts;
+    private Task? _serverTask;
+    private int _started = 0; // 0 = not started, 1 = started (for thread-safe check)
+
+    /// <summary>
+    /// Gets the port the server is listening on.
+    /// </summary>
+    public int Port { get; }
+
+    /// <summary>
+    /// Gets the secret token used in the URL path for security (prevents hijacking by other local processes).
+    /// </summary>
+    public string SecretToken => _secretToken;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SimpleHttpServer"/> class.
+    /// </summary>
+    /// <param name="nupkgPath">The path to the .nupkg file to serve.</param>
+    /// <param name="releasesPath">The path to the releases.json file (or releases.win.json).</param>
+    /// <param name="port">The port to listen on.</param>
+    /// <param name="logger">The logger instance.</param>
+    public SimpleHttpServer(string nupkgPath, string releasesPath, int port, ILogger logger)
+    {
+        _nupkgPath = nupkgPath ?? throw new ArgumentNullException(nameof(nupkgPath));
+        _releasesPath = releasesPath ?? throw new ArgumentNullException(nameof(releasesPath));
+        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        Port = port;
+
+        // Generate a random secret token to prevent other local processes from hijacking the server
+        _secretToken = Guid.NewGuid().ToString("N").Substring(0, SecretTokenLength);
+
+        _listener = new HttpListener();
+        _listener.Prefixes.Add($"http://localhost:{Port}/{_secretToken}/");
+    }
+
+    /// <summary>
+    /// Starts the HTTP server using thread-safe Interlocked pattern.
+    /// </summary>
+    public void Start()
+    {
+        // Use Interlocked to atomically check and set _started flag
+        if (Interlocked.CompareExchange(ref _started, 1, 0) != 0)
+        {
+            return; // Already running
+        }
+
+        _cts = new CancellationTokenSource();
+        _listener.Start();
+        _serverTask = Task.Run(() => HandleRequestsAsync(_cts.Token), _cts.Token);
+        _logger.LogInformation("HTTP server started on port {Port} with secret token", Port);
+    }
+
+    /// <summary>
+    /// Stops the HTTP server.
+    /// </summary>
+    public void Stop()
+    {
+        if (_cts == null || _serverTask == null)
+        {
+            return;
+        }
+
+        _cts.Cancel();
+        _listener.Stop();
+
+        try
+        {
+            _serverTask.Wait(TimeSpan.FromSeconds(5));
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error stopping HTTP server");
+        }
+
+        _logger.LogInformation("HTTP server stopped");
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        Stop();
+        _cts?.Dispose();
+        _listener.Close();
+    }
+
+    private async Task HandleRequestsAsync(CancellationToken cancellationToken)
+    {
+        while (!cancellationToken.IsCancellationRequested)
+        {
+            try
+            {
+                // Use BeginGetContext + timeout to allow cancellation
+                var contextTask = _listener.GetContextAsync();
+                var completedTask = await Task.WhenAny(contextTask, Task.Delay(TimeSpan.FromSeconds(1), cancellationToken)).ConfigureAwait(false);
+
+                if (completedTask != contextTask)
+                {
+                    // Timeout occurred or cancellation requested, check status
+                    if (cancellationToken.IsCancellationRequested)
+                        break;
+                    continue; // Loop back to check cancellation
+                }
+
+                var context = await contextTask.ConfigureAwait(false);
+                _ = Task.Run(() => ProcessRequestAsync(context), cancellationToken);
+            }
+            catch (HttpListenerException) when (cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
+            catch (ObjectDisposedException) when (cancellationToken.IsCancellationRequested)
+            {
+                // Expected when _listener is stopped during cancellation
+                break;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error handling HTTP request");
+            }
+        }
+    }
+
+    private async Task ProcessRequestAsync(HttpListenerContext context)
+    {
+        try
+        {
+            var request = context.Request;
+            var response = context.Response;
+
+            _logger.LogDebug("HTTP request: {Method} {Url}", request.HttpMethod, request.Url);
+
+            // Serve releases.win.json or releases.json (Velopack format)
+            if (request.Url?.AbsolutePath.Contains("releases", StringComparison.OrdinalIgnoreCase) == true &&
+                request.Url.AbsolutePath.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
+            {
+                if (File.Exists(_releasesPath))
+                {
+                    _logger.LogDebug("Serving releases JSON from {Path}", _releasesPath);
+                    var content = await File.ReadAllBytesAsync(_releasesPath);
+                    response.ContentType = "application/json";
+                    response.ContentLength64 = content.Length;
+                    await response.OutputStream.WriteAsync(content);
+                }
+                else
+                {
+                    _logger.LogWarning("Releases JSON file not found at {Path}", _releasesPath);
+                    response.StatusCode = 404;
+                }
+            }
+
+            // Serve .nupkg file
+            else if (request.Url?.AbsolutePath.EndsWith(".nupkg", StringComparison.OrdinalIgnoreCase) == true)
+            {
+                if (File.Exists(_nupkgPath))
+                {
+                    _logger.LogDebug("Serving nupkg from {Path}", _nupkgPath);
+                    response.ContentType = "application/octet-stream";
+                    response.ContentLength64 = new FileInfo(_nupkgPath).Length;
+
+                    using var fileStream = File.OpenRead(_nupkgPath);
+                    await fileStream.CopyToAsync(response.OutputStream);
+                }
+                else
+                {
+                    _logger.LogWarning("Nupkg file not found at {Path}", _nupkgPath);
+                    response.StatusCode = 404;
+                }
+            }
+            else
+            {
+                _logger.LogWarning("Unknown request path: {Path}", request.Url?.AbsolutePath);
+                response.StatusCode = 404;
+            }
+
+            response.Close();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error processing HTTP request");
+        }
+    }
+}
\ No newline at end of file
diff --git a/GenHub/GenHub/Features/AppUpdate/Services/VelopackUpdateManager.cs b/GenHub/GenHub/Features/AppUpdate/Services/VelopackUpdateManager.cs
index 5a4aa0a14..164947dc1 100644
--- a/GenHub/GenHub/Features/AppUpdate/Services/VelopackUpdateManager.cs
+++ b/GenHub/GenHub/Features/AppUpdate/Services/VelopackUpdateManager.cs
@@ -1,12 +1,21 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.IO.Compression;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Runtime.InteropServices;
+using System.Security;
 using System.Text.Json;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.GitHub;
 using GenHub.Core.Models.AppUpdate;
+using GenHub.Core.Models.Enums;
 using GenHub.Features.AppUpdate.Interfaces;
 using Microsoft.Extensions.Logging;
 using NuGet.Versioning;
@@ -16,50 +25,67 @@
 namespace GenHub.Features.AppUpdate.Services;
 
 /// <summary>
-/// Velopack-based update manager service.
+/// Velopack-based update manager service with support for release and artifact update channels.
 /// </summary>
-public class VelopackUpdateManager : IVelopackUpdateManager, IDisposable
+public class VelopackUpdateManager(
+    ILogger<VelopackUpdateManager> logger,
+    IHttpClientFactory httpClientFactory,
+    IGitHubTokenStorage gitHubTokenStorage,
+    IUserSettingsService userSettingsService) : IVelopackUpdateManager, IDisposable
 {
-    private readonly ILogger<VelopackUpdateManager> _logger;
-    private readonly IHttpClientFactory _httpClientFactory;
-    private readonly UpdateManager? _updateManager;
-    private readonly GithubSource _githubSource;
+    /// <summary>
+    /// Length of the git short hash used in versioning (7 characters).
+    /// </summary>
+    private const int GitShortHashLength = 7;
+
+    private readonly GithubSource _githubSource = new(AppConstants.GitHubRepositoryUrl, string.Empty, true);
+    private readonly UpdateManager? _updateManager = CreateUpdateManager(logger);
+
     private bool _hasUpdateFromGitHub;
     private string? _latestVersionFromGitHub;
+    private ArtifactUpdateInfo? _latestArtifactUpdate;
 
-    /// <summary>
-    /// Initializes a new instance of the <see cref="VelopackUpdateManager"/> class.
-    /// </summary>
-    /// <param name="logger">The logger instance.</param>
-    /// <param name="httpClientFactory">The HTTP client factory for creating HttpClient instances.</param>
-    public VelopackUpdateManager(ILogger<VelopackUpdateManager> logger, IHttpClientFactory httpClientFactory)
-    {
-        _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        _httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
+    /// <inheritdoc/>
+    public UpdateChannel CurrentChannel { get; set; } = userSettingsService.Get().UpdateChannel;
 
-        // Always initialize GithubSource for update checking
-        _githubSource = new GithubSource(AppConstants.GitHubRepositoryUrl, string.Empty, true);
+    /// <inheritdoc/>
+    public bool HasArtifactUpdateAvailable => _latestArtifactUpdate != null;
 
-        try
+    /// <inheritdoc/>
+    public ArtifactUpdateInfo? LatestArtifactUpdate => _latestArtifactUpdate;
+
+    /// <inheritdoc/>
+    public int? SubscribedPrNumber { get; set; }
+
+    /// <inheritdoc/>
+    public bool IsPrMergedOrClosed { get; private set; }
+
+    /// <inheritdoc/>
+    public bool IsUpdatePendingRestart => _updateManager?.UpdatePendingRestart != null;
+
+    /// <inheritdoc/>
+    public bool HasUpdateAvailableFromGitHub
+    {
+        get
         {
-            // Try to initialize UpdateManager for downloading/applying updates
-            // This will only work if app is installed, but that's OK - we check GitHub directly
-            _updateManager = new UpdateManager(_githubSource);
-            _logger.LogInformation("Velopack UpdateManager initialized successfully for: {Repository}", AppConstants.GitHubRepositoryUrl);
+            logger.LogDebug("HasUpdateAvailableFromGitHub property accessed: {Value}", _hasUpdateFromGitHub);
+            return _hasUpdateFromGitHub;
         }
-        catch (Exception ex)
+    }
+
+    /// <inheritdoc/>
+    public string? LatestVersionFromGitHub
+    {
+        get
         {
-            _logger.LogWarning(ex, "Velopack UpdateManager not available (running from Debug)");
-            _logger.LogDebug("Update CHECKING will still work via GitHub API, but downloading/installing requires installed app");
+            logger.LogDebug("LatestVersionFromGitHub property accessed: '{Value}'", _latestVersionFromGitHub ?? "NULL");
+            return _latestVersionFromGitHub;
         }
     }
 
-    /// <summary>
-    /// Disposes of managed resources.
-    /// </summary>
+    /// <inheritdoc/>
     public void Dispose()
     {
-        // Dispose UpdateManager if it implements IDisposable
         if (_updateManager is IDisposable disposableUpdateManager)
         {
             disposableUpdateManager.Dispose();
@@ -71,165 +97,446 @@ public void Dispose()
     /// <inheritdoc/>
     public async Task<UpdateInfo?> CheckForUpdatesAsync(CancellationToken cancellationToken = default)
     {
-        _logger.LogInformation("Starting GitHub update check for repository: {Url}", AppConstants.GitHubRepositoryUrl);
+        logger.LogInformation("Starting GitHub release update check for: {Url}", AppConstants.GitHubRepositoryUrl);
+
+        // Reset per-run state to avoid stale UI
+        _hasUpdateFromGitHub = false;
+        _latestVersionFromGitHub = null;
 
         try
         {
-            // Extract owner and repo from URL
-            // Format: https://github.com/owner/repo
-            var uri = new Uri(AppConstants.GitHubRepositoryUrl);
-            var pathParts = uri.AbsolutePath.Trim('/').Split('/');
-            if (pathParts.Length < 2)
-            {
-                _logger.LogError("Invalid GitHub repository URL format: {Url}", AppConstants.GitHubRepositoryUrl);
-                return null;
-            }
-
-            var owner = pathParts[0];
-            var repo = pathParts[1];
-
-            _logger.LogInformation("🔍 Fetching releases from GitHub API: {Owner}/{Repo}", owner, repo);
-
-            // Call GitHub API to get latest release
-            var apiUrl = $"https://api.github.com/repos/{owner}/{repo}/releases";
+            var apiUrl = $"https://api.github.com/repos/{AppConstants.GitHubRepositoryOwner}/{AppConstants.GitHubRepositoryName}/releases";
             using var client = CreateConfiguredHttpClient();
             var response = await client.GetAsync(apiUrl, cancellationToken);
 
             if (!response.IsSuccessStatusCode)
             {
-                _logger.LogError("GitHub API request failed: {StatusCode} - {Reason}", response.StatusCode, response.ReasonPhrase);
+                logger.LogError("GitHub API request failed: {StatusCode}", response.StatusCode);
                 return null;
             }
 
-            var json = await client.GetStringAsync(apiUrl, cancellationToken);
-
-            JsonElement releases;
-            try
-            {
-                releases = JsonSerializer.Deserialize<JsonElement>(json);
-            }
-            catch (JsonException ex)
-            {
-                _logger.LogError(ex, "Failed to parse GitHub API response as JSON");
-                _logger.LogDebug("Raw JSON response: {Json}", json);
-                return null;
-            }
+            var json = await response.Content.ReadAsStringAsync(cancellationToken);
+            var releases = JsonSerializer.Deserialize<JsonElement>(json);
 
             if (!releases.ValueKind.Equals(JsonValueKind.Array) || releases.GetArrayLength() == 0)
             {
-                _logger.LogWarning("No releases found on GitHub");
+                logger.LogWarning("No releases found on GitHub");
                 return null;
             }
 
-            // Parse current version
             if (!SemanticVersion.TryParse(AppConstants.AppVersion, out var currentVersion))
             {
-                _logger.LogError("Failed to parse current version: {Version}", AppConstants.AppVersion);
+                logger.LogError("Failed to parse current version: {Version}", AppConstants.AppVersion);
                 return null;
             }
 
-            _logger.LogDebug("Current version parsed: {Version}, Prerelease: {IsPrerelease}", currentVersion, currentVersion.IsPrerelease);
-
-            // Find the latest release (including prereleases)
             SemanticVersion? latestVersion = null;
-            JsonElement? latestRelease = null;
-
             foreach (var release in releases.EnumerateArray())
             {
                 var tagName = release.GetProperty("tag_name").GetString();
                 if (string.IsNullOrEmpty(tagName))
                     continue;
 
-                // Remove 'v' prefix if present
                 var versionString = tagName.TrimStart('v', 'V');
-
                 if (!SemanticVersion.TryParse(versionString, out var releaseVersion))
-                {
-                    _logger.LogDebug("Skipping release with invalid version: {TagName}", tagName);
                     continue;
-                }
 
-                _logger.LogDebug("Found release: {Version}, Prerelease: {IsPrerelease}", releaseVersion, releaseVersion.IsPrerelease);
+                // Filter based on current channel
+                if (CurrentChannel == UpdateChannel.Stable && releaseVersion.IsPrerelease)
+                    continue;
 
                 if (latestVersion == null || releaseVersion > latestVersion)
                 {
                     latestVersion = releaseVersion;
-                    latestRelease = release;
                 }
             }
 
-            if (latestVersion == null || latestRelease == null)
-            {
-                _logger.LogWarning("No valid releases found");
-                return null;
-            }
-
-            _logger.LogInformation("Latest available version: {Version}", latestVersion);
-            _logger.LogInformation("Comparing: Current={Current} vs Latest={Latest}", currentVersion, latestVersion);
-
-            // Check if update is available
-            if (latestVersion <= currentVersion)
+            if (latestVersion == null || latestVersion <= currentVersion)
             {
-                _logger.LogInformation("No update available. Current version {Current} is up to date", currentVersion);
+                logger.LogInformation("No update available. Current: {Current}", currentVersion);
                 return null;
             }
 
-            _logger.LogInformation("Update available: Current={Current}, Latest={Latest}", currentVersion, latestVersion);
-
-            // Store GitHub update detection result
+            logger.LogInformation("Update available: {Current} -> {Latest}", currentVersion, latestVersion);
             _hasUpdateFromGitHub = true;
             _latestVersionFromGitHub = latestVersion.ToString();
 
-            // If UpdateManager is available, use it to get proper UpdateInfo
-            // Otherwise, return null (can still show user there's an update, but can't install)
+            // Try to get UpdateInfo from Velopack if available
             if (_updateManager != null)
             {
                 try
                 {
-                    _logger.LogDebug("Calling UpdateManager.CheckForUpdatesAsync()");
-
                     var updateInfo = await _updateManager.CheckForUpdatesAsync();
-
-                    _logger.LogDebug("UpdateManager.CheckForUpdatesAsync() completed. UpdateInfo is null: {IsNull}", updateInfo == null);
-                    if (updateInfo != null)
-                    {
-                        _logger.LogDebug("UpdateInfo version: {Version}", updateInfo.TargetFullRelease.Version);
-                    }
-
                     if (updateInfo != null)
                     {
-                        _logger.LogInformation("✅ UpdateManager also confirmed update is available and can be installed");
+                        logger.LogInformation("Velopack confirmed update available");
                         return updateInfo;
                     }
-                    else
-                    {
-                        _logger.LogWarning("⚠️ UpdateManager returned NULL - no update found via Velopack (but GitHub says there is one)");
-                    }
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "UpdateManager.CheckForUpdatesAsync failed");
-                    _logger.LogWarning("Update is available from GitHub, but cannot be downloaded/installed due to UpdateManager exception");
+                    logger.LogWarning(ex, "Velopack UpdateManager check failed");
                 }
             }
-            else
+
+            return null;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to check for updates");
+            return null;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<ArtifactUpdateInfo?> CheckForArtifactUpdatesAsync(CancellationToken cancellationToken = default)
+    {
+        logger.LogInformation("Checking for artifact updates (requires PAT)");
+
+        // Reset per-run state to avoid stale UI
+        _latestArtifactUpdate = null;
+
+        // Check if PAT is available
+        if (!gitHubTokenStorage.HasToken())
+        {
+            logger.LogDebug("No GitHub PAT available, skipping artifact check");
+            return null;
+        }
+
+        try
+        {
+            var token = await gitHubTokenStorage.LoadTokenAsync();
+            if (token == null)
+            {
+                logger.LogWarning("Failed to load GitHub PAT");
+                return null;
+            }
+
+            using var client = CreateConfiguredHttpClient(token);
+            var owner = AppConstants.GitHubRepositoryOwner;
+            var repo = AppConstants.GitHubRepositoryName;
+
+            // Get workflow runs for CI
+            var runsUrl = $"https://api.github.com/repos/{owner}/{repo}/actions/runs?status=success&per_page=10";
+            var runsResponse = await client.GetAsync(runsUrl, cancellationToken);
+
+            if (!runsResponse.IsSuccessStatusCode)
+            {
+                logger.LogWarning("Failed to fetch workflow runs: {Status}", runsResponse.StatusCode);
+                return null;
+            }
+
+            var runsJson = await runsResponse.Content.ReadAsStringAsync(cancellationToken);
+            var runsData = JsonSerializer.Deserialize<JsonElement>(runsJson);
+
+            if (!runsData.TryGetProperty("workflow_runs", out var runs) || runs.GetArrayLength() == 0)
             {
-                _logger.LogWarning("⚠️ UpdateManager is NULL - was not initialized successfully");
+                logger.LogDebug("No successful workflow runs found");
+                return null;
             }
 
-            // Return null but flag is set (UI can show "update available" but disable install)
-            _logger.LogWarning("⚠️ Update detected via GitHub API but UpdateManager unavailable (running from debug)");
-            _logger.LogWarning("   Install the app using Setup.exe to enable automatic updates");
+            // Find the latest run with artifacts
+            foreach (var run in runs.EnumerateArray())
+            {
+                var runId = run.GetProperty("id").GetInt64();
+                var runUrl = run.GetProperty("html_url").GetString() ?? string.Empty;
+                DateTime createdAt;
+                try
+                {
+                    createdAt = run.GetProperty("created_at").GetDateTime();
+                }
+                catch (FormatException ex)
+                {
+                    logger.LogWarning(ex, "Failed to parse created_at date from workflow run");
+                    createdAt = DateTime.UtcNow;
+                }
+
+                var headSha = run.GetProperty("head_sha").GetString() ?? string.Empty;
+                var shortHash = headSha.Length >= GitShortHashLength ? headSha[..GitShortHashLength] : headSha;
+
+                // Check for PR number in the run
+                int? prNumber = null;
+                if (run.TryGetProperty("pull_requests", out var prs) && prs.GetArrayLength() > 0)
+                {
+                    prNumber = prs[0].GetProperty("number").GetInt32();
+                }
+
+                // Get artifacts for this run
+                var artifactsUrl = $"https://api.github.com/repos/{owner}/{repo}/actions/runs/{runId}/artifacts";
+                var artifactsResponse = await client.GetAsync(artifactsUrl, cancellationToken);
+
+                if (!artifactsResponse.IsSuccessStatusCode)
+                    continue;
 
+                var artifactsJson = await artifactsResponse.Content.ReadAsStringAsync(cancellationToken);
+                var artifactsData = JsonSerializer.Deserialize<JsonElement>(artifactsJson);
+
+                if (!artifactsData.TryGetProperty("artifacts", out var artifacts) || artifacts.GetArrayLength() == 0)
+                    continue;
+
+                // Look for Velopack artifacts
+                foreach (var artifact in artifacts.EnumerateArray())
+                {
+                    var artifactName = artifact.GetProperty("name").GetString() ?? string.Empty;
+                    if (!artifactName.Contains("velopack", StringComparison.OrdinalIgnoreCase))
+                        continue;
+
+                    var artifactId = artifact.GetProperty("id").GetInt64();
+
+                    // Extract version from artifact name (format: genhub-velopack-windows-0.0.160-pr3)
+                    var version = ExtractVersionFromArtifactName(artifactName) ?? "unknown";
+
+                    var artifactInfo = new ArtifactUpdateInfo(
+                        version: version,
+                        gitHash: shortHash,
+                        pullRequestNumber: prNumber,
+                        workflowRunId: runId,
+                        workflowRunUrl: runUrl,
+                        artifactId: artifactId,
+                        artifactName: artifactName,
+                        createdAt: createdAt);
+
+                    logger.LogInformation("Found artifact update: {Version} ({Hash})", version, shortHash);
+                    _latestArtifactUpdate = artifactInfo;
+                    return artifactInfo;
+                }
+            }
+
+            logger.LogDebug("No Velopack artifacts found in recent workflow runs");
             return null;
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to check for updates");
+            logger.LogError(ex, "Failed to check for artifact updates");
             return null;
         }
     }
 
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<PullRequestInfo>> GetOpenPullRequestsAsync(CancellationToken cancellationToken = default)
+    {
+        logger.LogInformation("Fetching open pull requests with artifacts");
+
+        // Reset merged/closed tracking
+        IsPrMergedOrClosed = false;
+
+        var results = new List<PullRequestInfo>();
+
+        // Check if PAT is available
+        if (!gitHubTokenStorage.HasToken())
+        {
+            logger.LogDebug("No GitHub PAT available, skipping PR list fetch");
+            return results;
+        }
+
+        try
+        {
+            var token = await gitHubTokenStorage.LoadTokenAsync();
+            if (token == null)
+            {
+                logger.LogWarning("Failed to load GitHub PAT");
+                return results;
+            }
+
+            using var client = CreateConfiguredHttpClient(token);
+            var owner = AppConstants.GitHubRepositoryOwner;
+            var repo = AppConstants.GitHubRepositoryName;
+
+            // Get open pull requests
+            var prsUrl = $"https://api.github.com/repos/{owner}/{repo}/pulls?state=open&per_page=30";
+            var prsResponse = await client.GetAsync(prsUrl, cancellationToken);
+
+            if (!prsResponse.IsSuccessStatusCode)
+            {
+                logger.LogWarning("Failed to fetch open PRs: {Status}", prsResponse.StatusCode);
+                return results;
+            }
+
+            var prsJson = await prsResponse.Content.ReadAsStringAsync(cancellationToken);
+            var prsData = JsonSerializer.Deserialize<JsonElement>(prsJson);
+
+            if (!prsData.ValueKind.Equals(JsonValueKind.Array))
+            {
+                return results;
+            }
+
+            // Track if subscribed PR is still open
+            bool subscribedPrFound = false;
+
+            foreach (var pr in prsData.EnumerateArray())
+            {
+                var prNumber = pr.GetProperty("number").GetInt32();
+                var title = pr.GetProperty("title").GetString() ?? "Unknown";
+                var branchName = pr.TryGetProperty("head", out var head)
+                    ? head.GetProperty("ref").GetString() ?? "unknown"
+                    : "unknown";
+                var author = pr.TryGetProperty("user", out var user)
+                    ? user.GetProperty("login").GetString() ?? "unknown"
+                    : "unknown";
+                var state = pr.GetProperty("state").GetString() ?? "open";
+                var updatedAt = pr.TryGetProperty("updated_at", out var updatedAtProp)
+                    ? updatedAtProp.GetDateTimeOffset()
+                    : (DateTimeOffset?)null;
+
+                // Check if this is our subscribed PR
+                if (SubscribedPrNumber == prNumber)
+                {
+                    subscribedPrFound = true;
+                    IsPrMergedOrClosed = false;
+                }
+
+                // Find latest artifact for this PR by checking workflow runs
+                ArtifactUpdateInfo? latestArtifact = null;
+
+                var runsUrl = $"https://api.github.com/repos/{owner}/{repo}/actions/runs?status=success&per_page=5";
+                var runsResponse = await client.GetAsync(runsUrl, cancellationToken);
+
+                if (runsResponse.IsSuccessStatusCode)
+                {
+                    var runsJson = await runsResponse.Content.ReadAsStringAsync(cancellationToken);
+                    var runsData = JsonSerializer.Deserialize<JsonElement>(runsJson);
+
+                    if (runsData.TryGetProperty("workflow_runs", out var runs))
+                    {
+                        foreach (var run in runs.EnumerateArray())
+                        {
+                            // Check if this run is for our PR
+                            if (!run.TryGetProperty("pull_requests", out var runPrs))
+                                continue;
+
+                            bool isForThisPr = false;
+                            foreach (var runPr in runPrs.EnumerateArray())
+                            {
+                                if (runPr.GetProperty("number").GetInt32() == prNumber)
+                                {
+                                    isForThisPr = true;
+                                    break;
+                                }
+                            }
+
+                            if (!isForThisPr)
+                                continue;
+
+                            // Get artifacts for this run
+                            var runId = run.GetProperty("id").GetInt64();
+                            var runUrl = run.GetProperty("html_url").GetString() ?? string.Empty;
+                            DateTime createdAt;
+                            try
+                            {
+                                createdAt = run.GetProperty("created_at").GetDateTime();
+                            }
+                            catch (FormatException ex)
+                            {
+                                logger.LogWarning(ex, "Failed to parse created_at date from workflow run");
+                                createdAt = DateTime.UtcNow;
+                            }
+
+                            var headSha = run.GetProperty("head_sha").GetString() ?? string.Empty;
+                            var shortHash = headSha.Length >= GitShortHashLength ? headSha[..GitShortHashLength] : headSha;
+
+                            var artifactsUrl = $"https://api.github.com/repos/{owner}/{repo}/actions/runs/{runId}/artifacts";
+                            var artifactsResponse = await client.GetAsync(artifactsUrl, cancellationToken);
+
+                            if (!artifactsResponse.IsSuccessStatusCode)
+                                continue;
+
+                            var artifactsJson = await artifactsResponse.Content.ReadAsStringAsync(cancellationToken);
+                            var artifactsData = JsonSerializer.Deserialize<JsonElement>(artifactsJson);
+
+                            if (!artifactsData.TryGetProperty("artifacts", out var artifacts))
+                                continue;
+
+                            // Collect all velopack artifacts, prefer Windows
+                            ArtifactUpdateInfo? windowsArtifact = null;
+                            ArtifactUpdateInfo? fallbackArtifact = null;
+
+                            foreach (var artifact in artifacts.EnumerateArray())
+                            {
+                                var artifactName = artifact.GetProperty("name").GetString() ?? string.Empty;
+
+                                // Look for the .nupkg artifact (genhub-velopack-windows-* or genhub-velopack-linux-*)
+                                // Setup.exe and RELEASES are in separate artifacts to reduce download size
+                                if (!artifactName.Contains("velopack", StringComparison.OrdinalIgnoreCase))
+                                    continue;
+
+                                var artifactId = artifact.GetProperty("id").GetInt64();
+                                var version = ExtractVersionFromArtifactName(artifactName) ?? $"PR{prNumber}";
+
+                                var artifactInfo = new ArtifactUpdateInfo(
+                                    version: version,
+                                    gitHash: shortHash,
+                                    pullRequestNumber: prNumber,
+                                    workflowRunId: runId,
+                                    workflowRunUrl: runUrl,
+                                    artifactId: artifactId,
+                                    artifactName: artifactName,
+                                    createdAt: createdAt);
+
+                                // Prefer Windows artifact
+                                if (artifactName.Contains("windows", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    windowsArtifact = artifactInfo;
+                                    break; // Got Windows, stop looking
+                                }
+                                else if (fallbackArtifact == null && !artifactName.Contains("linux", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    fallbackArtifact = artifactInfo;
+                                }
+                            }
+
+                            latestArtifact = windowsArtifact ?? fallbackArtifact;
+
+                            if (latestArtifact != null)
+                                break;
+                        }
+                    }
+                }
+
+                var prInfo = new PullRequestInfo
+                {
+                    Number = prNumber,
+                    Title = title,
+                    BranchName = branchName,
+                    Author = author,
+                    State = state,
+                    UpdatedAt = updatedAt,
+                    LatestArtifact = latestArtifact,
+                };
+
+                results.Add(prInfo);
+            }
+
+            // Update merged/closed status for subscribed PR
+            if (SubscribedPrNumber.HasValue && !subscribedPrFound)
+            {
+                // PR is no longer in open PRs list - check if merged or closed
+                var prStatusUrl = $"https://api.github.com/repos/{owner}/{repo}/pulls/{SubscribedPrNumber}";
+                var statusResponse = await client.GetAsync(prStatusUrl, cancellationToken);
+
+                if (statusResponse.IsSuccessStatusCode)
+                {
+                    var statusJson = await statusResponse.Content.ReadAsStringAsync(cancellationToken);
+                    var statusData = JsonSerializer.Deserialize<JsonElement>(statusJson);
+                    var state = statusData.GetProperty("state").GetString();
+
+                    IsPrMergedOrClosed = state != null && !state.Equals("open", StringComparison.OrdinalIgnoreCase);
+                    if (IsPrMergedOrClosed)
+                    {
+                        logger.LogInformation("Subscribed PR #{PrNumber} has been merged/closed", SubscribedPrNumber);
+                    }
+                }
+            }
+
+            logger.LogInformation("Found {Count} open PRs", results.Count);
+            return results;
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to fetch open pull requests");
+            return results;
+        }
+    }
+
     /// <inheritdoc/>
     public async Task DownloadUpdatesAsync(UpdateInfo updateInfo, IProgress<UpdateProgress>? progress = null, CancellationToken cancellationToken = default)
     {
@@ -242,9 +549,8 @@ public async Task DownloadUpdatesAsync(UpdateInfo updateInfo, IProgress<UpdatePr
 
         try
         {
-            _logger.LogInformation("Downloading update {Version}...", updateInfo.TargetFullRelease.Version);
+            logger.LogInformation("Downloading update {Version}...", updateInfo.TargetFullRelease.Version);
 
-            // Wrap Velopack progress into our UpdateProgress model
             Action<int>? velopackProgress = null;
             if (progress != null)
             {
@@ -269,11 +575,11 @@ public async Task DownloadUpdatesAsync(UpdateInfo updateInfo, IProgress<UpdatePr
                 IsCompleted = true,
             });
 
-            _logger.LogInformation("Update downloaded successfully");
+            logger.LogInformation("Update downloaded successfully");
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to download updates");
+            logger.LogError(ex, "Failed to download updates");
             throw;
         }
     }
@@ -290,13 +596,30 @@ public void ApplyUpdatesAndRestart(UpdateInfo updateInfo)
 
         try
         {
-            _logger.LogInformation("Applying update {Version} and restarting...", updateInfo.TargetFullRelease.Version);
+            logger.LogInformation("Applying update {Version} and restarting...", updateInfo.TargetFullRelease.Version);
+            logger.LogInformation("Update package: {Package}", updateInfo.TargetFullRelease.FileName);
+            logger.LogInformation("Current app will exit and restart with new version");
+
             _updateManager.ApplyUpdatesAndRestart(updateInfo.TargetFullRelease);
+
+            // If we reach here, restart might have failed
+            logger.LogWarning("ApplyUpdatesAndRestart returned without exiting - this is unexpected");
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to apply updates and restart");
-            throw;
+            logger.LogError(ex, "Failed to apply updates and restart. Attempting fallback to ApplyUpdatesAndExit...");
+
+            // Try fallback to exit-only mode
+            try
+            {
+                _updateManager.ApplyUpdatesAndExit(updateInfo.TargetFullRelease);
+                logger.LogInformation("Fallback to ApplyUpdatesAndExit succeeded. Please restart the application manually.");
+            }
+            catch (Exception fallbackEx)
+            {
+                logger.LogError(fallbackEx, "Fallback to ApplyUpdatesAndExit also failed");
+                throw new InvalidOperationException("Failed to apply update. Both restart and exit methods failed.", ex);
+            }
         }
     }
 
@@ -312,49 +635,355 @@ public void ApplyUpdatesAndExit(UpdateInfo updateInfo)
 
         try
         {
-            _logger.LogInformation("Applying update {Version} and exiting...", updateInfo.TargetFullRelease.Version);
+            logger.LogInformation("Applying update {Version} and exiting...", updateInfo.TargetFullRelease.Version);
             _updateManager.ApplyUpdatesAndExit(updateInfo.TargetFullRelease);
         }
         catch (Exception ex)
         {
-            _logger.LogError(ex, "Failed to apply updates and exit");
+            logger.LogError(ex, "Failed to apply updates and exit");
             throw;
         }
     }
 
     /// <inheritdoc/>
-    public bool IsUpdatePendingRestart => _updateManager?.UpdatePendingRestart != null;
+    public async Task InstallPrArtifactAsync(PullRequestInfo prInfo, IProgress<UpdateProgress>? progress = null, CancellationToken cancellationToken = default)
+    {
+        if (prInfo.LatestArtifact == null)
+        {
+            throw new InvalidOperationException($"PR #{prInfo.Number} has no artifacts available");
+        }
 
-    /// <inheritdoc/>
-    public bool HasUpdateAvailableFromGitHub
+        if (!gitHubTokenStorage.HasToken())
+        {
+            throw new InvalidOperationException("GitHub PAT required to download PR artifacts");
+        }
+
+        SimpleHttpServer? server = null;
+        string? tempDir = null;
+
+        try
+        {
+            progress?.Report(new UpdateProgress { Status = "Downloading PR artifact...", PercentComplete = 0 });
+
+            var token = await gitHubTokenStorage.LoadTokenAsync();
+            if (token == null)
+            {
+                throw new InvalidOperationException("Failed to load GitHub PAT");
+            }
+
+            using var client = CreateConfiguredHttpClient(token);
+            var owner = AppConstants.GitHubRepositoryOwner;
+            var repo = AppConstants.GitHubRepositoryName;
+            var artifactId = prInfo.LatestArtifact.ArtifactId;
+
+            // GitHub Actions artifacts are returned as ZIP files via the API,
+            // even if individual files were uploaded. This is a GitHub Actions platform limitation.
+            // The /zip endpoint is the only way to download artifacts.
+            var downloadUrl = $"https://api.github.com/repos/{owner}/{repo}/actions/artifacts/{artifactId}/zip";
+            logger.LogInformation("Downloading PR #{Number} artifact from {Url}", prInfo.Number, downloadUrl);
+
+            var response = await client.GetAsync(downloadUrl, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+            response.EnsureSuccessStatusCode();
+
+            // Create temp directory
+            tempDir = Path.Combine(Path.GetTempPath(), $"genhub-pr{prInfo.Number}-{Guid.NewGuid():N}");
+            Directory.CreateDirectory(tempDir);
+
+            var zipPath = Path.Combine(tempDir, "artifact.zip");
+            using (var fileStream = File.Create(zipPath))
+            {
+                await response.Content.CopyToAsync(fileStream, cancellationToken);
+            }
+
+            progress?.Report(new UpdateProgress { Status = "Extracting artifact...", PercentComplete = 30 });
+
+            // Extract the ZIP to access the .nupkg file
+            // Note: The artifact now contains ONLY the .nupkg file (Setup.exe and RELEASES are separate artifacts)
+            ZipFile.ExtractToDirectory(zipPath, tempDir);
+
+            // Find .nupkg file - should be the only file in the artifact
+            var nupkgFiles = Directory.GetFiles(tempDir, "*.nupkg", SearchOption.AllDirectories);
+
+            // Prefer platform-appropriate nupkg based on current runtime
+            var isWindows = RuntimeInformation.IsOSPlatform(OSPlatform.Windows);
+            var isLinux = RuntimeInformation.IsOSPlatform(OSPlatform.Linux);
+
+            var nupkgFile = isWindows
+                ? nupkgFiles.FirstOrDefault(f => Path.GetFileName(f).Contains("-win", StringComparison.OrdinalIgnoreCase))
+                  ?? nupkgFiles.FirstOrDefault(f => !Path.GetFileName(f).Contains("-linux", StringComparison.OrdinalIgnoreCase))
+                : isLinux
+                ? nupkgFiles.FirstOrDefault(f => Path.GetFileName(f).Contains("-linux", StringComparison.OrdinalIgnoreCase))
+                  ?? nupkgFiles.FirstOrDefault()
+                : nupkgFiles.FirstOrDefault();
+
+            if (nupkgFile == null)
+            {
+                throw new FileNotFoundException("No .nupkg file found in PR artifact");
+            }
+
+            logger.LogInformation("Found nupkg: {File}", Path.GetFileName(nupkgFile));
+
+            // Create releases.win.json (Velopack format)
+            var releasesPath = Path.Combine(tempDir, "releases.win.json");
+            var nupkgFileName = Path.GetFileName(nupkgFile);
+            var fileInfo = new FileInfo(nupkgFile);
+            var sha1 = CalculateSHA1(nupkgFile);
+            var sha256 = CalculateSHA256(nupkgFile);
+
+            // Extract version from nupkg filename (e.g., GenHub-0.0.160-pr3-full.nupkg -> 0.0.160-pr3)
+            var versionMatch = System.Text.RegularExpressions.Regex.Match(nupkgFileName, @"GenHub-(.+)-full\.nupkg", System.Text.RegularExpressions.RegexOptions.IgnoreCase);
+            var fileVersion = versionMatch.Success ? versionMatch.Groups[1].Value : prInfo.LatestArtifact.Version;
+
+            var releasesJson = new
+            {
+                Assets = new[]
+                {
+                    new
+                    {
+                        PackageId = "GenHub",
+                        Version = fileVersion,
+                        Type = "Full",
+                        FileName = nupkgFileName,
+                        SHA1 = sha1,
+                        SHA256 = sha256,
+                        Size = fileInfo.Length,
+                    },
+                },
+            };
+
+            var jsonContent = System.Text.Json.JsonSerializer.Serialize(releasesJson);
+            await File.WriteAllTextAsync(releasesPath, jsonContent, cancellationToken);
+            logger.LogInformation("Created releases.win.json with version {Version}", fileVersion);
+
+            progress?.Report(new UpdateProgress { Status = "Starting local server...", PercentComplete = 50 });
+
+            // Start HTTP server
+            var port = FindAvailablePort();
+            server = new SimpleHttpServer(nupkgFile, releasesPath, port, logger);
+            server.Start();
+
+            progress?.Report(new UpdateProgress { Status = "Preparing update...", PercentComplete = 60 });
+
+            // For PR artifacts, we bypass Velopack's version check entirely
+            // This allows users to "switch" to any PR build, even if it's technically "older"
+            // We construct a VelopackAsset directly from the nupkg file
+            logger.LogInformation("Bypassing version check for PR artifact installation");
+
+            var asset = new VelopackAsset
+            {
+                PackageId = "GenHub",
+                Version = NuGet.Versioning.SemanticVersion.Parse(fileVersion),
+                Type = VelopackAssetType.Full,
+                FileName = nupkgFileName,
+                SHA1 = sha1,
+                SHA256 = sha256,
+                Size = fileInfo.Length,
+            };
+
+            progress?.Report(new UpdateProgress { Status = "Downloading update...", PercentComplete = 70 });
+
+            // Point Velopack to localhost for download - use the secret token from the server for security
+            var source = new SimpleWebSource($"http://localhost:{port}/{server.SecretToken}/");
+            var localUpdateManager = new UpdateManager(source);
+
+            try
+            {
+                // Check for updates - may return null if version check fails
+                var updateInfo = await localUpdateManager.CheckForUpdatesAsync();
+
+                if (updateInfo == null)
+                {
+                    // Version check failed - strip build metadata and try comparing base versions
+                    var currentVersionStr = AppConstants.AppVersion.Split('+')[0]; // Strip build metadata
+                    var targetVersionStr = fileVersion.Split('+')[0]; // Strip build metadata
+
+                    logger.LogWarning("Cannot install PR artifact: current version ({Current}) >= target ({Target})",
+                        currentVersionStr, targetVersionStr);
+                    logger.LogInformation("Full versions: current={CurrentFull}, target={TargetFull}",
+                        AppConstants.AppVersion, fileVersion);
+
+                    // Check if they're actually the same version (ignoring build metadata)
+                    if (currentVersionStr.Equals(targetVersionStr, StringComparison.OrdinalIgnoreCase))
+                    {
+                        throw new InvalidOperationException(
+                            $"PR build {fileVersion} is already installed (current: {AppConstants.AppVersion}). " +
+                            $"This is the same version with different build metadata.");
+                    }
+                    else
+                    {
+                        throw new InvalidOperationException(
+                            $"Cannot install PR build {fileVersion}: Current version ({AppConstants.AppVersion}) is newer. " +
+                            $"To install this older PR build, uninstall GenHub first, then run Setup.exe from the PR artifact.");
+                    }
+                }
+
+                // Download from localhost
+                await localUpdateManager.DownloadUpdatesAsync(updateInfo, p =>
+                {
+                    progress?.Report(new UpdateProgress
+                    {
+                        Status = "Downloading update...",
+                        PercentComplete = 70 + (int)(p * 0.2), // 70-90%
+                    });
+                });
+
+                progress?.Report(new UpdateProgress { Status = "Installing update...", PercentComplete = 90 });
+
+                logger.LogInformation("Applying PR #{Number} update and restarting", prInfo.Number);
+                logger.LogInformation("Update version: {Version}", updateInfo.TargetFullRelease.Version);
+                logger.LogInformation("Update package: {Package}", updateInfo.TargetFullRelease.FileName);
+
+                try
+                {
+                    // Use ApplyUpdatesAndRestart to automatically restart the app
+                    logger.LogInformation("Using ApplyUpdatesAndRestart for PR artifact installation");
+                    localUpdateManager.ApplyUpdatesAndRestart(updateInfo.TargetFullRelease);
+
+                    // If we get here, the exit might not have happened immediately
+                    logger.LogWarning("ApplyUpdatesAndExit returned without exiting - waiting for exit...");
+                    await Task.Delay(5000, cancellationToken);
+
+                    logger.LogError("Application did not exit after ApplyUpdatesAndExit. Update may have failed.");
+                    throw new InvalidOperationException("Application did not exit after applying update");
+                }
+                catch (Exception restartEx)
+                {
+                    logger.LogError(restartEx, "Failed to apply PR artifact update");
+                    logger.LogError("Update file: {File}", updateInfo.TargetFullRelease.FileName);
+                    logger.LogError("Update version: {Version}", updateInfo.TargetFullRelease.Version);
+                    throw;
+                }
+            }
+            finally
+            {
+                // Note: UpdateManager doesn't implement IDisposable, so no cleanup needed
+            }
+        }
+        catch (Exception ex)
+        {
+            logger.LogError(ex, "Failed to install PR artifact");
+            progress?.Report(new UpdateProgress { Status = "Installation failed", HasError = true, ErrorMessage = ex.Message });
+            throw;
+        }
+        finally
+        {
+            // Cleanup
+            server?.Dispose();
+
+            if (tempDir != null && Directory.Exists(tempDir))
+            {
+                try
+                {
+                    Directory.Delete(tempDir, recursive: true);
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning(ex, "Failed to cleanup temp directory: {Path}", tempDir);
+                }
+            }
+        }
+    }
+
+    /// <summary>
+    /// Creates the Velopack UpdateManager, or null if running in debug/uninstalled mode.
+    /// </summary>
+    private static UpdateManager? CreateUpdateManager(ILogger logger)
     {
-        get
+        try
         {
-            _logger.LogDebug("HasUpdateAvailableFromGitHub property accessed: {Value}", _hasUpdateFromGitHub);
-            return _hasUpdateFromGitHub;
+            var source = new GithubSource(AppConstants.GitHubRepositoryUrl, string.Empty, true);
+            var manager = new UpdateManager(source);
+            logger.LogInformation("Velopack UpdateManager initialized for: {Repository}", AppConstants.GitHubRepositoryUrl);
+            return manager;
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Velopack UpdateManager not available (running from Debug)");
+            return null;
         }
     }
 
-    /// <inheritdoc/>
-    public string? LatestVersionFromGitHub
+    private static string CalculateSHA1(string filePath)
     {
-        get
+        using var stream = File.OpenRead(filePath);
+        using var sha1 = System.Security.Cryptography.SHA1.Create();
+        var hash = sha1.ComputeHash(stream);
+        return BitConverter.ToString(hash).Replace("-", string.Empty);
+    }
+
+    private static string CalculateSHA256(string filePath)
+    {
+        using var stream = File.OpenRead(filePath);
+        using var sha256 = System.Security.Cryptography.SHA256.Create();
+        var hash = sha256.ComputeHash(stream);
+        return BitConverter.ToString(hash).Replace("-", string.Empty);
+    }
+
+    private static int FindAvailablePort()
+    {
+        var listener = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
+        listener.Start();
+        var port = ((System.Net.IPEndPoint)listener.LocalEndpoint).Port;
+        listener.Stop();
+        return port;
+    }
+
+    /// <summary>
+    /// Extracts version from artifact name.
+    /// Expected format: genhub-velopack-{platform}-{version}
+    /// Version format: 0.0.X or 0.0.X-prY (e.g., "0.0.150" or "0.0.150-pr42").
+    /// </summary>
+    private static string? ExtractVersionFromArtifactName(string artifactName)
+    {
+        // Try both windows and linux prefixes
+        var prefixes = new[] { "genhub-velopack-windows-", "genhub-velopack-linux-" };
+
+        foreach (var prefix in prefixes)
         {
-            _logger.LogDebug("LatestVersionFromGitHub property accessed: '{Value}'", _latestVersionFromGitHub ?? "NULL");
-            return _latestVersionFromGitHub;
+            if (artifactName.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                var version = artifactName[prefix.Length..];
+                return string.IsNullOrWhiteSpace(version) ? null : version;
+            }
         }
+
+        return null;
     }
 
     /// <summary>
-    /// Gets or creates an HttpClient instance with proper configuration.
+    /// Converts SecureString to plain string.
     /// </summary>
-    /// <returns>An HttpClient instance.</returns>
-    private HttpClient CreateConfiguredHttpClient()
+    private static string SecureStringToString(SecureString secureString)
     {
-        var client = _httpClientFactory.CreateClient();
+        var ptr = Marshal.SecureStringToGlobalAllocUnicode(secureString);
+        try
+        {
+            return Marshal.PtrToStringUni(ptr) ?? string.Empty;
+        }
+        finally
+        {
+            Marshal.ZeroFreeGlobalAllocUnicode(ptr);
+        }
+    }
+
+    /// <summary>
+    /// Creates an HttpClient with standard configuration.
+    /// </summary>
+    private HttpClient CreateConfiguredHttpClient(SecureString? token = null)
+    {
+        var client = httpClientFactory.CreateClient();
         client.DefaultRequestHeaders.UserAgent.Clear();
         client.DefaultRequestHeaders.UserAgent.Add(
             new ProductInfoHeaderValue("GenHub", AppConstants.AppVersion));
+        client.DefaultRequestHeaders.Accept.Add(
+            new MediaTypeWithQualityHeaderValue("application/vnd.github+json"));
+
+        if (token != null)
+        {
+            var plainText = SecureStringToString(token);
+            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", plainText);
+        }
+
         return client;
     }
 }
diff --git a/GenHub/GenHub/Features/AppUpdate/ViewModels/UpdateNotificationViewModel.cs b/GenHub/GenHub/Features/AppUpdate/ViewModels/UpdateNotificationViewModel.cs
index f14851ffe..4624ef27e 100644
--- a/GenHub/GenHub/Features/AppUpdate/ViewModels/UpdateNotificationViewModel.cs
+++ b/GenHub/GenHub/Features/AppUpdate/ViewModels/UpdateNotificationViewModel.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Collections.ObjectModel;
 using System.Diagnostics;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Input;
@@ -7,6 +9,8 @@
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
 using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.GitHub;
 using GenHub.Core.Models.AppUpdate;
 using GenHub.Features.AppUpdate.Interfaces;
 using Microsoft.Extensions.Logging;
@@ -21,6 +25,7 @@ public partial class UpdateNotificationViewModel : ObservableObject, IDisposable
 {
     private readonly IVelopackUpdateManager _velopackUpdateManager;
     private readonly ILogger<UpdateNotificationViewModel> _logger;
+    private readonly IUserSettingsService _userSettingsService;
     private readonly CancellationTokenSource _cancellationTokenSource;
     private UpdateInfo? _currentUpdateInfo;
 
@@ -91,26 +96,73 @@ public partial class UpdateNotificationViewModel : ObservableObject, IDisposable
     [ObservableProperty]
     private string _errorMessage = string.Empty;
 
+    [ObservableProperty]
+    private ObservableCollection<PullRequestInfo> _availablePullRequests = new();
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(DisplayLatestVersion))]
+    private PullRequestInfo? _subscribedPr;
+
+    [ObservableProperty]
+    private bool _isLoadingPullRequests;
+
+    [ObservableProperty]
+    private bool _hasPat;
+
+    [ObservableProperty]
+    private bool _showPrMergedWarning;
+
     /// <summary>
     /// Initializes a new instance of the <see cref="UpdateNotificationViewModel"/> class.
     /// </summary>
     /// <param name="velopackUpdateManager">The Velopack update manager.</param>
     /// <param name="logger">The logger.</param>
+    /// <param name="userSettingsService">The user settings service.</param>
+    /// <param name="gitHubTokenStorage">The GitHub token storage.</param>
     public UpdateNotificationViewModel(
         IVelopackUpdateManager velopackUpdateManager,
-        ILogger<UpdateNotificationViewModel> logger)
+        ILogger<UpdateNotificationViewModel> logger,
+        IUserSettingsService userSettingsService,
+        IGitHubTokenStorage? gitHubTokenStorage = null)
     {
         _velopackUpdateManager = velopackUpdateManager ?? throw new ArgumentNullException(nameof(velopackUpdateManager));
         _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        _userSettingsService = userSettingsService ?? throw new ArgumentNullException(nameof(userSettingsService));
         _cancellationTokenSource = new CancellationTokenSource();
 
         CheckForUpdatesCommand = new AsyncRelayCommand(CheckForUpdatesAsync, () => !IsChecking);
         DismissCommand = new RelayCommand(DismissUpdate);
 
-        _logger.LogInformation("UpdateNotificationViewModel initialized with Velopack");
+        // Check if PAT is available
+        HasPat = gitHubTokenStorage?.HasToken() ?? false;
+
+        _logger.LogInformation("UpdateNotificationViewModel initialized with Velopack (HasPat={HasPat})", HasPat);
+
+        // Automatically check for updates and load PRs when dialog opens
+        _ = InitializeAsync();
+    }
+
+    /// <summary>
+    /// Initializes the view model by checking for updates and loading PRs.
+    /// </summary>
+    private async Task InitializeAsync()
+    {
+        // Load subscribed PR from settings
+        var settings = _userSettingsService.Get();
+        if (settings.SubscribedPrNumber.HasValue)
+        {
+            _velopackUpdateManager.SubscribedPrNumber = settings.SubscribedPrNumber;
+            _logger.LogInformation("Loaded subscribed PR #{PrNumber} from settings", settings.SubscribedPrNumber);
+        }
+
+        // Load PRs FIRST so SubscribedPr object is populated before update check
+        if (HasPat)
+        {
+            await LoadPullRequestsAsync();
+        }
 
-        // Automatically check for updates when dialog opens
-        _ = CheckForUpdatesAsync();
+        // Now check for updates - SubscribedPr will be properly populated
+        await CheckForUpdatesAsync();
     }
 
     /// <summary>
@@ -160,6 +212,13 @@ public string DisplayLatestVersion
                 return "Unknown";
             }
 
+            // If we are subscribed to a PR and the update matches that PR's latest artifact
+            if (SubscribedPr?.LatestArtifact != null &&
+                string.Equals(SubscribedPr.LatestArtifact.Version, LatestVersion, StringComparison.OrdinalIgnoreCase))
+            {
+                return SubscribedPr.LatestArtifact.DisplayVersion;
+            }
+
             return LatestVersion.StartsWith("v", StringComparison.OrdinalIgnoreCase)
                 ? LatestVersion
                 : $"v{LatestVersion}";
@@ -197,16 +256,70 @@ private async Task CheckForUpdatesAsync()
 
             _logger.LogInformation("Starting Velopack update check");
 
+            // Check if subscribed to a PR - this takes precedence over main branch releases
+            if (SubscribedPr?.LatestArtifact != null)
+            {
+                // For subscribed PRs, compare versions without build metadata
+                // Strip everything after '+' to ignore build hashes
+                var currentVersionBase = CurrentAppVersion.Split('+')[0];
+                var prVersionBase = SubscribedPr.LatestArtifact.Version.Split('+')[0];
+
+                if (!string.Equals(prVersionBase, currentVersionBase, StringComparison.OrdinalIgnoreCase))
+                {
+                    // Check if this version was already dismissed
+                    var settings = _userSettingsService.Get();
+                    if (!string.Equals(prVersionBase, settings.DismissedUpdateVersion, StringComparison.OrdinalIgnoreCase))
+                    {
+                        IsUpdateAvailable = true;
+                        LatestVersion = prVersionBase;
+                        ReleaseNotesUrl = $"{AppConstants.GitHubRepositoryUrl}/pull/{SubscribedPr.Number}";
+                        StatusMessage = $"New PR build available: {SubscribedPr.LatestArtifact.DisplayVersion}";
+                        _logger.LogInformation(
+                            "Subscribed to PR #{PrNumber}, new build available: {Version}",
+                            SubscribedPr.Number,
+                            LatestVersion);
+                        return; // Exit early - PR update takes priority
+                    }
+                    else
+                    {
+                        _logger.LogInformation("PR update {Version} was previously dismissed", prVersionBase);
+                        StatusMessage = $"You dismissed the update for PR #{SubscribedPr.Number}";
+                        return;
+                    }
+                }
+                else
+                {
+                    // We are on the latest PR build
+                    IsUpdateAvailable = false;
+                    StatusMessage = $"You are on the latest build for PR #{SubscribedPr.Number}";
+                    _logger.LogInformation("Already on latest PR #{PrNumber} build", SubscribedPr.Number);
+                    return; // Exit early - no need to check main branch
+                }
+            }
+
+            // Check main branch releases (only if not subscribed to PR)
             _currentUpdateInfo = await _velopackUpdateManager.CheckForUpdatesAsync(_cancellationTokenSource.Token);
 
-            // Check BOTH UpdateInfo (for installed app with working Velopack) AND GitHub flag (for installed app where Velopack has issues)
+            // Check both UpdateInfo (for installed app with working Velopack) and GitHub flag (for installed app where Velopack has issues)
             if (_currentUpdateInfo != null)
             {
-                IsUpdateAvailable = true;
-                LatestVersion = _currentUpdateInfo.TargetFullRelease.Version.ToString();
-                ReleaseNotesUrl = AppConstants.GitHubRepositoryUrl + "/releases/tag/v" + LatestVersion;
-                StatusMessage = $"Update available: v{LatestVersion}";
-                _logger.LogInformation("Update available from UpdateManager: {Version}", LatestVersion);
+                var version = _currentUpdateInfo.TargetFullRelease.Version.ToString();
+
+                // Check if this version was already dismissed
+                var settings = _userSettingsService.Get();
+                if (!string.Equals(version, settings.DismissedUpdateVersion, StringComparison.OrdinalIgnoreCase))
+                {
+                    IsUpdateAvailable = true;
+                    LatestVersion = version;
+                    ReleaseNotesUrl = AppConstants.GitHubRepositoryUrl + "/releases/tag/v" + LatestVersion;
+                    StatusMessage = $"Update available: v{LatestVersion}";
+                    _logger.LogInformation("Update available from UpdateManager: {Version}", LatestVersion);
+                }
+                else
+                {
+                    _logger.LogInformation("Update {Version} was previously dismissed", version);
+                    StatusMessage = "You're up to date!";
+                }
             }
             else if (_velopackUpdateManager.HasUpdateAvailableFromGitHub)
             {
@@ -217,18 +330,28 @@ private async Task CheckForUpdatesAsync()
                     _velopackUpdateManager.HasUpdateAvailableFromGitHub,
                     githubVersion ?? "NULL");
 
-                IsUpdateAvailable = true;
-                LatestVersion = githubVersion ?? "Unknown";
-                ReleaseNotesUrl = AppConstants.GitHubRepositoryUrl + "/releases/tag/v" + LatestVersion;
-                StatusMessage = $"Update available: v{LatestVersion}";
-                _logger.LogInformation("Update available from GitHub API: {Version}", LatestVersion);
+                // Check if this version was already dismissed
+                var settings = _userSettingsService.Get();
+                if (!string.Equals(githubVersion, settings.DismissedUpdateVersion, StringComparison.OrdinalIgnoreCase))
+                {
+                    IsUpdateAvailable = true;
+                    LatestVersion = githubVersion ?? "Unknown";
+                    ReleaseNotesUrl = AppConstants.GitHubRepositoryUrl + "/releases/tag/v" + LatestVersion;
+                    StatusMessage = $"Update available: v{LatestVersion}";
+                    _logger.LogInformation("Update available from GitHub API: {Version}", LatestVersion);
+                }
+                else
+                {
+                    _logger.LogInformation("GitHub update {Version} was previously dismissed", githubVersion);
+                    StatusMessage = "You're up to date!";
+                }
             }
             else
             {
                 IsUpdateAvailable = false;
                 LatestVersion = string.Empty;
                 StatusMessage = "You're up to date!";
-                _logger.LogInformation("No updates available");
+                _logger.LogInformation("No updates available from Velopack/GitHub");
             }
         }
         catch (Exception ex)
@@ -275,6 +398,18 @@ private async Task InstallUpdateAsync()
             return;
         }
 
+        // 1. Handle PR Artifact Update
+        // If we are subscribed to a PR and the LatestVersion matches the PR artifact, install that instead
+        if (SubscribedPr?.LatestArtifact != null &&
+            string.Equals(SubscribedPr.LatestArtifact.Version, LatestVersion, StringComparison.OrdinalIgnoreCase))
+        {
+            _logger.LogInformation("Installing PR artifact update via InstallUpdateAsync override");
+            await InstallPrArtifactAsync();
+            return;
+        }
+
+        // 2. Handle Standard Velopack Update
+
         // If we don't have UpdateInfo, we need to show error that installed app is required
         if (_currentUpdateInfo == null)
         {
@@ -343,13 +478,80 @@ private async Task InstallUpdateAsync()
     }
 
     /// <summary>
-    /// Dismisses the update notification.
+    /// Installs the subscribed PR artifact.
+    /// </summary>
+    [RelayCommand(CanExecute = nameof(CanInstallPrArtifact))]
+    private async Task InstallPrArtifactAsync()
+    {
+        if (SubscribedPr == null || SubscribedPr.LatestArtifact == null)
+        {
+            _logger.LogWarning("Cannot install PR artifact - no PR subscribed or no artifact available");
+            return;
+        }
+
+        IsInstalling = true;
+        HasError = false;
+        ErrorMessage = string.Empty;
+        DownloadProgress = 0;
+
+        try
+        {
+            _logger.LogInformation("Installing PR #{Number} artifact", SubscribedPr.Number);
+
+            var progress = new Progress<UpdateProgress>(p =>
+            {
+                Dispatcher.UIThread.InvokeAsync(() =>
+                {
+                    InstallationProgress = p;
+                    StatusMessage = p.Status;
+                    DownloadProgress = p.PercentComplete;
+                });
+            });
+
+            await _velopackUpdateManager.InstallPrArtifactAsync(SubscribedPr, progress, _cancellationTokenSource.Token);
+
+            // App will restart, this code won't execute
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to install PR artifact");
+            HasError = true;
+            ErrorMessage = $"PR installation failed: {ex.Message}";
+            StatusMessage = "PR installation failed";
+            InstallationProgress = new UpdateProgress
+            {
+                Status = "Installation failed",
+                HasError = true,
+                ErrorMessage = ex.Message,
+            };
+        }
+        finally
+        {
+            IsInstalling = false;
+        }
+    }
+
+    /// <summary>
+    /// Gets a value indicating whether the PR artifact can be installed.
+    /// </summary>
+    public bool CanInstallPrArtifact => SubscribedPr?.LatestArtifact != null && !IsInstalling;
+
+    /// <summary>
+    /// Dismisses the update notification and persists the dismissed version.
     /// </summary>
     private void DismissUpdate()
     {
+        // Persist the dismissed version to prevent showing it again
+        if (!string.IsNullOrEmpty(LatestVersion))
+        {
+            _userSettingsService.Update(s => s.DismissedUpdateVersion = LatestVersion);
+            _ = _userSettingsService.SaveAsync();
+            _logger.LogInformation("Dismissed update version {Version}", LatestVersion);
+        }
+
         IsUpdateAvailable = false;
         _currentUpdateInfo = null;
-        StatusMessage = "Ready to check for updates";
+        StatusMessage = "Update dismissed";
         HasError = false;
         ErrorMessage = string.Empty;
         LatestVersion = string.Empty;
@@ -393,4 +595,105 @@ private void UpdateCommandStates()
         OnPropertyChanged(nameof(InstallButtonText));
         InstallUpdateCommand.NotifyCanExecuteChanged();
     }
+
+    /// <summary>
+    /// Loads the list of open pull requests with available artifacts.
+    /// </summary>
+    [RelayCommand]
+    private async Task LoadPullRequestsAsync()
+    {
+        if (!HasPat || IsLoadingPullRequests)
+        {
+            return;
+        }
+
+        IsLoadingPullRequests = true;
+        AvailablePullRequests.Clear();
+
+        try
+        {
+            _logger.LogInformation("Loading open pull requests with artifacts");
+
+            var prs = await _velopackUpdateManager.GetOpenPullRequestsAsync(_cancellationTokenSource.Token);
+
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                foreach (var pr in prs)
+                {
+                    AvailablePullRequests.Add(pr);
+                }
+            });
+
+            // Check if we had a subscribed PR that got merged/closed
+            if (_velopackUpdateManager.IsPrMergedOrClosed && _velopackUpdateManager.SubscribedPrNumber.HasValue)
+            {
+                ShowPrMergedWarning = true;
+                StatusMessage = $"PR #{_velopackUpdateManager.SubscribedPrNumber} has been merged. Select a new PR or switch to MAIN.";
+                _logger.LogInformation("Subscribed PR has been merged/closed, showing warning");
+            }
+
+            // Update subscribed PR info
+            if (_velopackUpdateManager.SubscribedPrNumber.HasValue)
+            {
+                SubscribedPr = AvailablePullRequests.FirstOrDefault(p => p.Number == _velopackUpdateManager.SubscribedPrNumber);
+            }
+
+            _logger.LogInformation("Loaded {Count} open PRs", AvailablePullRequests.Count);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to load pull requests");
+            StatusMessage = "Failed to load PRs";
+        }
+        finally
+        {
+            IsLoadingPullRequests = false;
+        }
+    }
+
+    /// <summary>
+    /// Subscribes to updates from a specific PR.
+    /// </summary>
+    /// <param name="prNumber">The PR number to subscribe to.</param>
+    [RelayCommand]
+    private void SubscribeToPr(int prNumber)
+    {
+        _velopackUpdateManager.SubscribedPrNumber = prNumber;
+        SubscribedPr = AvailablePullRequests.FirstOrDefault(p => p.Number == prNumber);
+        ShowPrMergedWarning = false;
+
+        // Persist to settings
+        _userSettingsService.Update(s => s.SubscribedPrNumber = prNumber);
+        _ = _userSettingsService.SaveAsync();
+
+        if (SubscribedPr != null)
+        {
+            StatusMessage = $"Subscribed to PR #{prNumber}: {SubscribedPr.Title}";
+            _logger.LogInformation("Subscribed to PR #{PrNumber}", prNumber);
+        }
+    }
+
+    partial void OnSubscribedPrChanged(PullRequestInfo? value)
+    {
+        OnPropertyChanged(nameof(CanInstallPrArtifact));
+        InstallPrArtifactCommand.NotifyCanExecuteChanged();
+    }
+
+    /// <summary>
+    /// Unsubscribes from PR updates and switches to MAIN branch.
+    /// </summary>
+    [RelayCommand]
+    private void UnsubscribeFromPr()
+    {
+        _velopackUpdateManager.SubscribedPrNumber = null;
+        SubscribedPr = null;
+        ShowPrMergedWarning = false;
+        StatusMessage = "Switched to MAIN branch updates";
+
+        // Persist to settings
+        _userSettingsService.Update(s => s.SubscribedPrNumber = null);
+        _ = _userSettingsService.SaveAsync();
+
+        _logger.LogInformation("Unsubscribed from PR, switched to MAIN");
+    }
 }
diff --git a/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationView.axaml b/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationView.axaml
index 006d07a30..597d9f96d 100644
--- a/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationView.axaml
+++ b/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationView.axaml
@@ -4,98 +4,47 @@
     x:Class="GenHub.Features.AppUpdate.Views.UpdateNotificationView"
     x:DataType="vm:UpdateNotificationViewModel">
 
-    <Grid RowDefinitions="Auto,Auto,*,Auto" Margin="20">
-        <!-- Header section with version -->
-        <Border Grid.Row="0"
-            Padding="20"
-            Margin="0,0,0,16"
-            Background="#20FFFFFF"
-            CornerRadius="8">
-            <Grid ColumnDefinitions="*,Auto">
-                <Grid Grid.Column="0" ColumnDefinitions="Auto,*">
-                    <Border Grid.Column="0"
-                        Background="#3399FF"
-                        CornerRadius="8"
-                        Width="40" Height="40"
-                        Margin="0,0,16,0"
-                        VerticalAlignment="Center">
-                        <Viewbox Width="20" Height="20">
-                            <Path Data="M9,12L11,14L15,10L13.5,8.5L11,11L9.5,9.5L9,12M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2M12,4A8,8 0 0,1 20,12A8,8 0 0,1 12,20A8,8 0 0,1 4,12A8,8 0 0,1 12,4Z"
-                                Fill="White" Stretch="Uniform" />
-                        </Viewbox>
-                    </Border>
+    <Grid RowDefinitions="Auto,*,Auto" Margin="20,12,20,12">
 
-                    <StackPanel Grid.Column="1" VerticalAlignment="Center">
-                        <TextBlock Text="Current Version" Foreground="#90FFFFFF" FontSize="14" Margin="0,0,0,4" />
-                        <TextBlock Text="{Binding CurrentAppVersion, FallbackValue=1.0.0}" FontWeight="SemiBold" FontSize="22" Foreground="White" />
-                    </StackPanel>
-                </Grid>
-
-                <Button Grid.Column="1"
-                    Command="{Binding CheckForUpdatesCommand}"
-                    IsEnabled="{Binding IsCheckButtonEnabled}"
-                    VerticalAlignment="Center"
-                    Background="#3399FF"
-                    Foreground="White"
-                    Padding="16,10"
-                    CornerRadius="8"
-                    BorderThickness="0">
-                    <StackPanel Orientation="Horizontal" Spacing="8">
-                        <Viewbox Width="16" Height="16">
-                            <Path Data="M17.65,6.35C16.2,4.9 14.21,4 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20C15.73,20 18.84,17.45 19.73,14H17.65C16.83,16.33 14.61,18 12,18A6,6 0 0,1 6,12A6,6 0 0,1 12,6C13.66,6 15.14,6.69 16.22,7.78L13,11H20V4L17.65,6.35Z"
-                                Fill="White" Stretch="Uniform" />
-                        </Viewbox>
-                        <TextBlock Text="Check For Updates" VerticalAlignment="Center" FontWeight="Medium" />
-                    </StackPanel>
-                    <Button.Styles>
-                        <Style Selector="Button:pointerover">
-                            <Setter Property="Background" Value="#4DB3FF" />
-                        </Style>
-                        <Style Selector="Button:pressed">
-                            <Setter Property="Background" Value="#0080E5" />
-                        </Style>
-                    </Button.Styles>
-                </Button>
-            </Grid>
-        </Border>
-
-        <!-- Status section -->
-        <Border Grid.Row="1"
-            Background="#15FFFFFF"
+        <!-- Status section with refresh button -->
+        <Border Grid.Row="0"
+            Background="#2D2D30"
             CornerRadius="8"
-            Padding="20"
-            Margin="0,0,0,16">
-            <Grid ColumnDefinitions="*,Auto">
-                <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="12">
-                    <Border Background="#3399FF" CornerRadius="6" Width="28" Height="28" VerticalAlignment="Center">
+            Padding="12,10"
+            Margin="0,0,0,12">
+            <Grid ColumnDefinitions="Auto,*,Auto">
+                <Border Grid.Column="0" Background="#7B1FA2" CornerRadius="6" Width="28" Height="28" VerticalAlignment="Center" Margin="0,0,10,0">
+                    <Viewbox Width="16" Height="16">
+                        <Path Data="M13,9H11V7H13M13,17H11V11H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z"
+                            Fill="White" Stretch="Uniform" />
+                    </Viewbox>
+                </Border>
+                <TextBlock Grid.Column="1" Text="{Binding StatusMessage, FallbackValue=Ready}" Foreground="White" FontSize="14" VerticalAlignment="Center" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding StatusMessage}" />
+                <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="8">
+                    <ProgressBar Width="80" Height="6" Value="{Binding DownloadProgress}" Maximum="100" IsVisible="{Binding IsDownloading}" Foreground="#7B1FA2" Background="#404040" CornerRadius="3" />
+                    <Button Command="{Binding CheckForUpdatesCommand}" IsEnabled="{Binding IsCheckButtonEnabled}" Background="#7B1FA2" Foreground="White" Padding="8" CornerRadius="6" BorderThickness="0" Cursor="Hand" ToolTip.Tip="Check For Updates">
                         <Viewbox Width="16" Height="16">
-                            <Path Data="M13,9H11V7H13M13,17H11V11H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z"
-                                Fill="White" Stretch="Uniform" />
+                            <Path Data="M17.65,6.35C16.2,4.9 14.21,4 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20C15.73,20 18.84,17.45 19.73,14H17.65C16.83,16.33 14.61,18 12,18A6,6 0 0,1 6,12A6,6 0 0,1 12,6C13.66,6 15.14,6.69 16.22,7.78L13,11H20V4L17.65,6.35Z" Fill="White" Stretch="Uniform" />
                         </Viewbox>
-                    </Border>
-                    <TextBlock Text="{Binding StatusMessage, FallbackValue=Ready}" Foreground="White" FontSize="15" VerticalAlignment="Center" />
+                        <Button.Styles>
+                            <Style Selector="Button:pointerover"><Setter Property="Background" Value="#9C27B0" /></Style>
+                            <Style Selector="Button:pressed"><Setter Property="Background" Value="#6A1B9A" /></Style>
+                        </Button.Styles>
+                    </Button>
                 </StackPanel>
-
-                <ProgressBar Grid.Column="1"
-                    Width="100"
-                    Height="6"
-                    Value="{Binding DownloadProgress}"
-                    Maximum="100"
-                    IsVisible="{Binding IsDownloading}"
-                    Foreground="#3399FF"
-                    Background="#25FFFFFF"
-                    CornerRadius="3" />
             </Grid>
         </Border>
 
-        <!-- Update available section -->
-        <Border Grid.Row="2"
-            Background="#1A4DB3FF"
-            CornerRadius="8"
-            Padding="24"
-            Margin="0,0,0,16"
-            IsVisible="{Binding IsUpdateAvailable}">
-            <StackPanel Spacing="16">
+        <!-- Main Content Area -->
+        <ScrollViewer Grid.Row="1" Margin="0,0,0,4" VerticalScrollBarVisibility="Auto">
+            <StackPanel>
+                <!-- Update available section -->
+                <Border Background="#1A7B1FA2"
+                    CornerRadius="8"
+                    Padding="24"
+                    Margin="0,0,0,16"
+                    IsVisible="{Binding IsUpdateAvailable}">
+                    <StackPanel Spacing="16">
                 <Grid ColumnDefinitions="Auto,*">
                     <Border Grid.Column="0"
                         Background="#3399FF"
@@ -118,12 +67,12 @@
                     </StackPanel>
                 </Grid>
 
-                <Border Background="#15FFFFFF" CornerRadius="6" Padding="16">
+                <Border Background="#3D3D40" CornerRadius="6" Padding="16">
                     <StackPanel Spacing="8">
                         <TextBlock Text="What's new:" FontWeight="SemiBold" Foreground="White" FontSize="14" />
-                        <TextBlock Text="This update includes bug fixes, performance improvements, and new features." 
-                                   Foreground="#B3FFFFFF" 
-                                   FontSize="13" 
+                        <TextBlock Text="This update includes bug fixes, performance improvements, and new features."
+                                   Foreground="#B3FFFFFF"
+                                   FontSize="13"
                                    TextWrapping="Wrap" />
                         <Button Command="{Binding ViewReleaseNotesCommand}"
                                 Content="View Release Notes"
@@ -143,8 +92,8 @@
                 </Border>
 
                 <!-- Installation progress -->
-                <Border Background="#15FFFFFF" 
-                        CornerRadius="6" 
+                <Border Background="#3D3D40"
+                        CornerRadius="6"
                         Padding="16"
                         IsVisible="{Binding IsInstalling}">
                     <StackPanel Spacing="12">
@@ -152,8 +101,8 @@
                         <ProgressBar Value="{Binding InstallationProgress.PercentComplete}"
                                      Maximum="100"
                                      Height="8"
-                                     Foreground="#3399FF"
-                                     Background="#25FFFFFF"
+                                     Foreground="#7B1FA2"
+                                     Background="#505050"
                                      CornerRadius="4" />
                         <TextBlock Foreground="#90FFFFFF" FontSize="12">
                             <Run Text="{Binding InstallationProgress.PercentComplete, StringFormat={}{0:F0}}" />
@@ -164,35 +113,188 @@
             </StackPanel>
         </Border>
 
-        <!-- Error section -->
-        <Border Grid.Row="2"
-            Background="#1AFF4444"
-            BorderBrush="#FF4444"
-            BorderThickness="1"
-            CornerRadius="8"
-            Padding="16"
-            Margin="0,0,0,16"
-            IsVisible="{Binding HasError}">
-            <StackPanel Orientation="Horizontal" Spacing="12">
-                <Border Background="#FF4444" CornerRadius="6" Width="28" Height="28">
+                <!-- Error section -->
+                <Border Background="#1AFF4444"
+                    BorderBrush="#FF4444"
+                    BorderThickness="1"
+                    CornerRadius="8"
+                    Padding="16"
+                    Margin="0,0,0,16"
+                    IsVisible="{Binding HasError}">
+            <Grid ColumnDefinitions="Auto,*">
+                <Border Grid.Column="0" Background="#FF4444" CornerRadius="6" Width="28" Height="28" Margin="0,0,12,0" VerticalAlignment="Top">
                     <Viewbox Width="16" Height="16">
                         <Path Data="M12,2L1,21H23M12,6L19.53,19H4.47M11,10V14H13V10M11,16V18H13V16"
                             Fill="White" Stretch="Uniform" />
                     </Viewbox>
                 </Border>
-                <TextBlock Text="{Binding ErrorMessage}" 
-                           Foreground="#FFB3B3" 
-                           TextWrapping="Wrap" 
+                <TextBlock Grid.Column="1"
+                           Text="{Binding ErrorMessage}"
+                           Foreground="#FFB3B3"
+                           TextWrapping="Wrap"
                            VerticalAlignment="Center" />
+            </Grid>
+        </Border>
+
+                <!-- PR Merged Warning -->
+                <Border Background="#1AFFAA00"
+                    BorderBrush="#FFAA00"
+                    BorderThickness="1"
+                    CornerRadius="8"
+                    Padding="16"
+                    Margin="0,0,0,8"
+                    IsVisible="{Binding ShowPrMergedWarning}">
+            <StackPanel Orientation="Horizontal" Spacing="12">
+                <Border Background="#FFAA00" CornerRadius="6" Width="28" Height="28">
+                    <Viewbox Width="16" Height="16">
+                        <Path Data="M13,9H11V7H13M13,17H11V11H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z"
+                            Fill="White" Stretch="Uniform" />
+                    </Viewbox>
+                </Border>
+                <StackPanel VerticalAlignment="Center">
+                    <TextBlock Text="Subscribed PR Merged" FontWeight="SemiBold" Foreground="#FFCC00" />
+                    <TextBlock Text="Select a new PR or switch to MAIN branch" Foreground="#B3FFFFFF" FontSize="12" />
+                </StackPanel>
+                <Button Command="{Binding UnsubscribeFromPrCommand}"
+                        Content="Switch to MAIN"
+                        Background="#25FFFFFF"
+                        Foreground="White"
+                        Padding="12,6"
+                        CornerRadius="4"
+                        BorderThickness="0"
+                        VerticalAlignment="Center"
+                        HorizontalAlignment="Right" />
             </StackPanel>
         </Border>
 
+                <!-- Open PRs section (for PAT users) -->
+                <Border Background="#2D2D30"
+                    CornerRadius="8"
+                    Padding="16"
+                    Margin="0,0,0,8"
+                    IsVisible="{Binding HasPat}">
+                    <!-- Content directly in stack panel, outer scrollviewer handles scrolling -->
+                    <StackPanel Spacing="12">
+                    <Grid ColumnDefinitions="*,Auto">
+                        <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="8">
+                            <Viewbox Width="16" Height="16" VerticalAlignment="Center">
+                                <Path Data="M6,3A1,1 0 0,1 7,4V4.88C8.06,4.44 9.5,4 11,4C14,4 14,6 16,6C19,6 20,4 20,4V12C20,12 19,14 16,14C13,14 13,12 11,12C8,12 8,14 6,14V21H4V4A1,1 0 0,1 5,3H6Z"
+                                    Fill="#3399FF" Stretch="Uniform" />
+                            </Viewbox>
+                            <TextBlock Text="Open Pull Requests" FontWeight="SemiBold" Foreground="White" VerticalAlignment="Center" />
+                            <TextBlock Text="{Binding AvailablePullRequests.Count, StringFormat='({0})'}" Foreground="#90FFFFFF" FontSize="12" VerticalAlignment="Center" />
+                        </StackPanel>
+                        <Button Grid.Column="1"
+                            Command="{Binding LoadPullRequestsCommand}"
+                            Content="↻ Refresh"
+                            Background="Transparent"
+                            Foreground="#7B1FA2"
+                            BorderThickness="0"
+                            Padding="8,4"
+                            VerticalAlignment="Center" />
+                    </Grid>
+
+                    <!-- Loading indicator -->
+                    <StackPanel Orientation="Horizontal" Spacing="8" IsVisible="{Binding IsLoadingPullRequests}">
+                        <ProgressBar IsIndeterminate="True" Width="100" Height="4" Foreground="#7B1FA2" />
+                        <TextBlock Text="Loading PRs..." Foreground="#90FFFFFF" FontSize="12" />
+                    </StackPanel>
+
+                    <!-- PR List -->
+                    <ItemsControl ItemsSource="{Binding AvailablePullRequests}">
+                        <ItemsControl.ItemTemplate>
+                            <DataTemplate>
+                                <Border Background="#3D3D40" CornerRadius="4" Padding="10" Margin="0,2">
+                                    <Grid ColumnDefinitions="*,Auto">
+                                        <StackPanel Grid.Column="0" Spacing="2">
+                                            <Grid ColumnDefinitions="Auto,*">
+                                                <TextBlock Grid.Column="0" Text="{Binding Number, StringFormat='#{0}'}" FontWeight="SemiBold" Foreground="#9C27B0" Margin="0,0,6,0" />
+                                                <TextBlock Grid.Column="1" Text="{Binding Title}" Foreground="White" TextTrimming="CharacterEllipsis" ToolTip.Tip="{Binding Title}" />
+                                            </Grid>
+                                            <StackPanel Orientation="Horizontal" Spacing="8">
+                                                <TextBlock Text="{Binding Author}" Foreground="#90FFFFFF" FontSize="11" />
+                                                <TextBlock Text="{Binding BranchName}" Foreground="#60FFFFFF" FontSize="11" />
+                                                <TextBlock Text="{Binding LatestArtifact.DisplayVersion}" Foreground="#67B26F" FontSize="11" IsVisible="{Binding HasArtifacts}" />
+                                            </StackPanel>
+                                        </StackPanel>
+                                        <Button Grid.Column="1"
+                                            Command="{Binding $parent[ItemsControl].((vm:UpdateNotificationViewModel)DataContext).SubscribeToPrCommand}"
+                                            CommandParameter="{Binding Number}"
+                                            Content="Subscribe"
+                                            Background="#7B1FA2"
+                                            Foreground="White"
+                                            Padding="10,6"
+                                            CornerRadius="4"
+                                            BorderThickness="0"
+                                            FontSize="11"
+                                            FontWeight="Medium"
+                                            Cursor="Hand"
+                                            VerticalAlignment="Center">
+                                            <Button.Styles>
+                                                <Style Selector="Button:pointerover">
+                                                    <Setter Property="Background" Value="#9C27B0" />
+                                                </Style>
+                                            </Button.Styles>
+                                        </Button>
+                                    </Grid>
+                                </Border>
+                            </DataTemplate>
+                        </ItemsControl.ItemTemplate>
+                    </ItemsControl>
+
+                    <!-- Current subscription -->
+                    <Border Background="#1A67B26F" CornerRadius="4" Padding="12" IsVisible="{Binding SubscribedPr, Converter={x:Static ObjectConverters.IsNotNull}}">
+                        <StackPanel Spacing="8">
+                            <Grid ColumnDefinitions="*,Auto">
+                                <StackPanel Grid.Column="0" Spacing="4">
+                                    <TextBlock Text="Currently Subscribed" Foreground="#67B26F" FontWeight="SemiBold" FontSize="12" />
+                                    <Grid ColumnDefinitions="Auto,*">
+                                        <TextBlock Grid.Column="0" Text="{Binding SubscribedPr.Number, StringFormat='#{0}'}" Foreground="White" FontWeight="SemiBold" Margin="0,0,6,0" />
+                                        <TextBlock Grid.Column="1"
+                                                   Text="{Binding SubscribedPr.Title}"
+                                                   Foreground="#B3FFFFFF"
+                                                   TextTrimming="CharacterEllipsis"
+                                                   ToolTip.Tip="{Binding SubscribedPr.Title}" />
+                                    </Grid>
+                                    <TextBlock Text="{Binding SubscribedPr.DisplayVersion, StringFormat='Version: {0}'}"
+                                               Foreground="#B3FFFFFF" FontSize="11" />
+                                </StackPanel>
+                                <Button Grid.Column="1"
+                                    Command="{Binding UnsubscribeFromPrCommand}"
+                                    Content="Unsubscribe"
+                                    Background="Transparent"
+                                    Foreground="#FF6666"
+                                    BorderThickness="0"
+                                    Padding="8,4"
+                                    VerticalAlignment="Center" />
+                            </Grid>
+
+                            <!-- Install PR Build Button -->
+                            <Button Command="{Binding InstallPrArtifactCommand}"
+                                    IsEnabled="{Binding CanInstallPrArtifact}"
+                                    HorizontalAlignment="Stretch"
+                                    Background="#67B26F"
+                                    Foreground="White"
+                                    Padding="12,8"
+                                    CornerRadius="4">
+                                <StackPanel Orientation="Horizontal" Spacing="8" HorizontalAlignment="Center">
+                                    <PathIcon Data="M13 3L4 14h7l-1 7 9-11h-7l1-7z" Width="14" Height="14" Foreground="White" />
+                                    <TextBlock Text="Install PR Build" FontWeight="SemiBold" />
+                                </StackPanel>
+                            </Button>
+                        </StackPanel>
+                    </Border>
+                </StackPanel>
+                </Border>
+            </StackPanel>
+        </ScrollViewer>
+
         <!-- Action buttons -->
-        <Grid Grid.Row="3" ColumnDefinitions="*,Auto,Auto" Margin="0,8,0,0">
+        <Grid Grid.Row="2" ColumnDefinitions="*,Auto,Auto" Margin="0,4,0,0">
             <Button Grid.Column="1"
                 Command="{Binding DismissCommand}"
                 Content="Dismiss"
-                Background="#25FFFFFF"
+                Background="#404040"
                 Foreground="White"
                 Padding="20,12"
                 Margin="0,0,12,0"
@@ -200,7 +302,7 @@
                 BorderThickness="0">
                 <Button.Styles>
                     <Style Selector="Button:pointerover">
-                        <Setter Property="Background" Value="#30FFFFFF" />
+                        <Setter Property="Background" Value="#505050" />
                     </Style>
                 </Button.Styles>
             </Button>
@@ -208,7 +310,7 @@
             <Button Grid.Column="2"
                 Command="{Binding InstallUpdateCommand}"
                 IsEnabled="{Binding CanDownloadUpdate}"
-                Background="#3399FF"
+                Background="#7B1FA2"
                 Foreground="White"
                 Padding="20,12"
                 CornerRadius="8"
@@ -222,13 +324,13 @@
                 </StackPanel>
                 <Button.Styles>
                     <Style Selector="Button:pointerover">
-                        <Setter Property="Background" Value="#4DB3FF" />
+                        <Setter Property="Background" Value="#9C27B0" />
                     </Style>
                     <Style Selector="Button:pressed">
-                        <Setter Property="Background" Value="#0080E5" />
+                        <Setter Property="Background" Value="#6A1B9A" />
                     </Style>
                     <Style Selector="Button:disabled">
-                        <Setter Property="Background" Value="#40FFFFFF" />
+                        <Setter Property="Background" Value="#505050" />
                         <Setter Property="Foreground" Value="#60FFFFFF" />
                     </Style>
                 </Button.Styles>
diff --git a/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationWindow.axaml b/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationWindow.axaml
index f424c80f7..69b602e1f 100644
--- a/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationWindow.axaml
+++ b/GenHub/GenHub/Features/AppUpdate/Views/UpdateNotificationWindow.axaml
@@ -6,6 +6,7 @@
         Width="580" Height="800"
         MinWidth="500" MinHeight="580"
         Title="GenHub Updates"
+        Icon="/Assets/Icons/generalshub-icon.png"
         WindowStartupLocation="CenterScreen"
         SystemDecorations="BorderOnly"
         TransparencyLevelHint="AcrylicBlur"
@@ -28,8 +29,8 @@
         <Border CornerRadius="8" BoxShadow="0 4 20 0 #50000000">
             <Border.Background>
                 <LinearGradientBrush StartPoint="0%,0%" EndPoint="100%,100%">
-                    <GradientStop Color="#242938" Offset="0" />
-                    <GradientStop Color="#1e2430" Offset="1" />
+                    <GradientStop Color="#1E1E1E" Offset="0" />
+                    <GradientStop Color="#1A1A1A" Offset="1" />
                 </LinearGradientBrush>
             </Border.Background>
         </Border>
@@ -42,24 +43,13 @@
                   Classes="TitleBarArea"
                   x:Name="TitleBarGrid"
                   PointerPressed="TitleBar_PointerPressed">
-                  
                 <!-- App icon and title -->
                 <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="12" VerticalAlignment="Center">
                     <!-- App icon  -->
-                    <Border Width="28" Height="28" 
-                            Background="#3399FF" 
-                            CornerRadius="6"
-                            Margin="8,0,0,0">
-                        <Viewbox Width="14" Height="14"
-                                 HorizontalAlignment="Center"
-                                 VerticalAlignment="Center">
-                            <Path Data="M12,8A3,3 0 0,0 9,11A3,3 0 0,0 12,14A3,3 0 0,0 15,11A3,3 0 0,0 12,8M12,2L13.09,8.26L22,9L15,14L17,21L12,18L7,21L9,14L2,9L10.91,8.26L12,2Z" 
-                                  Fill="White" 
-                                  Stretch="Uniform" />
-                        </Viewbox>
-                    </Border>
-                    
-                    <TextBlock Text="GenHub Updates" 
+                    <Image Source="/Assets/Icons/generalshub-icon.png"
+                           Width="28" Height="28"
+                           Margin="8,0,0,0" />
+                    <TextBlock Text="GenHub Updates"
                               VerticalAlignment="Center"
                               FontSize="16" FontWeight="SemiBold"
                               Foreground="White" />
diff --git a/GenHub/GenHub/Features/GitHub/ViewModels/GitHubTokenDialogViewModel.cs b/GenHub/GenHub/Features/GitHub/ViewModels/GitHubTokenDialogViewModel.cs
new file mode 100644
index 000000000..3fae0fa8a
--- /dev/null
+++ b/GenHub/GenHub/Features/GitHub/ViewModels/GitHubTokenDialogViewModel.cs
@@ -0,0 +1,239 @@
+using System;
+using System.Diagnostics;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Security;
+using System.Threading.Tasks;
+using Avalonia.Media;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.GitHub;
+using Microsoft.Extensions.Logging;
+
+namespace GenHub.Features.GitHub.ViewModels;
+
+/// <summary>
+/// ViewModel for the GitHub PAT token dialog.
+/// </summary>
+public partial class GitHubTokenDialogViewModel(IGitHubTokenStorage tokenStorage, IHttpClientFactory httpClientFactory, ILogger<GitHubTokenDialogViewModel> logger) : ObservableObject, IDisposable
+{
+    private SecureString? _secureToken;
+
+    [ObservableProperty]
+    private bool _isValidating;
+
+    [ObservableProperty]
+    private string _validationMessage = string.Empty;
+
+    [ObservableProperty]
+    private IBrush _validationMessageColor = Brushes.White;
+
+    [ObservableProperty]
+    private bool _hasValidationMessage;
+
+    [ObservableProperty]
+    private bool _isTokenValid;
+
+    /// <summary>
+    /// Event raised when the dialog should close with success.
+    /// </summary>
+    public event Action? SaveCompleted;
+
+    /// <summary>
+    /// Event raised when the dialog should close without saving.
+    /// </summary>
+    public event Action? CancelRequested;
+
+    /// <summary>
+    /// Sets the token from the password box (called from code-behind).
+    /// </summary>
+    /// <param name="token">The token string to set.</param>
+    public void SetToken(string token)
+    {
+        _secureToken?.Dispose();
+        _secureToken = new SecureString();
+        foreach (var c in token)
+        {
+            _secureToken.AppendChar(c);
+        }
+
+        _secureToken.MakeReadOnly();
+
+        // Clear validation when token changes
+        ValidationMessage = string.Empty;
+        HasValidationMessage = false;
+        IsTokenValid = false;
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        _secureToken?.Dispose();
+    }
+
+    /// <summary>
+    /// Opens the GitHub PAT creation page in the browser.
+    /// </summary>
+    [RelayCommand]
+    private void OpenPatCreation()
+    {
+        try
+        {
+            Process.Start(new ProcessStartInfo(GitHubConstants.PatCreationUrl) { UseShellExecute = true });
+        }
+        catch (Exception ex)
+        {
+            logger?.LogError(ex, "Failed to open PAT creation URL");
+        }
+    }
+
+    /// <summary>
+    /// Validates the entered token against GitHub API.
+    /// </summary>
+    [RelayCommand]
+    private async Task ValidateTokenAsync()
+    {
+        if (_secureToken == null || _secureToken.Length == 0)
+        {
+            ValidationMessage = GitHubConstants.EnterTokenMessage;
+            ValidationMessageColor = Brushes.Orange;
+            HasValidationMessage = true;
+            return;
+        }
+
+        if (httpClientFactory == null)
+        {
+            logger?.LogWarning("HttpClientFactory not available for token validation");
+            return;
+        }
+
+        IsValidating = true;
+        ValidationMessage = string.Empty;
+        HasValidationMessage = false;
+
+        try
+        {
+            using var client = httpClientFactory.CreateClient();
+            client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("GenHub", AppConstants.AppVersion));
+            client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", GetPlainToken());
+
+            var response = await client.GetAsync("https://api.github.com/user");
+
+            if (response.IsSuccessStatusCode)
+            {
+                // Check for required scopes
+                if (response.Headers.TryGetValues("X-OAuth-Scopes", out var scopes))
+                {
+                    var scopeString = string.Join(",", scopes);
+                    if (scopeString.Contains("repo", StringComparison.OrdinalIgnoreCase))
+                    {
+                        ValidationMessage = "✓ Token is valid with repo access!";
+                        ValidationMessageColor = Brushes.LightGreen;
+                        IsTokenValid = true;
+                        logger?.LogInformation("GitHub token validated successfully with repo scope");
+                    }
+                    else
+                    {
+                        ValidationMessage = "⚠ Token is valid but missing 'repo' scope. Some features may not work.";
+                        ValidationMessageColor = Brushes.Orange;
+                        IsTokenValid = true; // Still allow saving
+                        logger?.LogWarning("GitHub token valid but missing repo scope");
+                    }
+                }
+                else
+                {
+                    ValidationMessage = "✓ Token is valid!";
+                    ValidationMessageColor = Brushes.LightGreen;
+                    IsTokenValid = true;
+                }
+            }
+            else if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
+            {
+                ValidationMessage = "✗ Token is invalid or expired.";
+                ValidationMessageColor = Brushes.Salmon;
+                IsTokenValid = false;
+                logger?.LogWarning("GitHub token validation failed: Unauthorized");
+            }
+            else
+            {
+                ValidationMessage = $"✗ Validation failed: {response.StatusCode}";
+                ValidationMessageColor = Brushes.Salmon;
+                IsTokenValid = false;
+                logger?.LogWarning("GitHub token validation failed: {StatusCode}", response.StatusCode);
+            }
+        }
+        catch (Exception ex)
+        {
+            ValidationMessage = $"✗ Error: {ex.Message}";
+            ValidationMessageColor = Brushes.Salmon;
+            IsTokenValid = false;
+            logger?.LogError(ex, "Error validating GitHub token");
+        }
+        finally
+        {
+            IsValidating = false;
+            HasValidationMessage = true;
+        }
+    }
+
+    /// <summary>
+    /// Saves the token and closes the dialog.
+    /// </summary>
+    [RelayCommand]
+    private async Task SaveAsync()
+    {
+        if (_secureToken == null || _secureToken.Length == 0)
+        {
+            ValidationMessage = GitHubConstants.EnterTokenMessage;
+            ValidationMessageColor = Brushes.Orange;
+            HasValidationMessage = true;
+            return;
+        }
+
+        if (tokenStorage == null)
+        {
+            logger?.LogWarning("Token storage not available");
+            return;
+        }
+
+        try
+        {
+            await tokenStorage.SaveTokenAsync(_secureToken);
+            logger?.LogInformation("GitHub PAT saved successfully");
+            SaveCompleted?.Invoke();
+        }
+        catch (Exception ex)
+        {
+            ValidationMessage = $"✗ Failed to save token: {ex.Message}";
+            ValidationMessageColor = Brushes.Salmon;
+            HasValidationMessage = true;
+            logger?.LogError(ex, "Failed to save GitHub token");
+        }
+    }
+
+    /// <summary>
+    /// Cancels the dialog.
+    /// </summary>
+    [RelayCommand]
+    private void Cancel()
+    {
+        CancelRequested?.Invoke();
+    }
+
+    private string GetPlainToken()
+    {
+        if (_secureToken == null)
+            return string.Empty;
+
+        var ptr = System.Runtime.InteropServices.Marshal.SecureStringToGlobalAllocUnicode(_secureToken);
+        try
+        {
+            return System.Runtime.InteropServices.Marshal.PtrToStringUni(ptr) ?? string.Empty;
+        }
+        finally
+        {
+            System.Runtime.InteropServices.Marshal.ZeroFreeGlobalAllocUnicode(ptr);
+        }
+    }
+}
\ No newline at end of file
diff --git a/GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml b/GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml
new file mode 100644
index 000000000..ff65239c2
--- /dev/null
+++ b/GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml
@@ -0,0 +1,170 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:vm="using:GenHub.Features.GitHub.ViewModels"
+        xmlns:const="using:GenHub.Core.Constants"
+        mc:Ignorable="d" d:DesignWidth="500" d:DesignHeight="450"
+        x:Class="GenHub.Features.GitHub.Views.GitHubTokenDialogView"
+        x:DataType="vm:GitHubTokenDialogViewModel"
+        Title="{x:Static const:GitHubConstants.GitHubAuthenticationTitle}"
+        Icon="/Assets/Icons/generalshub-icon.png"
+        Width="500"
+        Height="450"
+        WindowStartupLocation="CenterOwner"
+        CanResize="False"
+        SystemDecorations="BorderOnly">
+
+    <Window.Resources>
+    </Window.Resources>
+
+    <Window.Styles>
+        <Style Selector="Button.primary">
+            <Setter Property="Background" Value="#0078D4"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderThickness" Value="0"/>
+            <Setter Property="CornerRadius" Value="4"/>
+            <Setter Property="Padding" Value="16,8"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+        </Style>
+
+        <Style Selector="Button.primary:pointerover">
+            <Setter Property="Background" Value="#106EBE"/>
+        </Style>
+
+        <Style Selector="Button.secondary">
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="Foreground" Value="#E0E0E0"/>
+            <Setter Property="BorderBrush" Value="#606060"/>
+            <Setter Property="BorderThickness" Value="1"/>
+            <Setter Property="CornerRadius" Value="4"/>
+            <Setter Property="Padding" Value="16,8"/>
+        </Style>
+
+        <Style Selector="Button.secondary:pointerover">
+            <Setter Property="Background" Value="#404040"/>
+        </Style>
+
+        <Style Selector="TextBox">
+            <Setter Property="Background" Value="#1E1E1E"/>
+            <Setter Property="Foreground" Value="White"/>
+            <Setter Property="BorderBrush" Value="#606060"/>
+            <Setter Property="CornerRadius" Value="4"/>
+            <Setter Property="Padding" Value="8"/>
+        </Style>
+    </Window.Styles>
+
+    <Design.DataContext>
+        <vm:GitHubTokenDialogViewModel />
+    </Design.DataContext>
+
+    <Grid RowDefinitions="*,Auto" Background="#1A1A1A">
+        <!-- Content -->
+        <Border Grid.Row="0" Padding="32" Background="#2D2D30">
+            <Grid RowDefinitions="Auto,Auto,Auto,Auto,Auto,Auto,*">
+                <!-- Header with Icon -->
+                <StackPanel Grid.Row="0" Orientation="Horizontal" Spacing="12" Margin="0,0,0,20">
+                    <TextBlock Text="🔑" FontSize="24" VerticalAlignment="Center"/>
+                    <TextBlock Text="{x:Static const:GitHubConstants.GitHubTokenHeaderLabel}"
+                              FontSize="18"
+                              FontWeight="SemiBold"
+                              Foreground="White"
+                              VerticalAlignment="Center" />
+                </StackPanel>
+
+                <TextBlock Grid.Row="1"
+                          Text="{x:Static const:GitHubConstants.GitHubTokenDescription}"
+                          TextWrapping="Wrap"
+                          Foreground="#AAAAAA"
+                          LineHeight="22"
+                          Margin="0,0,0,16" />
+
+                <!-- Token Input -->
+                <StackPanel Grid.Row="2" Spacing="8" Margin="0,0,0,16">
+                    <TextBlock Text="Personal Access Token:"
+                              FontWeight="Medium"
+                              Foreground="White"
+                              FontSize="13"/>
+                    <TextBox x:Name="TokenPasswordBox"
+                            PasswordChar="*"
+                            TextChanged="OnTokenPasswordChanged"
+                            Watermark="{x:Static const:GitHubConstants.TokenWatermark}"
+                            MinHeight="36"/>
+                </StackPanel>
+
+                <!-- Create PAT Link -->
+                <StackPanel Grid.Row="3" Spacing="8" Margin="0,0,0,16">
+                    <TextBlock Text="Don't have a Personal Access Token?"
+                              Foreground="#AAAAAA"
+                              FontSize="12"/>
+                    <Button Content="Create a GitHub Personal Access Token →"
+                            Command="{Binding OpenPatCreationCommand}"
+                            Background="Transparent"
+                            BorderThickness="0"
+                            Padding="0"
+                            HorizontalAlignment="Left"
+                            Cursor="Hand"
+                            ToolTip.Tip="Click to open GitHub PAT creation page">
+                        <Button.Styles>
+                            <Style Selector="Button">
+                                <Setter Property="Foreground" Value="#7B1FA2"/>
+                                <Setter Property="FontSize" Value="12"/>
+                            </Style>
+                            <Style Selector="Button:pointerover">
+                                <Setter Property="Foreground" Value="#9C27B0"/>
+                            </Style>
+                        </Button.Styles>
+                    </Button>
+                </StackPanel>
+
+                <!-- Validate Button -->
+                <StackPanel Grid.Row="4" Orientation="Horizontal" Spacing="12" Margin="0,0,0,16">
+                    <Button Content="{x:Static const:GitHubConstants.ValidateTokenButtonLabel}"
+                            Command="{Binding ValidateTokenCommand}"
+                            Classes="secondary"
+                            IsEnabled="{Binding !IsValidating}" />
+                </StackPanel>
+
+                <!-- Loading/Progress Indicator -->
+                <StackPanel Grid.Row="5"
+                           Orientation="Horizontal"
+                           Spacing="8"
+                           Margin="0,0,0,8"
+                           IsVisible="{Binding IsValidating}">
+                    <TextBlock Text="🔄" FontSize="14"/>
+                    <TextBlock Text="Validating token..."
+                              Foreground="#AAAAAA"
+                              FontSize="12"/>
+                </StackPanel>
+
+                <!-- Validation Message - Simple text only, no background box -->
+                <TextBlock Grid.Row="6"
+                          Text="{Binding ValidationMessage}"
+                          TextWrapping="Wrap"
+                          FontSize="13"
+                          Foreground="{Binding ValidationMessageColor}"
+                          Margin="0,4,0,20"
+                          IsVisible="{Binding HasValidationMessage}" />
+            </Grid>
+        </Border>
+
+        <!-- Buttons -->
+        <Border Grid.Row="1"
+                Background="#2D2D30"
+                BorderBrush="#3F3F46"
+                BorderThickness="0,1,0,0"
+                Padding="32,16">
+            <StackPanel Orientation="Horizontal" HorizontalAlignment="Right" Spacing="12">
+                <Button Content="{x:Static const:GitHubConstants.CancelButtonLabel}"
+                        Command="{Binding CancelCommand}"
+                        Classes="secondary"
+                        IsEnabled="{Binding !IsValidating}" />
+
+                <Button Content="{x:Static const:GitHubConstants.SaveButtonLabel}"
+                        Command="{Binding SaveCommand}"
+                        Classes="primary"
+                        IsEnabled="{Binding IsTokenValid}" />
+            </StackPanel>
+        </Border>
+    </Grid>
+</Window>
diff --git a/GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml.cs b/GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml.cs
new file mode 100644
index 000000000..75702e6d9
--- /dev/null
+++ b/GenHub/GenHub/Features/GitHub/Views/GitHubTokenDialogView.axaml.cs
@@ -0,0 +1,44 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using GenHub.Features.GitHub.ViewModels;
+
+namespace GenHub.Features.GitHub.Views;
+
+/// <summary>
+/// Code-behind for the GitHub Token Dialog view.
+/// </summary>
+public partial class GitHubTokenDialogView : Window
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="GitHubTokenDialogView"/> class.
+    /// </summary>
+    public GitHubTokenDialogView()
+    {
+        InitializeComponent();
+    }
+
+    /// <summary>
+    /// Sets the ViewModel and wires up events.
+    /// </summary>
+    /// <param name="viewModel">The ViewModel to bind to.</param>
+    public void SetViewModel(GitHubTokenDialogViewModel viewModel)
+    {
+        DataContext = viewModel;
+
+        viewModel.SaveCompleted += () => Close(true);
+        viewModel.CancelRequested += () => Close(false);
+    }
+
+    private void OnTokenPasswordChanged(object? sender, TextChangedEventArgs e)
+    {
+        if (sender is TextBox textBox && DataContext is GitHubTokenDialogViewModel vm)
+        {
+            vm.SetToken(textBox.Text ?? string.Empty);
+        }
+    }
+
+    private void InitializeComponent()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+}
\ No newline at end of file
diff --git a/GenHub/GenHub/Features/Settings/ViewModels/SettingsViewModel.cs b/GenHub/GenHub/Features/Settings/ViewModels/SettingsViewModel.cs
index e157d3d97..5fc067dd7 100644
--- a/GenHub/GenHub/Features/Settings/ViewModels/SettingsViewModel.cs
+++ b/GenHub/GenHub/Features/Settings/ViewModels/SettingsViewModel.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Diagnostics;
 using System.IO;
 using System.Linq;
@@ -12,7 +13,10 @@
 using CommunityToolkit.Mvvm.Input;
 using GenHub.Core.Constants;
 using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.GitHub;
+using GenHub.Core.Models.AppUpdate;
 using GenHub.Core.Models.Enums;
+using GenHub.Features.AppUpdate.Interfaces;
 using Microsoft.Extensions.Logging;
 
 namespace GenHub.Features.Settings.ViewModels;
@@ -24,6 +28,8 @@ public partial class SettingsViewModel : ObservableObject, IDisposable
 {
     private readonly IUserSettingsService _userSettingsService;
     private readonly ILogger<SettingsViewModel> _logger;
+    private readonly IGitHubTokenStorage? _gitHubTokenStorage;
+    private readonly IVelopackUpdateManager? _updateManager;
     private readonly Timer _memoryUpdateTimer;
     private bool _isViewVisible = false;
     private bool _disposed = false;
@@ -111,16 +117,52 @@ public partial class SettingsViewModel : ObservableObject, IDisposable
     [ObservableProperty]
     private int _autoGcIntervalDays = StorageConstants.AutoGcIntervalDays;
 
+    // Update settings properties
+    [ObservableProperty]
+    private UpdateChannel _selectedUpdateChannel = UpdateChannel.Prerelease;
+
+    [ObservableProperty]
+    private string _gitHubPatInput = string.Empty;
+
+    [ObservableProperty]
+    private bool _hasGitHubPat;
+
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(PatStatusColor))]
+    private bool _isPatValid;
+
+    [ObservableProperty]
+    private bool _isTestingPat;
+
+    [ObservableProperty]
+    private string _patStatusMessage = string.Empty;
+
+    [ObservableProperty]
+    private bool _isLoadingArtifacts;
+
+    [ObservableProperty]
+    private ObservableCollection<ArtifactUpdateInfo> _availableArtifacts = new();
+
     /// <summary>
     /// Initializes a new instance of the <see cref="SettingsViewModel"/> class.
     /// </summary>
     /// <param name="userSettingsService">The configuration service.</param>
     /// <param name="logger">The logger.</param>
-    public SettingsViewModel(IUserSettingsService userSettingsService, ILogger<SettingsViewModel> logger)
+    /// <param name="gitHubTokenStorage">Optional GitHub token storage for PAT management.</param>
+    /// <param name="updateManager">Optional Velopack update manager for artifact checking.</param>
+    public SettingsViewModel(
+        IUserSettingsService userSettingsService,
+        ILogger<SettingsViewModel> logger,
+        IGitHubTokenStorage? gitHubTokenStorage = null,
+        IVelopackUpdateManager? updateManager = null)
     {
         _userSettingsService = userSettingsService;
         _logger = logger;
+        _gitHubTokenStorage = gitHubTokenStorage;
+        _updateManager = updateManager;
+
         LoadSettings();
+        _ = LoadPatStatusAsync();
 
         // Initialize memory update timer (update every 2 seconds when visible)
         _memoryUpdateTimer = new Timer(UpdateMemoryUsageCallback, null, Timeout.Infinite, Timeout.Infinite);
@@ -204,6 +246,16 @@ public int DownloadTimeoutSeconds
     /// </summary>
     public IEnumerable<WorkspaceStrategy> AvailableWorkspaceStrategies => Enum.GetValues<WorkspaceStrategy>();
 
+    /// <summary>
+    /// Gets the available update channels for selection in the UI.
+    /// </summary>
+    public IEnumerable<UpdateChannel> AvailableUpdateChannels => Enum.GetValues<UpdateChannel>();
+
+    /// <summary>
+    /// Gets the current application version for display.
+    /// </summary>
+    public string CurrentVersion => AppConstants.FullDisplayVersion;
+
     /// <summary>
     /// Disposes the ViewModel and its resources.
     /// </summary>
@@ -346,6 +398,7 @@ private void LoadSettings()
             // Load CAS settings
             CasRootPath = settings.CasConfiguration.CasRootPath;
             EnableAutomaticGc = settings.CasConfiguration.EnableAutomaticGc;
+            SelectedUpdateChannel = settings.UpdateChannel;
             MaxCacheSizeGB = settings.CasConfiguration.MaxCacheSizeBytes / ConversionConstants.BytesPerGigabyte;
             CasMaxConcurrentOperations = settings.CasConfiguration.MaxConcurrentOperations;
             CasVerifyIntegrity = settings.CasConfiguration.VerifyIntegrity;
@@ -386,6 +439,7 @@ private async Task SaveSettings()
                 settings.AllowBackgroundDownloads = AllowBackgroundDownloads;
                 settings.EnableDetailedLogging = EnableDetailedLogging;
                 settings.DefaultWorkspaceStrategy = DefaultWorkspaceStrategy;
+                settings.UpdateChannel = SelectedUpdateChannel;
                 settings.DownloadBufferSize = (int)(DownloadBufferSizeKB * ConversionConstants.BytesPerKilobyte); // Convert KB to bytes
                 settings.DownloadTimeoutSeconds = DownloadTimeoutSeconds;
                 settings.DownloadUserAgent = DownloadUserAgent;
@@ -632,4 +686,252 @@ private void UpdateMemoryUsage()
             CurrentMemoryUsage = 0;
         }
     }
+
+    /// <summary>
+    /// Gets the status color for the PAT indicator.
+    /// </summary>
+    public string PatStatusColor => IsPatValid ? "#4CAF50" : "#888888";
+
+    /// <summary>
+    /// Loads the current PAT status from storage.
+    /// </summary>
+    private async Task LoadPatStatusAsync()
+    {
+        if (_gitHubTokenStorage == null)
+        {
+            HasGitHubPat = false;
+            PatStatusMessage = "Token storage not available";
+            return;
+        }
+
+        try
+        {
+            HasGitHubPat = _gitHubTokenStorage.HasToken();
+            if (HasGitHubPat)
+            {
+                PatStatusMessage = "GitHub PAT configured ✓";
+                IsPatValid = true;
+
+                // If Artifacts channel is selected and we have a PAT, load available artifacts
+                if (SelectedUpdateChannel == UpdateChannel.Artifacts && _updateManager != null)
+                {
+                    await LoadArtifactsAsync();
+                }
+            }
+            else
+            {
+                PatStatusMessage = "No GitHub PAT configured";
+                IsPatValid = false;
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to load PAT status");
+            PatStatusMessage = "Error checking PAT status";
+            HasGitHubPat = false;
+            IsPatValid = false;
+        }
+
+        await Task.CompletedTask;
+    }
+
+    /// <summary>
+    /// Tests the entered GitHub PAT by making an API call.
+    /// </summary>
+    [RelayCommand]
+    private async Task TestPatAsync()
+    {
+        if (string.IsNullOrWhiteSpace(GitHubPatInput))
+        {
+            PatStatusMessage = "Please enter a GitHub PAT";
+            return;
+        }
+
+        if (_gitHubTokenStorage == null)
+        {
+            PatStatusMessage = "Token storage not available";
+            return;
+        }
+
+        IsTestingPat = true;
+        PatStatusMessage = "Testing PAT...";
+
+        try
+        {
+            // Save temporarily to test
+            using var secureString = new System.Security.SecureString();
+            foreach (char c in GitHubPatInput)
+            {
+                secureString.AppendChar(c);
+            }
+
+            await _gitHubTokenStorage.SaveTokenAsync(secureString);
+
+            // Try to check for artifacts to validate the PAT
+            if (_updateManager != null)
+            {
+                // Validate first by making a test call (similar to GitHubTokenDialogViewModel)
+                // Only save after validation succeeds
+                try
+                {
+                    var artifact = await _updateManager.CheckForArtifactUpdatesAsync();
+                    if (artifact != null || _gitHubTokenStorage.HasToken())
+                    {
+                        PatStatusMessage = "PAT validated successfully ✓";
+                        IsPatValid = true;
+                        HasGitHubPat = true;
+                        GitHubPatInput = string.Empty; // Clear input after successful save
+                        return;
+                    }
+                }
+                catch
+                {
+                    // Rollback on validation failure
+                    await _gitHubTokenStorage.DeleteTokenAsync();
+                    throw;
+                }
+            }
+
+            // If we can't fully validate but storage worked, mark as valid
+            PatStatusMessage = "PAT saved (validation pending)";
+            IsPatValid = true;
+            HasGitHubPat = true;
+            GitHubPatInput = string.Empty;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "PAT validation failed");
+            PatStatusMessage = $"Invalid PAT: {ex.Message}";
+            IsPatValid = false;
+        }
+        finally
+        {
+            IsTestingPat = false;
+        }
+    }
+
+    /// <summary>
+    /// Deletes the stored GitHub PAT.
+    /// </summary>
+    [RelayCommand]
+    private async Task DeletePatAsync()
+    {
+        if (_gitHubTokenStorage == null)
+        {
+            return;
+        }
+
+        try
+        {
+            await _gitHubTokenStorage.DeleteTokenAsync();
+            HasGitHubPat = false;
+            IsPatValid = false;
+            PatStatusMessage = "GitHub PAT removed";
+            AvailableArtifacts.Clear();
+
+            // Switch to Prerelease channel if on Artifacts
+            if (SelectedUpdateChannel == UpdateChannel.Artifacts)
+            {
+                SelectedUpdateChannel = UpdateChannel.Prerelease;
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to delete PAT");
+            PatStatusMessage = $"Error: {ex.Message}";
+        }
+    }
+
+    /// <summary>
+    /// Opens the Update Notification window for browsing updates and managing PR subscriptions.
+    /// </summary>
+    [RelayCommand]
+    private void OpenUpdateWindow()
+    {
+        try
+        {
+            var updateWindow = new Features.AppUpdate.Views.UpdateNotificationWindow();
+            updateWindow.Show();
+            _logger.LogInformation("Update window opened from Settings");
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to open update window");
+        }
+    }
+
+    /// <summary>
+    /// Loads available CI artifacts for selection.
+    /// </summary>
+    [RelayCommand]
+    private async Task LoadArtifactsAsync()
+    {
+        if (_updateManager == null || !HasGitHubPat)
+        {
+            PatStatusMessage = "Configure a GitHub PAT to load artifacts";
+            return;
+        }
+
+        IsLoadingArtifacts = true;
+        AvailableArtifacts.Clear();
+
+        try
+        {
+            var artifact = await _updateManager.CheckForArtifactUpdatesAsync();
+            if (artifact != null)
+            {
+                AvailableArtifacts.Add(artifact);
+                PatStatusMessage = $"Found {AvailableArtifacts.Count} artifact(s)";
+            }
+            else
+            {
+                PatStatusMessage = "No artifacts available";
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to load artifacts");
+            PatStatusMessage = $"Error loading artifacts: {ex.Message}";
+        }
+        finally
+        {
+            IsLoadingArtifacts = false;
+        }
+    }
+
+    /// <summary>
+    /// Handles update channel change.
+    /// </summary>
+    partial void OnSelectedUpdateChannelChanged(UpdateChannel value)
+    {
+        _logger.LogInformation("Update channel changed to: {Channel}", value);
+
+        // Update the update manager's channel
+        if (_updateManager != null)
+        {
+            _updateManager.CurrentChannel = value;
+        }
+
+        // Persist setting
+        _userSettingsService.Update(s => s.UpdateChannel = value);
+
+        // Save settings asynchronously with error handling
+        _ = _userSettingsService.SaveAsync().ContinueWith(t =>
+        {
+            if (t.IsFaulted)
+            {
+                _logger.LogError(t.Exception, "Failed to save update channel setting");
+            }
+        });
+
+        // If switching to Artifacts, load available artifacts
+        if (value == UpdateChannel.Artifacts && HasGitHubPat)
+        {
+            _ = LoadArtifactsAsync();
+        }
+        else if (value == UpdateChannel.Artifacts && !HasGitHubPat)
+        {
+            PatStatusMessage = "GitHub PAT required for artifact updates";
+        }
+    }
 }
\ No newline at end of file
diff --git a/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml b/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml
index bc9209f4a..da037fbbc 100644
--- a/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml
+++ b/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml
@@ -56,16 +56,15 @@
     </Style>
     
     <Style Selector="Button.primary-button">
-      <Setter Property="Background" Value="#0078D4" />
+      <Setter Property="Background" Value="#7B1FA2" />
       <Setter Property="Foreground" Value="#FFFFFF" />
-      <Setter Property="BorderBrush" Value="#106EBE" />
+      <Setter Property="BorderBrush" Value="#9C27B0" />
       <Setter Property="Padding" Value="16,8" />
       <Setter Property="CornerRadius" Value="4" />
       <Setter Property="FontWeight" Value="SemiBold" />
     </Style>
-    
     <Style Selector="Button.primary-button:pointerover">
-      <Setter Property="Background" Value="#106EBE" />
+      <Setter Property="Background" Value="#9C27B0" />
     </Style>
     
     <Style Selector="Button.secondary-button">
@@ -449,6 +448,131 @@
         </StackPanel>
       </Border>
 
+      <!-- Update Settings -->
+      <Border Classes="settings-card">
+        <StackPanel Spacing="20">
+          <TextBlock Text="🔄 Updates" Classes="section-header" />
+
+          <!-- Current Version -->
+          <StackPanel Spacing="4">
+            <TextBlock Text="Current Version" Classes="setting-label" />
+            <TextBlock Text="{Binding CurrentVersion}" FontSize="14" Foreground="#67B26F" FontWeight="SemiBold" />
+          </StackPanel>
+
+          <!-- Update Channel Selection -->
+          <StackPanel Spacing="8">
+            <TextBlock Text="Update Channel" Classes="setting-label" />
+            <ComboBox ItemsSource="{Binding AvailableUpdateChannels}"
+                      SelectedItem="{Binding SelectedUpdateChannel}"
+                      HorizontalAlignment="Left"
+                      MinWidth="200" />
+            <TextBlock Classes="setting-description">
+              <Run Text="Stable: Release builds only • " />
+              <Run Text="Prerelease: Alpha/Beta builds • " />
+              <Run Text="Artifacts: CI builds (requires PAT)" />
+            </TextBlock>
+
+            <!-- Manage Updates & PRs Button -->
+            <Button Content="Manage Updates &amp; PRs"
+                    Command="{Binding OpenUpdateWindowCommand}"
+                    Classes="browse-button"
+                    HorizontalAlignment="Left"
+                    Margin="0,8,0,0"
+                    ToolTip.Tip="Browse available updates and subscribe to Pull Requests" />
+          </StackPanel>
+
+          <!-- GitHub PAT for Artifact Access -->
+          <Border Background="#1E1E1E" CornerRadius="4" Padding="15" BorderBrush="#4E4E4E" BorderThickness="1">
+            <StackPanel Spacing="12">
+              <StackPanel Orientation="Horizontal" Spacing="8">
+                <TextBlock Text="🔑" FontSize="16" VerticalAlignment="Center" />
+                <TextBlock Text="GitHub Personal Access Token (for Artifact Updates)"
+                           Classes="setting-label" VerticalAlignment="Center" Margin="0" />
+              </StackPanel>
+
+              <!-- PAT Status -->
+              <StackPanel Orientation="Horizontal" Spacing="8">
+                 <Ellipse Width="8" Height="8" VerticalAlignment="Center"
+                          Fill="{Binding PatStatusColor}">
+                 </Ellipse>
+                <TextBlock Text="{Binding PatStatusMessage}" Foreground="#AAAAAA" FontSize="12" />
+              </StackPanel>
+
+              <!-- PAT Input -->
+              <Grid ColumnDefinitions="*,Auto,Auto" IsVisible="{Binding !HasGitHubPat}">
+                <TextBox Grid.Column="0"
+                         Text="{Binding GitHubPatInput}"
+                         PasswordChar="●"
+                         Watermark="ghp_xxxxxxxxxxxxxxxxxxxx"
+                         Margin="0,0,8,0" />
+                <Button Grid.Column="1"
+                        Content="Save &amp; Test"
+                        Command="{Binding TestPatCommand}"
+                        IsEnabled="{Binding !IsTestingPat}"
+                        Classes="browse-button" />
+              </Grid>
+
+              <!-- Delete PAT button (when PAT exists) -->
+              <StackPanel Orientation="Horizontal" Spacing="10" IsVisible="{Binding HasGitHubPat}">
+                <Button Content="Remove PAT"
+                        Command="{Binding DeletePatCommand}"
+                        Classes="secondary-button" />
+                <Button Content="Refresh Artifacts"
+                        Command="{Binding LoadArtifactsCommand}"
+                        IsEnabled="{Binding !IsLoadingArtifacts}"
+                        Classes="browse-button" />
+              </StackPanel>
+
+              <StackPanel Orientation="Horizontal" Spacing="12">
+                <TextBlock Text="PAT with 'repo' scope required for CI artifact access."
+                           Classes="setting-description" VerticalAlignment="Center" />
+                <Button Content="Create PAT →"
+                        Click="OnOpenPatCreationUrl"
+                        Background="Transparent"
+                        BorderThickness="0"
+                        Padding="0"
+                        Foreground="#7B1FA2"
+                        FontSize="12"
+                        Cursor="Hand"
+                        ToolTip.Tip="Click to open GitHub PAT creation page" />
+              </StackPanel>
+            </StackPanel>
+          </Border>
+
+          <!-- Available Artifacts (for PAT users) -->
+          <StackPanel Spacing="8" IsVisible="{Binding HasGitHubPat}">
+            <TextBlock Text="Available CI Artifacts" Classes="setting-label" />
+            <ItemsControl ItemsSource="{Binding AvailableArtifacts}">
+              <ItemsControl.ItemTemplate>
+                <DataTemplate>
+                  <Border Background="#3D3D3D" CornerRadius="4" Padding="12" Margin="0,4">
+                    <Grid ColumnDefinitions="*,Auto">
+                      <StackPanel Grid.Column="0" Spacing="4">
+                        <TextBlock Text="{Binding DisplayVersion}" FontWeight="SemiBold" Foreground="#FFFFFF" />
+                        <StackPanel Orientation="Horizontal" Spacing="8">
+                          <TextBlock Text="{Binding CreatedAt, StringFormat='{}{0:yyyy-MM-dd HH:mm}'}"
+                                     Foreground="#AAAAAA" FontSize="11" />
+                          <TextBlock Text="{Binding ArtifactName}"
+                                     Foreground="#888888" FontSize="11" />
+                        </StackPanel>
+                      </StackPanel>
+                      <Button Grid.Column="1"
+                              Content="View Run →"
+                              Classes="browse-button"
+                              Click="OnViewWorkflowRun"
+                              Tag="{Binding WorkflowRunUrl}" />
+                    </Grid>
+                  </Border>
+                </DataTemplate>
+              </ItemsControl.ItemTemplate>
+            </ItemsControl>
+            <TextBlock Text="No artifacts available"
+                       IsVisible="{Binding !AvailableArtifacts.Count}"
+                       Foreground="#888888" FontStyle="Italic" />
+          </StackPanel>
+        </StackPanel>
+      </Border>
+
       <!-- Action Buttons -->
       <StackPanel Orientation="Horizontal" Spacing="15" HorizontalAlignment="Right" Margin="0,10,0,0">
         <Button Content="Reset to Defaults"
diff --git a/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml.cs b/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml.cs
index 0c4a37fe7..8c3f84b2e 100644
--- a/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml.cs
+++ b/GenHub/GenHub/Features/Settings/Views/SettingsView.axaml.cs
@@ -36,6 +36,40 @@ private void OnTextBoxLostFocus(object? sender, RoutedEventArgs e)
         // This method exists for potential future enhancements
     }
 
+    private void OnOpenPatCreationUrl(object? sender, RoutedEventArgs e)
+    {
+        try
+        {
+            System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(
+                Core.Constants.GitHubConstants.PatCreationUrl)
+            {
+                UseShellExecute = true,
+            });
+        }
+        catch
+        {
+            // Silently fail if browser cannot be opened
+        }
+    }
+
+    private void OnViewWorkflowRun(object? sender, RoutedEventArgs e)
+    {
+        if (sender is Button button && button.Tag is string url && !string.IsNullOrEmpty(url))
+        {
+            try
+            {
+                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(url)
+                {
+                    UseShellExecute = true,
+                });
+            }
+            catch
+            {
+                // Silently fail if browser cannot be opened
+            }
+        }
+    }
+
     /// <summary>
     /// Loads and initializes the XAML components for this view.
     /// </summary>
diff --git a/docs/velopack-integration.md b/docs/velopack-integration.md
index e8f12df37..e347e1ffa 100644
--- a/docs/velopack-integration.md
+++ b/docs/velopack-integration.md
@@ -5,16 +5,19 @@ GenHub uses [Velopack](https://velopack.io/) for application installation and au
 ## Overview
 
 Velopack provides:
+
 - **Zero-config installers** - Generate installers automatically from your build output
 - **Automatic updates** - Delta updates that only download changed files
 - **Cross-platform** - Single solution for Windows and Linux
 - **GitHub Releases integration** - Seamless updates from GitHub
+- **CI Artifact Updates** - Subscribe to PR builds for testing
 
 ## How It Works
 
 ### 1. Application Startup
 
 When GenHub starts, `VelopackApp.Build().Run()` is called first in `Program.cs`. This handles:
+
 - First-run initialization
 - Update installation on startup
 - Install/uninstall hooks
@@ -22,7 +25,11 @@ When GenHub starts, `VelopackApp.Build().Run()` is called first in `Program.cs`.
 
 ### 2. Update Checking
 
-The `VelopackUpdateManager` service checks for updates from GitHub Releases:
+GenHub supports two update sources:
+
+#### GitHub Releases (Stable Channel)
+
+The `VelopackUpdateManager` service checks for stable releases:
 
 ```csharp
 var updateInfo = await _velopackUpdateManager.CheckForUpdatesAsync();
@@ -34,13 +41,108 @@ if (updateInfo != null)
 }
 ```
 
+#### PR Artifacts (Testing Channel)
+
+Users can subscribe to specific Pull Request builds for testing:
+
+```csharp
+// Subscribe to PR #3
+_userSettingsService.Update(s => s.SubscribedPrNumber = 3);
+
+// Check for PR updates
+var prInfo = await _velopackUpdateManager.GetSubscribedPrInfoAsync();
+if (prInfo?.LatestArtifact != null)
+{
+    // Install PR build
+    await _velopackUpdateManager.InstallPrArtifactAsync(prInfo, progress);
+}
+```
+
 ### 3. Update Flow
 
-1. **Check** - Application queries GitHub Releases for new versions
-2. **Download** - Delta packages are downloaded (only changes)
-3. **Apply** - Update is staged and applied on next restart
+1. **Check** - Application queries GitHub Releases or PR artifacts for new versions
+2. **Download** - Packages are downloaded (delta updates when possible)
+3. **Apply** - Update is staged and applied
 4. **Restart** - Application restarts with new version
 
+## Versioning Scheme
+
+GenHub uses a custom versioning scheme optimized for continuous integration:
+
+### Version Format
+
+```
+0.0.{RUN_NUMBER}[-pr{PR_NUMBER}][+{BUILD_METADATA}]
+```
+
+**Components:**
+
+- `0.0.X` - Base version (0.0 indicates pre-1.0 development)
+- `RUN_NUMBER` - GitHub Actions run number (auto-incrementing)
+- `-pr{N}` - Optional PR number for pull request builds
+- `+{HASH}` - Build metadata (git commit hash, stripped for comparison)
+
+### Examples
+
+```bash
+# Main branch build (run #157)
+0.0.157
+
+# PR #3 build (run #160)
+0.0.160-pr3
+
+# Full version with build metadata
+0.0.160-pr3+051baf8.051baf832a894f542e60d3e4c2471c7d4dd753da
+```
+
+### Version Comparison
+
+GenHub strips build metadata (everything after `+`) when comparing versions:
+
+```csharp
+// These are considered the same version:
+"0.0.160-pr3+051baf8..."
+"0.0.160-pr3+18d0017..."
+// Both compare as: "0.0.160-pr3"
+```
+
+This allows users to reinstall the same PR build with different commits without version conflicts.
+
+## Update Channels
+
+GenHub provides two update channels that users can switch between:
+
+### Stable Channel
+
+- **Source**: GitHub Releases
+- **Versions**: `0.0.X` (no PR suffix)
+- **Updates**: Only stable builds from main branch
+- **Recommended for**: Production use
+
+### Artifacts Channel (PR Subscription)
+
+- **Source**: GitHub Actions CI artifacts
+- **Versions**: `0.0.X-prY` format
+- **Updates**: Specific PR builds
+- **Recommended for**: Testing features, bug fixes
+- **Requires**: GitHub Personal Access Token (PAT) with `repo` scope
+
+#### Subscribing to PR Builds
+
+1. Navigate to Settings → Updates
+2. Click "Manage Updates & PRs"
+3. Enter GitHub PAT (if not already configured)
+4. Select a PR from the list
+5. Click "Subscribe"
+
+The app will now check for updates from that PR instead of stable releases.
+
+#### Unsubscribing
+
+1. Open "Manage Updates & PRs"
+2. Click "Unsubscribe" on the currently subscribed PR
+3. App returns to stable channel
+
 ## Building Releases
 
 ### Prerequisites
@@ -48,90 +150,129 @@ if (updateInfo != null)
 - .NET 8 SDK
 - Velopack CLI tool: `dotnet tool install -g vpk`
 
+### Version Number Generation
+
+GenHub uses GitHub Actions run numbers for versioning:
+
+```yaml
+# CI builds (PRs and main branch)
+VERSION: 0.0.${{ github.run_number }}[-pr${{ github.event.pull_request.number }}]
+
+# Example outputs:
+# Main branch: 0.0.157
+# PR #3: 0.0.160-pr3
+```
+
 ### Manual Build Process
 
 #### Windows
 
 ```powershell
+# Set version
+$VERSION = "0.0.157"  # Or "0.0.160-pr3" for PR builds
+
 # Publish the application
 dotnet publish GenHub/GenHub.Windows/GenHub.Windows.csproj `
   -c Release `
   --self-contained `
   -r win-x64 `
-  -o ./publish/windows
+  -o ./publish/windows `
+  -p:Version=$VERSION
 
 # Package with Velopack
 vpk pack `
   --packId GenHub `
-  --packVersion 1.0.0 `
+  --packVersion $VERSION `
   --packDir ./publish/windows `
   --mainExe GenHub.Windows.exe `
   --packTitle "GenHub" `
   --packAuthors "Community Outpost" `
   --icon GenHub/GenHub/Assets/Icons/generalshub.ico `
   --outputDir ./releases
-
-# For alpha/beta releases, use semantic versioning prerelease identifiers:
-# vpk pack ... --packVersion 1.0.0-alpha.1
-# vpk pack ... --packVersion 1.0.0-beta.2
-# vpk pack ... --packVersion 1.0.0-rc.1
 ```
 
 #### Linux
 
 ```bash
+# Set version
+VERSION="0.0.157"  # Or "0.0.160-pr3" for PR builds
+
 # Publish the application
 dotnet publish GenHub/GenHub.Linux/GenHub.Linux.csproj \
   -c Release \
   --self-contained \
   -r linux-x64 \
-  -o ./publish/linux
+  -o ./publish/linux \
+  -p:Version=$VERSION
 
 # Package with Velopack
 vpk pack \
   --packId GenHub \
-  --packVersion 1.0.0 \
+  --packVersion $VERSION \
   --packDir ./publish/linux \
   --mainExe GenHub.Linux \
   --packTitle "GenHub" \
   --packAuthors "Community Outpost" \
   --icon GenHub/GenHub/Assets/Icons/generalshub.ico \
   --outputDir ./releases
-
-# For alpha/beta releases:
-# vpk pack ... --packVersion 1.0.0-alpha.1
-# vpk pack ... --packVersion 1.0.0-beta.2
 ```
 
 ### Automated CI/CD
 
-GenHub includes a GitHub Actions workflow (`.github/workflows/release.yml`) that automatically:
+GenHub includes GitHub Actions workflows:
+
+#### `.github/workflows/ci.yml` - Continuous Integration
+
+Runs on every push and PR:
+
+1. Builds for Windows and Linux
+2. Packages with Velopack using `0.0.{RUN_NUMBER}[-pr{PR_NUMBER}]` versioning
+3. Uploads artifacts to GitHub Actions
+4. Generates `releases.win.json` and `releases.linux.json` metadata
+
+**Artifacts uploaded:**
+
+- `genhub-velopack-windows-{VERSION}` - Windows installer and packages
+- `genhub-velopack-linux-{VERSION}` - Linux packages
+- `genhub-metadata-windows-{VERSION}` - Update metadata (`releases.win.json`)
+- `genhub-metadata-linux-{VERSION}` - Update metadata (`releases.linux.json`)
+
+#### `.github/workflows/release.yml` - Stable Releases
+
+Triggered by version tags (`v*`):
 
 1. Builds releases for Windows and Linux
-2. Packages them with Velopack
-3. Creates a GitHub Release with installers
+2. Creates GitHub Release
+3. Uploads installers and packages
 4. Publishes update feed for automatic updates
 
-**To trigger a release:**
+**To trigger a stable release:**
 
 ```bash
-git tag v1.0.0
-git push origin v1.0.0
+git tag v0.0.157
+git push origin v0.0.157
 ```
 
-Or manually through GitHub Actions workflow dispatch.
-
 ## Release Artifacts
 
 After packaging, Velopack generates:
 
-- **GenHub-win-Setup.exe** (Windows) - Full installer that installs to `%LOCALAPPDATA%\GenHub`
+### Windows
+
+- **GenHub-{Version}-Setup.exe** - Full installer (installs to `%LOCALAPPDATA%\GenHub`)
 - **GenHub-{Version}-full.nupkg** - Full release package
 - **GenHub-{Version}-delta.nupkg** - Delta update package (if previous version exists)
-- **GenHub-win-Portable.zip** - Portable version (no installation required)
-- **RELEASES** - Update feed manifest
+- **GenHub-{Version}-Portable.zip** - Portable version (no installation required)
+- **releases.win.json** - Update feed manifest (JSON format)
+
+### Linux
 
-Upload all artifacts to GitHub Releases. Velopack will automatically serve updates.
+- **GenHub-{Version}-linux-x64.AppImage** - AppImage installer
+- **GenHub-{Version}-full.nupkg** - Full release package
+- **GenHub-{Version}-delta.nupkg** - Delta update package
+- **releases.linux.json** - Update feed manifest (JSON format)
+
+**Note**: Velopack v0.0.942+ uses JSON format (`releases.*.json`) instead of the legacy `RELEASES` file.
 
 ## Installation Locations
 
@@ -139,7 +280,7 @@ Upload all artifacts to GitHub Releases. Velopack will automatically serve updat
 
 - **Installation Directory**: `%LOCALAPPDATA%\GenHub\` (e.g., `C:\Users\YourName\AppData\Local\GenHub\`)
 - **User Data**: `%APPDATA%\GenHub\`
-- **Update Cache**: `%LOCALAPPDATA%\GenHub\`
+- **Update Cache**: `%LOCALAPPDATA%\GenHub\packages\`
 
 **Note**: Velopack uses a "one-click" installer that always installs to LocalAppData. This location:
 
@@ -150,111 +291,62 @@ Upload all artifacts to GitHub Releases. Velopack will automatically serve updat
 
 ### Linux Installation
 
-- **Installation Directory**: `/usr/local/bin/GenHub/` or `~/.local/share/GenHub/`
+- **Installation Directory**: `~/.local/share/GenHub/`
 - **User Data**: `~/.config/GenHub/`
 - **Update Cache**: `~/.cache/GenHub/`
 
 The app ID `GenHub` ensures clean, predictable installation paths without vendor prefixes.
 
-## Release Channels and Prerelease Versions
-
-Velopack supports **semantic versioning prerelease identifiers** for alpha, beta, and release candidate builds. You can use semver formats without needing separate channels:
-
-### Semantic Versioning Examples
-
-**Version Format:** `MAJOR.MINOR.PATCH[-PRERELEASE]`
-
-```bash
-# Stable release
-vpk pack ... --packVersion 1.0.0
-
-# Alpha releases (early testing) - increment the number after alpha
-vpk pack ... --packVersion 1.0.0-alpha.1
-vpk pack ... --packVersion 1.0.0-alpha.2
-vpk pack ... --packVersion 1.0.0-alpha.3
-
-# Beta releases (feature complete, testing)
-vpk pack ... --packVersion 1.0.0-beta.1
-vpk pack ... --packVersion 1.0.0-beta.2
-
-# Release candidates
-vpk pack ... --packVersion 1.0.0-rc.1
-vpk pack ... --packVersion 1.0.0-rc.2
-
-# Final stable release
-vpk pack ... --packVersion 1.0.0
+## Update Features
 
-# Next feature version - start over with alpha
-vpk pack ... --packVersion 1.1.0-alpha.1
-vpk pack ... --packVersion 1.1.0-alpha.2
-vpk pack ... --packVersion 1.1.0-beta.1
-vpk pack ... --packVersion 1.1.0
+### Dismiss Updates
 
-# Patch release
-vpk pack ... --packVersion 1.1.1
+Users can dismiss update notifications:
 
-# Major version bump
-vpk pack ... --packVersion 2.0.0-alpha.1
+```csharp
+// In UpdateNotificationViewModel
+private void DismissUpdate()
+{
+    // Persist dismissed version to prevent showing again
+    _userSettingsService.Update(s => s.DismissedUpdateVersion = LatestVersion);
+    IsUpdateAvailable = false;
+}
 ```
 
-**Versioning Flow:**
+Dismissed updates won't reappear until a **different version** is available.
 
-```text
-1.0.0-alpha.1 → 1.0.0-alpha.2 → ... → 1.0.0-beta.1 → 1.0.0-beta.2 → 1.0.0
-                                                                        ↓
-1.1.0-alpha.1 → 1.1.0-alpha.2 → ... → 1.1.0-beta.1 → 1.1.0 ←─────────┘
-```
+### PR Update Priority
 
-### How Velopack Handles Prereleases
+When subscribed to a PR:
 
-- **Stable users** (installed from a stable version like `1.0.0`) will ONLY receive stable updates
-- **Prerelease users** (installed from `1.0.0-beta.1`) will receive ALL updates including prereleases
-- Versioning follows [SemVer 2.0](https://semver.org/) rules
-- Users on prereleases automatically upgrade to stable when available
+1. PR updates take priority over stable releases
+2. Version comparison ignores build metadata
+3. Users can "switch" to any PR build regardless of version number
+4. Unsubscribing returns to stable channel
 
-### Using Channels for Different Features
+### Build Metadata Handling
 
-If you need separate feature branches (e.g., stable vs experimental features), use the `--channel` parameter:
+Build metadata (commit hashes) is:
 
-```bash
-# Stable channel (default: "win" for Windows, "linux" for Linux)
-vpk pack ... --packVersion 1.0.0
+- **Included** in the version string for tracking
+- **Displayed** in the UI for transparency
+- **Stripped** during version comparison to avoid false updates
+- **Logged** for debugging purposes
 
-# Beta feature channel
-vpk pack ... --packVersion 1.0.0 --channel win-beta
+Example:
 
-# Experimental channel
-vpk pack ... --packVersion 1.0.0 --channel win-experimental
 ```
-
-**Note**: Once a user installs from a specific channel, they only receive updates from that channel unless they explicitly switch.
-
-### Recommended Strategy
-
-For most use cases, use **prerelease identifiers** instead of channels:
-
-- ✅ Simpler: No channel management needed
-- ✅ Automatic graduation: Beta users get stable updates automatically
-- ✅ Clear versioning: Everyone sees the same version numbers
-
-Use channels only if you need persistent feature branches (like stable/nightly builds).
-
-## Update Channel Management
-
-By default, GenHub uses the default update channel. You can create multiple channels (stable, beta, etc.):
-
-```bash
-vpk pack ... --channel beta
+Display: v0.0.160-pr3 (051baf8)
+Full version: 0.0.160-pr3+051baf8.051baf832a894f542e60d3e4c2471c7d4dd753da
+Comparison: 0.0.160-pr3
 ```
 
-Users will automatically receive updates from their installed channel.
-
 ## Testing Updates Locally
 
 ### 1. Create Test Release
 
 ```powershell
-vpk pack --packId GenHub --packVersion 1.0.0 --packDir ./publish --mainExe GenHub.Windows.exe -o ./test-releases
+vpk pack --packId GenHub --packVersion 0.0.100 --packDir ./publish --mainExe GenHub.Windows.exe -o ./test-releases
 ```
 
 ### 2. Create Second Version
@@ -262,7 +354,7 @@ vpk pack --packId GenHub --packVersion 1.0.0 --packDir ./publish --mainExe GenHu
 Update your code, then:
 
 ```powershell
-vpk pack --packId GenHub --packVersion 1.0.1 --packDir ./publish --mainExe GenHub.Windows.exe -o ./test-releases --delta ./test-releases/RELEASES
+vpk pack --packId GenHub --packVersion 0.0.101 --packDir ./publish --mainExe GenHub.Windows.exe -o ./test-releases --delta ./test-releases/releases.win.json
 ```
 
 ### 3. Test Update
@@ -270,7 +362,8 @@ vpk pack --packId GenHub --packVersion 1.0.1 --packDir ./publish --mainExe GenHu
 Point UpdateManager to local directory:
 
 ```csharp
-var manager = new UpdateManager("file:///C:/path/to/test-releases");
+var source = new SimpleWebSource("file:///C:/path/to/test-releases");
+var manager = new UpdateManager(source);
 ```
 
 ## Architecture
@@ -280,7 +373,9 @@ var manager = new UpdateManager("file:///C:/path/to/test-releases");
 - **VelopackApp** - Handles application lifecycle hooks
 - **VelopackUpdateManager** - Service for checking/downloading/applying updates
 - **IVelopackUpdateManager** - Interface for update operations
-- **UpdateInfo** - Model containing update metadata
+- **UpdateInfo** - Model containing update metadata from Velopack
+- **ArtifactUpdateInfo** - Model for PR artifact metadata
+- **PullRequestInfo** - Model for PR information and artifacts
 - **UpdateProgress** - Progress reporting model
 
 ### Integration Points
@@ -288,6 +383,28 @@ var manager = new UpdateManager("file:///C:/path/to/test-releases");
 - `Program.cs` - VelopackApp.Build().Run() initialization
 - `AppUpdateModule.cs` - DI registration
 - `VelopackUpdateManager.cs` - Update service implementation
+- `UpdateNotificationViewModel.cs` - UI logic for update notifications
+- `MainViewModel.cs` - Main window update badge logic
+
+### Key Services
+
+```csharp
+public interface IVelopackUpdateManager
+{
+    // Stable channel updates
+    Task<UpdateInfo?> CheckForUpdatesAsync(CancellationToken cancellationToken = default);
+    Task DownloadUpdatesAsync(UpdateInfo updateInfo, IProgress<UpdateProgress>? progress = null);
+    void ApplyUpdatesAndRestart(UpdateInfo updateInfo);
+
+    // PR artifact updates
+    Task<PullRequestInfo?> GetSubscribedPrInfoAsync(CancellationToken cancellationToken = default);
+    Task InstallPrArtifactAsync(PullRequestInfo prInfo, IProgress<UpdateProgress>? progress = null, CancellationToken cancellationToken = default);
+
+    // Properties
+    bool HasUpdateAvailableFromGitHub { get; }
+    string? LatestVersionFromGitHub { get; }
+}
+```
 
 ## Troubleshooting
 
@@ -295,18 +412,72 @@ var manager = new UpdateManager("file:///C:/path/to/test-releases");
 
 Velopack only works when the app is installed. When running from Visual Studio or `dotnet run`, updates are disabled. This is expected behavior.
 
+To test updates:
+
+1. Build a Velopack package
+2. Install it using the Setup.exe
+3. Run the installed app
+
 ### Update Check Fails
 
-- Ensure GitHub repository is public or provide authentication
-- Verify GitHub Releases contain Velopack packages
+- **GitHub Releases**: Ensure repository is public or provide authentication
+- **PR Artifacts**: Requires GitHub PAT with `repo` scope
+- Verify GitHub Releases/Actions contain Velopack packages
 - Check network connectivity
+- Review logs for specific error messages
 
 ### Version Comparison Issues
 
-Velopack uses semantic versioning (SemVer). Ensure version numbers follow `Major.Minor.Patch` format.
+GenHub strips build metadata before comparison. If updates aren't detected:
+
+1. Check version format: `0.0.X` or `0.0.X-prY`
+2. Verify build metadata is after `+` symbol
+3. Review logs for version comparison details
+
+### PR Artifact Installation Fails
+
+Common issues:
+
+1. **"No update found from PR artifact"**
+   - Current version >= target version
+   - Velopack won't "downgrade" by default
+   - Solution: Uninstall and run Setup.exe from PR artifact
+
+2. **"Already installed"**
+   - Same base version with different build metadata
+   - This is expected - versions are identical
+
+3. **Authentication errors**
+   - GitHub PAT missing or invalid
+   - PAT needs `repo` scope for private repos
+
+### App Doesn't Restart After Update
+
+- Ensure using `ApplyUpdatesAndRestart()` not `ApplyUpdatesAndExit()`
+- Check logs for update application errors
+- Verify update package integrity
+
+## Security Considerations
+
+### GitHub Personal Access Tokens
+
+- **Storage**: Tokens are stored in Windows Credential Manager (Windows) or Keyring (Linux)
+- **Scope**: Only `repo` scope is required
+- **Usage**: Only for downloading PR artifacts
+- **Rotation**: Users can update/remove tokens at any time
+
+### Update Verification
+
+Velopack verifies package integrity using:
+
+- SHA256 checksums in metadata files
+- Package signatures (if configured)
+- HTTPS for all downloads
 
 ## Additional Resources
 
 - [Velopack Documentation](https://docs.velopack.io/)
 - [Velopack GitHub](https://github.com/velopack/velopack)
 - [GitHub Releases Guide](https://docs.github.com/en/repositories/releasing-projects-on-github)
+- [GitHub Actions Artifacts](https://docs.github.com/en/actions/using-workflows/storing-workflow-data-as-artifacts)
+- [Semantic Versioning](https://semver.org/)