diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index bdbf22214..af5309aed 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -309,47 +309,136 @@ jobs:
       contents: write
       pull-requests: write
     steps:
-      - name: Checkout main
+      - name: Checkout beta
         uses: actions/checkout@v6
         with:
-          ref: main
+          ref: beta
           fetch-depth: 0
 
-      - name: Create PR to merge main into beta
-        id: sync_pr
+      - name: Prepare sync branch from beta with merged main
+        id: sync_branch
         env:
-          GH_TOKEN: ${{ github.token }}
           NEW_VERSION: ${{ needs.bump.outputs.new_version }}
         shell: bash
         run: |
           set -euo pipefail
-          # Check if beta is behind main
-          git fetch origin beta
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
+
+          # Fetch both branches so we can build a merge commit in CI.
+          git fetch origin main beta
           if git merge-base --is-ancestor origin/main origin/beta; then
-            echo "beta is already up to date with main. Skipping PR."
+            echo "beta is already up to date with main. Skipping sync."
             echo "skipped=true" >> "$GITHUB_OUTPUT"
             exit 0
           fi
 
+          SYNC_BRANCH="sync/main-v${NEW_VERSION}-into-beta-${GITHUB_RUN_ID}"
+          echo "name=$SYNC_BRANCH" >> "$GITHUB_OUTPUT"
+          echo "skipped=false" >> "$GITHUB_OUTPUT"
+
+          git checkout -b "$SYNC_BRANCH" origin/beta
+
+          if git merge origin/main --no-ff --no-commit; then
+            echo "main merged cleanly into sync branch."
+          else
+            echo "Merge conflicts detected. Attempting expected conflict resolution for beta version files."
+            CONFLICTS=$(git diff --name-only --diff-filter=U || true)
+            if [[ -n "$CONFLICTS" ]]; then
+              echo "$CONFLICTS"
+            fi
+
+            # Keep beta-side prerelease versions if these files conflict.
+            for file in MCPForUnity/package.json Server/pyproject.toml; do
+              if git ls-files -u -- "$file" | grep -q .; then
+                echo "Keeping beta version for $file"
+                git checkout --ours -- "$file"
+                git add "$file"
+              fi
+            done
+
+            REMAINING=$(git diff --name-only --diff-filter=U || true)
+            if [[ -n "$REMAINING" ]]; then
+              echo "Unexpected unresolved conflicts remain:"
+              echo "$REMAINING"
+              exit 1
+            fi
+          fi
+
+          git commit -m "chore: sync main (v${NEW_VERSION}) into beta"
+
+          # After releasing X.Y.Z on main, beta should move to X.Y.(Z+1)-beta.1.
+          IFS='.' read -r MAJOR MINOR PATCH <<< "$NEW_VERSION"
+          NEXT_PATCH=$((PATCH + 1))
+          NEXT_BETA_VERSION="${MAJOR}.${MINOR}.${NEXT_PATCH}-beta.1"
+          echo "beta_version=$NEXT_BETA_VERSION" >> "$GITHUB_OUTPUT"
+          echo "Setting beta version to $NEXT_BETA_VERSION"
+
+          CURRENT_BETA_VERSION=$(jq -r '.version' MCPForUnity/package.json)
+          if [[ "$CURRENT_BETA_VERSION" != "$NEXT_BETA_VERSION" ]]; then
+            jq --arg v "$NEXT_BETA_VERSION" '.version = $v' MCPForUnity/package.json > tmp.json
+            mv tmp.json MCPForUnity/package.json
+            git add MCPForUnity/package.json
+            git commit -m "chore: set beta version to ${NEXT_BETA_VERSION} after release v${NEW_VERSION}"
+          else
+            echo "Beta version already at target: $NEXT_BETA_VERSION"
+          fi
+
+          echo "Pushing sync branch $SYNC_BRANCH"
+          git push origin "$SYNC_BRANCH"
+
+      - name: Create PR to merge sync branch into beta
+        if: steps.sync_branch.outputs.skipped != 'true'
+        id: sync_pr
+        env:
+          GH_TOKEN: ${{ github.token }}
+          NEW_VERSION: ${{ needs.bump.outputs.new_version }}
+          NEXT_BETA_VERSION: ${{ steps.sync_branch.outputs.beta_version }}
+          SYNC_BRANCH: ${{ steps.sync_branch.outputs.name }}
+        shell: bash
+        run: |
+          set -euo pipefail
           PR_URL=$(gh pr create \
             --base beta \
-            --head main \
+            --head "$SYNC_BRANCH" \
             --title "chore: sync main (v${NEW_VERSION}) into beta" \
-            --body "Automated sync of version bump from main into beta.")
+            --body "Automated sync of main back into beta after release v${NEW_VERSION}, including beta version set to ${NEXT_BETA_VERSION}.")
           echo "pr_url=$PR_URL" >> "$GITHUB_OUTPUT"
           PR_NUMBER=$(echo "$PR_URL" | grep -oE '[0-9]+$')
           echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
-          echo "skipped=false" >> "$GITHUB_OUTPUT"
 
       - name: Merge sync PR
-        if: steps.sync_pr.outputs.skipped != 'true'
+        if: steps.sync_branch.outputs.skipped != 'true'
         env:
           GH_TOKEN: ${{ github.token }}
           PR_NUMBER: ${{ steps.sync_pr.outputs.pr_number }}
         shell: bash
         run: |
           set -euo pipefail
-          gh pr merge "$PR_NUMBER" --merge --no-delete-branch
+
+          # Best effort: auto-merge if repository settings allow it.
+          gh pr merge "$PR_NUMBER" --merge --auto --delete-branch || true
+
+          # Retry direct merge for up to 2 minutes while checks settle.
+          for i in {1..24}; do
+            STATE=$(gh pr view "$PR_NUMBER" --json state -q '.state')
+            if [[ "$STATE" == "MERGED" ]]; then
+              echo "Sync PR merged successfully."
+              exit 0
+            fi
+
+            if gh pr merge "$PR_NUMBER" --merge --delete-branch >/dev/null 2>&1; then
+              echo "Sync PR merged successfully."
+              exit 0
+            fi
+
+            echo "Waiting for sync PR to become mergeable... (state: $STATE)"
+            sleep 5
+          done
+
+          echo "Sync PR did not merge in time."
+          gh pr view "$PR_NUMBER" --json state,mergeStateStatus,isDraft -q '{state: .state, mergeStateStatus: .mergeStateStatus, isDraft: .isDraft}'
+          exit 1
 
   publish_docker:
     name: Publish Docker image
diff --git a/MCPForUnity/Editor/Services/PackageUpdateService.cs b/MCPForUnity/Editor/Services/PackageUpdateService.cs
index 81c0161f7..5f594e9ca 100644
--- a/MCPForUnity/Editor/Services/PackageUpdateService.cs
+++ b/MCPForUnity/Editor/Services/PackageUpdateService.cs
@@ -1,9 +1,11 @@
 using System;
 using System.Net;
+using System.Text.RegularExpressions;
 using MCPForUnity.Editor.Constants;
 using MCPForUnity.Editor.Helpers;
 using Newtonsoft.Json.Linq;
 using UnityEditor;
+using PackageInfo = UnityEditor.PackageManager.PackageInfo;
 
 namespace MCPForUnity.Editor.Services
 {
@@ -14,17 +16,30 @@ public class PackageUpdateService : IPackageUpdateService
     {
         private const string LastCheckDateKey = EditorPrefKeys.LastUpdateCheck;
         private const string CachedVersionKey = EditorPrefKeys.LatestKnownVersion;
+        private const string LastBetaCheckDateKey = EditorPrefKeys.LastUpdateCheck + ".beta";
+        private const string CachedBetaVersionKey = EditorPrefKeys.LatestKnownVersion + ".beta";
         private const string LastAssetStoreCheckDateKey = EditorPrefKeys.LastAssetStoreUpdateCheck;
         private const string CachedAssetStoreVersionKey = EditorPrefKeys.LatestKnownAssetStoreVersion;
-        private const string PackageJsonUrl = "https://raw.githubusercontent.com/CoplayDev/unity-mcp/main/MCPForUnity/package.json";
+        private const string MainPackageJsonUrl = "https://raw.githubusercontent.com/CoplayDev/unity-mcp/main/MCPForUnity/package.json";
+        private const string BetaPackageJsonUrl = "https://raw.githubusercontent.com/CoplayDev/unity-mcp/beta/MCPForUnity/package.json";
         private const string AssetStoreVersionUrl = "https://gqoqjkkptwfbkwyssmnj.supabase.co/storage/v1/object/public/coplay-images/assetstoreversion.json";
 
         /// <inheritdoc/>
         public UpdateCheckResult CheckForUpdate(string currentVersion)
         {
             bool isGitInstallation = IsGitInstallation();
-            string lastCheckDate = EditorPrefs.GetString(isGitInstallation ? LastCheckDateKey : LastAssetStoreCheckDateKey, "");
-            string cachedLatestVersion = EditorPrefs.GetString(isGitInstallation ? CachedVersionKey : CachedAssetStoreVersionKey, "");
+            string gitBranch = isGitInstallation ? GetGitUpdateBranch(currentVersion) : "main";
+            bool useBetaChannel = isGitInstallation && string.Equals(gitBranch, "beta", StringComparison.OrdinalIgnoreCase);
+
+            string lastCheckKey = isGitInstallation
+                ? (useBetaChannel ? LastBetaCheckDateKey : LastCheckDateKey)
+                : LastAssetStoreCheckDateKey;
+            string cachedVersionKey = isGitInstallation
+                ? (useBetaChannel ? CachedBetaVersionKey : CachedVersionKey)
+                : CachedAssetStoreVersionKey;
+
+            string lastCheckDate = EditorPrefs.GetString(lastCheckKey, "");
+            string cachedLatestVersion = EditorPrefs.GetString(cachedVersionKey, "");
 
             if (lastCheckDate == DateTime.Now.ToString("yyyy-MM-dd") && !string.IsNullOrEmpty(cachedLatestVersion))
             {
@@ -38,14 +53,14 @@ public UpdateCheckResult CheckForUpdate(string currentVersion)
             }
 
             string latestVersion = isGitInstallation
-                ? FetchLatestVersionFromGitHub()
+                ? FetchLatestVersionFromGitHub(gitBranch)
                 : FetchLatestVersionFromAssetStoreJson();
 
             if (!string.IsNullOrEmpty(latestVersion))
             {
                 // Cache the result
-                EditorPrefs.SetString(isGitInstallation ? LastCheckDateKey : LastAssetStoreCheckDateKey, DateTime.Now.ToString("yyyy-MM-dd"));
-                EditorPrefs.SetString(isGitInstallation ? CachedVersionKey : CachedAssetStoreVersionKey, latestVersion);
+                EditorPrefs.SetString(lastCheckKey, DateTime.Now.ToString("yyyy-MM-dd"));
+                EditorPrefs.SetString(cachedVersionKey, latestVersion);
 
                 return new UpdateCheckResult
                 {
@@ -68,31 +83,142 @@ public UpdateCheckResult CheckForUpdate(string currentVersion)
 
         /// <inheritdoc/>
         public bool IsNewerVersion(string version1, string version2)
+        {
+            if (!TryParseVersion(version1, out var left) || !TryParseVersion(version2, out var right))
+            {
+                return false;
+            }
+
+            return CompareVersions(left, right) > 0;
+        }
+
+        private static int CompareVersions(ParsedVersion left, ParsedVersion right)
+        {
+            int cmp = left.Major.CompareTo(right.Major);
+            if (cmp != 0) return cmp;
+
+            cmp = left.Minor.CompareTo(right.Minor);
+            if (cmp != 0) return cmp;
+
+            cmp = left.Patch.CompareTo(right.Patch);
+            if (cmp != 0) return cmp;
+
+            // Stable is newer than prerelease when core version matches.
+            if (!left.IsPrerelease && right.IsPrerelease) return 1;
+            if (left.IsPrerelease && !right.IsPrerelease) return -1;
+            if (!left.IsPrerelease && !right.IsPrerelease) return 0;
+
+            cmp = GetPrereleaseRank(left.PrereleaseLabel).CompareTo(GetPrereleaseRank(right.PrereleaseLabel));
+            if (cmp != 0) return cmp;
+
+            cmp = left.PrereleaseNumber.CompareTo(right.PrereleaseNumber);
+            if (cmp != 0) return cmp;
+
+            return string.Compare(left.PrereleaseLabel, right.PrereleaseLabel, StringComparison.OrdinalIgnoreCase);
+        }
+
+        private static int GetPrereleaseRank(string label)
+        {
+            if (string.IsNullOrEmpty(label))
+            {
+                return 0;
+            }
+
+            switch (label.ToLowerInvariant())
+            {
+                case "a":
+                case "alpha":
+                    return 1;
+                case "b":
+                case "beta":
+                    return 2;
+                case "rc":
+                    return 3;
+                case "preview":
+                case "pre":
+                    return 4;
+                default:
+                    return 5;
+            }
+        }
+
+        private static bool TryParseVersion(string version, out ParsedVersion parsed)
+        {
+            parsed = default;
+            if (string.IsNullOrWhiteSpace(version))
+            {
+                return false;
+            }
+
+            string normalized = version.Trim().TrimStart('v', 'V');
+            var match = Regex.Match(
+                normalized,
+                @"^(?<major>\d+)\.(?<minor>\d+)\.(?<patch>\d+)(?:-(?<label>[A-Za-z]+)(?:\.(?<number>\d+))?)?$");
+
+            if (!match.Success)
+            {
+                return false;
+            }
+
+            if (!int.TryParse(match.Groups["major"].Value, out int major) ||
+                !int.TryParse(match.Groups["minor"].Value, out int minor) ||
+                !int.TryParse(match.Groups["patch"].Value, out int patch))
+            {
+                return false;
+            }
+
+            string prereleaseLabel = match.Groups["label"].Success ? match.Groups["label"].Value : string.Empty;
+            int prereleaseNumber = 0;
+            if (match.Groups["number"].Success)
+            {
+                int.TryParse(match.Groups["number"].Value, out prereleaseNumber);
+            }
+
+            parsed = new ParsedVersion
+            {
+                Major = major,
+                Minor = minor,
+                Patch = patch,
+                PrereleaseLabel = prereleaseLabel,
+                PrereleaseNumber = prereleaseNumber,
+                IsPrerelease = !string.IsNullOrEmpty(prereleaseLabel)
+            };
+            return true;
+        }
+
+        private static bool IsPreReleaseVersion(string version)
+        {
+            if (string.IsNullOrWhiteSpace(version))
+            {
+                return AssetPathUtility.IsPreReleaseVersion();
+            }
+
+            return version.IndexOf('-', StringComparison.Ordinal) >= 0;
+        }
+
+        private static string GetGitUpdateBranch(string currentVersion)
         {
             try
             {
-                // Remove any "v" prefix
-                version1 = version1.TrimStart('v', 'V');
-                version2 = version2.TrimStart('v', 'V');
+                var packageInfo = PackageInfo.FindForAssembly(typeof(PackageUpdateService).Assembly);
+                string packageId = packageInfo?.packageId ?? string.Empty;
 
-                var version1Parts = version1.Split('.');
-                var version2Parts = version2.Split('.');
+                if (packageId.IndexOf("#beta", StringComparison.OrdinalIgnoreCase) >= 0)
+                {
+                    return "beta";
+                }
 
-                for (int i = 0; i < Math.Min(version1Parts.Length, version2Parts.Length); i++)
+                if (packageId.IndexOf("#main", StringComparison.OrdinalIgnoreCase) >= 0)
                 {
-                    if (int.TryParse(version1Parts[i], out int v1Num) &&
-                        int.TryParse(version2Parts[i], out int v2Num))
-                    {
-                        if (v1Num > v2Num) return true;
-                        if (v1Num < v2Num) return false;
-                    }
+                    return "main";
                 }
-                return false;
             }
             catch
             {
-                return false;
+                // Fall back to version-based inference below.
             }
+
+            return IsPreReleaseVersion(currentVersion) ? "beta" : "main";
         }
 
         /// <inheritdoc/>
@@ -117,14 +243,16 @@ public void ClearCache()
         {
             EditorPrefs.DeleteKey(LastCheckDateKey);
             EditorPrefs.DeleteKey(CachedVersionKey);
+            EditorPrefs.DeleteKey(LastBetaCheckDateKey);
+            EditorPrefs.DeleteKey(CachedBetaVersionKey);
             EditorPrefs.DeleteKey(LastAssetStoreCheckDateKey);
             EditorPrefs.DeleteKey(CachedAssetStoreVersionKey);
         }
 
         /// <summary>
-        /// Fetches the latest version from GitHub's main branch package.json
+        /// Fetches the latest version from GitHub package.json for the requested branch.
         /// </summary>
-        protected virtual string FetchLatestVersionFromGitHub()
+        protected virtual string FetchLatestVersionFromGitHub(string branch)
         {
             try
             {
@@ -140,7 +268,10 @@ protected virtual string FetchLatestVersionFromGitHub()
                 using (var client = new WebClient())
                 {
                     client.Headers.Add("User-Agent", "Unity-MCPForUnity-UpdateChecker");
-                    string jsonContent = client.DownloadString(PackageJsonUrl);
+                    string packageJsonUrl = string.Equals(branch, "beta", StringComparison.OrdinalIgnoreCase)
+                        ? BetaPackageJsonUrl
+                        : MainPackageJsonUrl;
+                    string jsonContent = client.DownloadString(packageJsonUrl);
 
                     var packageJson = JObject.Parse(jsonContent);
                     string version = packageJson["version"]?.ToString();
@@ -156,6 +287,16 @@ protected virtual string FetchLatestVersionFromGitHub()
             }
         }
 
+        private struct ParsedVersion
+        {
+            public int Major;
+            public int Minor;
+            public int Patch;
+            public string PrereleaseLabel;
+            public int PrereleaseNumber;
+            public bool IsPrerelease;
+        }
+
         /// <summary>
         /// Fetches the latest Asset Store version from a hosted JSON file.
         /// </summary>
diff --git a/MCPForUnity/Editor/Windows/Components/ClientConfig/McpClientConfigSection.cs b/MCPForUnity/Editor/Windows/Components/ClientConfig/McpClientConfigSection.cs
index 575650f57..f2f58155c 100644
--- a/MCPForUnity/Editor/Windows/Components/ClientConfig/McpClientConfigSection.cs
+++ b/MCPForUnity/Editor/Windows/Components/ClientConfig/McpClientConfigSection.cs
@@ -103,18 +103,10 @@ private void InitializeUI()
             {
                 // Restore last selected client from EditorPrefs
                 string lastClientId = EditorPrefs.GetString(EditorPrefKeys.LastSelectedClientId, string.Empty);
-                int restoredIndex = 0;
-                if (!string.IsNullOrEmpty(lastClientId))
-                {
-                    for (int i = 0; i < configurators.Count; i++)
-                    {
-                        if (string.Equals(configurators[i].Id, lastClientId, StringComparison.OrdinalIgnoreCase))
-                        {
-                            restoredIndex = i;
-                            break;
-                        }
-                    }
-                }
+                int restoredIndex = FindConfiguratorIndex(lastClientId);
+                if (restoredIndex < 0)
+                    restoredIndex = 0;
+
                 clientDropdown.index = restoredIndex;
                 selectedClientIndex = restoredIndex;
             }
@@ -131,7 +123,17 @@ private void RegisterCallbacks()
         {
             clientDropdown.RegisterValueChangedCallback(evt =>
             {
-                selectedClientIndex = clientDropdown.index;
+                int selectedIndex = GetIndexForDropdownValue(evt.newValue);
+                if (selectedIndex < 0)
+                {
+                    selectedIndex = clientDropdown.index;
+                }
+                if (selectedIndex < 0 || selectedIndex >= configurators.Count)
+                {
+                    return;
+                }
+
+                selectedClientIndex = selectedIndex;
                 // Persist the selected client so it's restored on next window open
                 if (selectedClientIndex >= 0 && selectedClientIndex < configurators.Count)
                 {
@@ -653,5 +655,64 @@ private static string GetExpectedPackageSourceForBetaMode()
             // Standard mode uses exact version from package.json
             return AssetPathUtility.GetMcpServerPackageSource();
         }
+
+        private int FindConfiguratorIndex(string persistedClientValue)
+        {
+            if (string.IsNullOrWhiteSpace(persistedClientValue))
+                return -1;
+
+            // Primary match: stored stable ID.
+            for (int i = 0; i < configurators.Count; i++)
+            {
+                if (string.Equals(configurators[i].Id, persistedClientValue, StringComparison.OrdinalIgnoreCase))
+                    return i;
+            }
+
+            // Compatibility match for older persisted values (e.g., display names with spaces).
+            string normalized = NormalizeClientToken(persistedClientValue);
+            if (string.IsNullOrEmpty(normalized))
+                return -1;
+
+            for (int i = 0; i < configurators.Count; i++)
+            {
+                if (NormalizeClientToken(configurators[i].Id) == normalized ||
+                    NormalizeClientToken(configurators[i].DisplayName) == normalized)
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        private int GetIndexForDropdownValue(string dropdownValue)
+        {
+            if (string.IsNullOrWhiteSpace(dropdownValue))
+                return -1;
+
+            int directIndex = clientDropdown.choices?.IndexOf(dropdownValue) ?? -1;
+            if (directIndex >= 0 && directIndex < configurators.Count)
+                return directIndex;
+
+            string normalized = NormalizeClientToken(dropdownValue);
+            if (string.IsNullOrEmpty(normalized))
+                return -1;
+
+            for (int i = 0; i < configurators.Count; i++)
+            {
+                if (NormalizeClientToken(configurators[i].DisplayName) == normalized)
+                    return i;
+            }
+
+            return -1;
+        }
+
+        private static string NormalizeClientToken(string value)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+                return string.Empty;
+
+            return new string(value.Where(char.IsLetterOrDigit).ToArray()).ToLowerInvariant();
+        }
     }
 }
diff --git a/MCPForUnity/Editor/Windows/EditorPrefs/EditorPrefsWindow.cs b/MCPForUnity/Editor/Windows/EditorPrefs/EditorPrefsWindow.cs
index b36125d4f..e01f7f029 100644
--- a/MCPForUnity/Editor/Windows/EditorPrefs/EditorPrefsWindow.cs
+++ b/MCPForUnity/Editor/Windows/EditorPrefs/EditorPrefsWindow.cs
@@ -68,6 +68,7 @@ public class EditorPrefsWindow : EditorWindow
             { EditorPrefKeys.PackageDeployLastTargetPath, EditorPrefType.String },
             { EditorPrefKeys.PackageDeployLastSourcePath, EditorPrefType.String },
             { EditorPrefKeys.ServerSrc, EditorPrefType.String },
+            { EditorPrefKeys.LastSelectedClientId, EditorPrefType.String },
             { EditorPrefKeys.LatestKnownVersion, EditorPrefType.String },
             { EditorPrefKeys.LastAssetStoreUpdateCheck, EditorPrefType.String },
             { EditorPrefKeys.LatestKnownAssetStoreVersion, EditorPrefType.String },
diff --git a/MCPForUnity/Editor/Windows/MCPForUnityEditorWindow.cs b/MCPForUnity/Editor/Windows/MCPForUnityEditorWindow.cs
index a371ecbf5..85f5f3359 100644
--- a/MCPForUnity/Editor/Windows/MCPForUnityEditorWindow.cs
+++ b/MCPForUnity/Editor/Windows/MCPForUnityEditorWindow.cs
@@ -47,9 +47,10 @@ public class MCPForUnityEditorWindow : EditorWindow
         private static readonly HashSet<MCPForUnityEditorWindow> OpenWindows = new();
         private bool guiCreated = false;
         private bool toolsLoaded = false;
-        private bool resourcesLoaded = false;
-        private double lastRefreshTime = 0;
-        private const double RefreshDebounceSeconds = 0.5;
+        private bool resourcesLoaded = false;
+        private double lastRefreshTime = 0;
+        private const double RefreshDebounceSeconds = 0.5;
+        private bool updateCheckQueued = false;
 
         private enum ActivePanel
         {
@@ -321,23 +322,70 @@ public void CreateGUI()
 
             guiCreated = true;
 
-            // Initial updates
-            RefreshAllData();
-        }
+            // Initial updates
+            RefreshAllData();
+        }
 
-        private void UpdateVersionLabel(bool useBetaServer)
-        {
-            if (versionLabel == null)
-            {
-                return;
+        private void UpdateVersionLabel(bool useBetaServer)
+        {
+            if (versionLabel == null)
+            {
+                return;
             }
 
             string version = AssetPathUtility.GetPackageVersion();
             versionLabel.text = $"v{version}";
             versionLabel.tooltip = useBetaServer
                 ? "Beta server mode - fetching pre-release server versions from PyPI"
-                : $"MCP For Unity v{version}";
-        }
+                : $"MCP For Unity v{version}";
+        }
+
+        private void QueueUpdateCheck()
+        {
+            if (updateCheckQueued)
+            {
+                return;
+            }
+
+            updateCheckQueued = true;
+            EditorApplication.delayCall += CheckForPackageUpdates;
+        }
+
+        private void CheckForPackageUpdates()
+        {
+            updateCheckQueued = false;
+
+            if (updateNotification == null || updateNotificationText == null)
+            {
+                return;
+            }
+
+            string currentVersion = AssetPathUtility.GetPackageVersion();
+            if (string.IsNullOrEmpty(currentVersion) || currentVersion == "unknown")
+            {
+                updateNotification.RemoveFromClassList("visible");
+                return;
+            }
+
+            try
+            {
+                var result = MCPServiceLocator.Updates.CheckForUpdate(currentVersion);
+                if (result.CheckSucceeded && result.UpdateAvailable && !string.IsNullOrEmpty(result.LatestVersion))
+                {
+                    updateNotificationText.text = $"Newer version available: v{result.LatestVersion} (current v{currentVersion})";
+                    updateNotification.AddToClassList("visible");
+                }
+                else
+                {
+                    updateNotification.RemoveFromClassList("visible");
+                }
+            }
+            catch (Exception ex)
+            {
+                McpLog.Info($"Package update check skipped: {ex.Message}");
+                updateNotification.RemoveFromClassList("visible");
+            }
+        }
 
         private void EnsureToolsLoaded()
         {
@@ -458,9 +506,10 @@ private void RefreshAllData()
                 _ = connectionSection?.VerifyBridgeConnectionAsync();
             }
 
-            advancedSection?.UpdatePathOverrides();
-            clientConfigSection?.RefreshSelectedClient();
-        }
+            advancedSection?.UpdatePathOverrides();
+            clientConfigSection?.RefreshSelectedClient();
+            QueueUpdateCheck();
+        }
 
         private void SetupTabs()
         {