fix.可爱的我一直在修CI（

.github/workflows/build.yml

@@ -1,4 +1,4 @@
-name: Build
+name: Build
 
 on:
   push:
@@ -10,6 +10,7 @@ on:
 env:
   DOTNET_VERSION: '10.0.x'
   Solution_Name: LanMountainDesktop.slnx
+  DOTNET_gcServer: 1
 
 jobs:
   build-windows:
@@ -63,7 +64,8 @@ jobs:
           sudo apt-get install -y \
             libfontconfig1 libfreetype6 \
             libx11-6 libxrandr2 libxinerama1 \
-            libxi6 libxcursor1 libxext6
+            libxi6 libxcursor1 libxext6 \
+            libxrender1 libxkbcommon-x11-0
 
       - name: Setup .NET
         uses: actions/setup-dotnet@v4

.github/workflows/code-quality.yml

@@ -1,4 +1,4 @@
-name: Quality Check
+name: Quality Check
 
 on:
   pull_request:
@@ -9,6 +9,7 @@ on:
 env:
   DOTNET_VERSION: '10.0.x'
   Solution_Name: LanMountainDesktop.slnx
+  DOTNET_gcServer: 1
 
 jobs:
   analyze:

.github/workflows/release.yml

@@ -1,4 +1,4 @@
-name: Release
+name: Release
 
 on:
   push:
@@ -19,6 +19,7 @@ on:
 env:
   DOTNET_VERSION: '10.0.x'
   Solution_Name: LanMountainDesktop.slnx
+  DOTNET_gcServer: 1
 
 jobs:
   prepare:
@@ -29,7 +30,7 @@ jobs:
       informational_version: ${{ steps.version.outputs.informational_version }}
       tag: ${{ steps.version.outputs.tag }}
       checkout_ref: ${{ steps.version.outputs.checkout_ref }}
-    
+
     steps:
       - name: Get release info
         id: version
@@ -66,9 +67,15 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: [x64, x86]
-    name: Build_Windows_${{ matrix.arch }}
-    
+        include:
+          - arch: x64
+            self_contained: true
+            suffix: ''
+          - arch: x86
+            self_contained: true
+            suffix: ''
+    name: Build_Windows_${{ matrix.arch }}${{ matrix.suffix }}
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -93,23 +100,114 @@ jobs:
           -p:FileVersion=${{ needs.prepare.outputs.assembly_version }}
           -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
 
-      - name: Publish
+      - name: Publish Launcher
         run: |
-          dotnet publish LanMountainDesktop/LanMountainDesktop.csproj `
-            -c Release `
-            -o ./publish/windows-${{ matrix.arch }} `
-            --self-contained `
-            -r win-${{ matrix.arch }} `
-            -p:PublishSingleFile=false `
-            -p:SelfContained=true `
-            -p:DebugType=none `
-            -p:DebugSymbols=false `
-            -p:PublishTrimmed=false `
-            -p:PublishReadyToRun=false `
-            -p:Version=${{ needs.prepare.outputs.version }} `
-            -p:AssemblyVersion=${{ needs.prepare.outputs.assembly_version }} `
-            -p:FileVersion=${{ needs.prepare.outputs.assembly_version }} `
-            -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
+          $version = "${{ needs.prepare.outputs.version }}"
+          $arch = "${{ matrix.arch }}"
+          $selfContained = "${{ matrix.self_contained }}" -eq "true"
+          $launcherPublishDir = "publish/launcher-win-$arch"
+
+          if ($selfContained) {
+            dotnet publish LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj `
+              -c Release `
+              -o ./$launcherPublishDir `
+              --self-contained `
+              -r win-$arch `
+              -p:PublishSingleFile=false `
+              -p:PublishTrimmed=false `
+              -p:PublishReadyToRun=false `
+              -p:DebugType=none `
+              -p:DebugSymbols=false
+          } else {
+            dotnet publish LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj `
+              -c Release `
+              -o ./$launcherPublishDir `
+              --self-contained:false `
+              -p:PublishSingleFile=false `
+              -p:PublishTrimmed=false `
+              -p:PublishReadyToRun=false `
+              -p:DebugType=none `
+              -p:DebugSymbols=false
+          }
+
+          Write-Host "Launcher published to: $launcherPublishDir"
+        shell: pwsh
+
+      - name: Publish Main App
+        run: |
+          $selfContained = "${{ matrix.self_contained }}" -eq "true"
+          $publishDir = if ($selfContained) { "publish/windows-${{ matrix.arch }}" } else { "publish/windows-${{ matrix.arch }}-lite" }
+
+          if ($selfContained) {
+            dotnet publish LanMountainDesktop/LanMountainDesktop.csproj `
+              -c Release `
+              -o ./$publishDir `
+              --self-contained `
+              -r win-${{ matrix.arch }} `
+              -p:PublishSingleFile=false `
+              -p:DebugType=none `
+              -p:DebugSymbols=false `
+              -p:PublishTrimmed=false `
+              -p:PublishReadyToRun=false `
+              -p:Version=${{ needs.prepare.outputs.version }} `
+              -p:AssemblyVersion=${{ needs.prepare.outputs.assembly_version }} `
+              -p:FileVersion=${{ needs.prepare.outputs.assembly_version }} `
+              -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
+          } else {
+            dotnet publish LanMountainDesktop/LanMountainDesktop.csproj `
+              -c Release `
+              -o ./$publishDir `
+              --self-contained:false `
+              -p:PublishSingleFile=false `
+              -p:DebugType=none `
+              -p:DebugSymbols=false `
+              -p:PublishTrimmed=false `
+              -p:PublishReadyToRun=false `
+              -p:Version=${{ needs.prepare.outputs.version }} `
+              -p:AssemblyVersion=${{ needs.prepare.outputs.assembly_version }} `
+              -p:FileVersion=${{ needs.prepare.outputs.assembly_version }} `
+              -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
+          }
+
+          Write-Host "Published to: $publishDir"
+          Write-Host "Self-contained: $selfContained"
+        shell: pwsh
+
+      - name: Restructure for Launcher
+        run: |
+          $version = "${{ needs.prepare.outputs.version }}"
+          $arch = "${{ matrix.arch }}"
+          $selfContained = "${{ matrix.self_contained }}" -eq "true"
+          $publishDir = if ($selfContained) { "publish/windows-$arch" } else { "publish/windows-$arch-lite" }
+          $launcherPublishDir = "publish/launcher-win-$arch"
+          $appDir = "app-$version"
+
+          Write-Host "Restructuring for Launcher mode..."
+          Write-Host "Version: $version"
+          Write-Host "Publish dir: $publishDir"
+
+          $newStructure = "publish-launcher/windows-$arch"
+          New-Item -ItemType Directory -Path $newStructure -Force | Out-Null
+
+          $appPath = Join-Path $newStructure $appDir
+          Move-Item -Path $publishDir -Destination $appPath -Force
+
+          $launcherSource = $launcherPublishDir
+          if (Test-Path $launcherSource) {
+            Write-Host "Copying Launcher to root..."
+            Copy-Item -Path "$launcherSource\*" -Destination $newStructure -Recurse -Force
+          } else {
+            Write-Warning "Launcher publish dir not found: $launcherSource"
+          }
+
+          New-Item -ItemType File -Path (Join-Path $appPath ".current") -Force | Out-Null
+
+          Write-Host "New directory structure:"
+          Get-ChildItem -Path $newStructure -Recurse -Depth 2 | Select-Object FullName
+
+          Remove-Item -Path $publishDir -Recurse -Force -ErrorAction SilentlyContinue
+          Remove-Item -Path $launcherPublishDir -Recurse -Force -ErrorAction SilentlyContinue
+          Move-Item -Path $newStructure -Destination $publishDir -Force
         shell: pwsh
 
       - name: Install Inno Setup
@@ -120,27 +218,25 @@ jobs:
         run: |
           $version = "${{ needs.prepare.outputs.version }}"
           $arch = "${{ matrix.arch }}"
-          $publishDir = "publish\windows-$arch"
+          $selfContained = "${{ matrix.self_contained }}" -eq "true"
+          $suffix = "${{ matrix.suffix }}"
+          $publishDir = if ($selfContained) { "publish\windows-$arch" } else { "publish\windows-$arch-lite" }
           $installerScript = "LanMountainDesktop\installer\LanMountainDesktop.iss"
           $outputDir = "build-installer"
-          
-          # Verify source directory exists
+
           if (-not (Test-Path -Path $publishDir)) {
             Write-Error "Publish directory not found: $publishDir"
             Get-ChildItem -Path "publish" -Directory -ErrorAction SilentlyContinue | Select-Object Name
             exit 1
           }
-          
-          # Create output directory
+
           New-Item -ItemType Directory -Path $outputDir -Force | Out-Null
-          
-          # Verify installer script exists
+
           if (-not (Test-Path -Path $installerScript)) {
             Write-Error "Installer script not found: $installerScript"
             exit 1
           }
-          
-          # Find Inno Setup compiler (choco may install a shim in PATH)
+
           $isccPath = $null
           $isccCommand = Get-Command ISCC.exe -ErrorAction SilentlyContinue
           if ($isccCommand) {
@@ -172,12 +268,11 @@ jobs:
             Write-Error "Inno Setup compiler not found."
             exit 1
           }
-          
+
           Write-Host "Found Inno Setup at: $isccPath"
-          
-          # Build installer with iscc.exe
+
           Write-Host "Building installer for Windows $arch with version $version..."
-          
+
           $publishDir = (Resolve-Path $publishDir).Path
           $outputDir = (Resolve-Path $outputDir).Path
           $installerScript = (Resolve-Path $installerScript).Path
@@ -187,33 +282,234 @@ jobs:
             "/DPublishDir=$publishDir",
             "/DMyOutputDir=$outputDir",
             "/DMyAppArch=$arch",
+            "/DMyAppSuffix=$suffix",
+            "/DIsSelfContained=$selfContained",
             $installerScript
           )
-          
+
           Write-Host "Compile command: `"$isccPath`" $($compileArgs -join ' ')"
-          
-          # Execute the compiler
+
           & $isccPath @compileArgs
           if ($LASTEXITCODE -ne 0) {
             Write-Error "Inno Setup compiler exited with code $LASTEXITCODE"
             exit 1
           }
-          
-          # Check if build was successful
+
           $installerFile = Get-ChildItem -Path $outputDir -Filter "*.exe" -ErrorAction SilentlyContinue | Select-Object -First 1
           if (-not $installerFile) {
             Write-Error "Failed to create installer"
             exit 1
           }
-          
-          Write-Host "✅ Successfully created: $($installerFile.Name)"
+
+          Write-Host "Successfully created: $($installerFile.Name)"
           Write-Host "Installer size: $([Math]::Round($installerFile.Length / 1MB, 2)) MB"
         shell: pwsh
 
+      - name: Generate Delta Package
+        if: matrix.self_contained == true && matrix.arch == 'x64'
+        run: |
+          $version = "${{ needs.prepare.outputs.version }}"
+          $publishDir = "publish/windows-${{ matrix.arch }}"
+          $appDir = "app-$version"
+          $currentAppPath = Join-Path $publishDir $appDir
+          $outputDir = "delta-output"
+
+          New-Item -ItemType Directory -Path $outputDir -Force | Out-Null
+
+          # --- Determine previous version and download its update.zip for diff ---
+          $previousVersion = $null
+          $previousAppPath = $null
+          try {
+            $headers = @{ "User-Agent" = "LanMountainDesktop-CI"; "Authorization" = "token ${{ secrets.GITHUB_TOKEN }}" }
+            $releases = Invoke-RestMethod -Uri "https://api.github.com/repos/${{ github.repository }}/releases?per_page=10" -Headers $headers
+            $previousRelease = $releases | Where-Object { -not $_.prerelease -and -not $_.draft } | Select-Object -First 1
+            if ($previousRelease) {
+              $previousVersion = $previousRelease.tag_name.TrimStart('v','V')
+              Write-Host "Previous release version: $previousVersion"
+
+              # Try to download update.zip from previous release for diff
+              $prevUpdateZip = $previousRelease.assets | Where-Object { $_.name -eq "update.zip" } | Select-Object -First 1
+              if ($prevUpdateZip) {
+                Write-Host "Found update.zip in previous release - extracting for diff..."
+                $prevZipDest = Join-Path $outputDir "prev-update.zip"
+                Invoke-WebRequest -Uri $prevUpdateZip.browser_download_url -OutFile $prevZipDest -Headers $headers
+
+                $previousAppPath = Join-Path $outputDir "prev-app"
+                New-Item -ItemType Directory -Path $previousAppPath -Force | Out-Null
+                Expand-Archive -Path $prevZipDest -DestinationPath $previousAppPath -Force
+                Remove-Item -Path $prevZipDest -Force
+
+                $prevFileCount = (Get-ChildItem -Path $previousAppPath -Recurse -File).Count
+                Write-Host "Extracted $prevFileCount files from previous version for diff"
+              } else {
+                Write-Host "No update.zip found in previous release - will generate full package"
+              }
+            }
+          } catch {
+            Write-Host "Could not fetch previous release: $_"
+          }
+
+          # --- Generate file manifest with diff against previous version ---
+          Write-Host "Generating update package for version $version..."
+          $files = Get-ChildItem -Path $currentAppPath -Recurse -File
+          $fileEntries = [System.Collections.ArrayList]::new()
+          $changedFiles = [System.Collections.ArrayList]::new()
+          $reusedCount = 0
+          $addedCount = 0
+          $replacedCount = 0
+          $deletedCount = 0
+
+          # Build hash map of previous version files for quick lookup
+          $prevHashMap = @{}
+          if ($previousAppPath -and (Test-Path $previousAppPath)) {
+            $prevFiles = Get-ChildItem -Path $previousAppPath -Recurse -File
+            foreach ($pf in $prevFiles) {
+              $relPath = $pf.FullName.Substring($previousAppPath.Length).TrimStart('\', '/').Replace('\', '/')
+              if ($relPath -match '^\.(current|partial|destroy)$') { continue }
+              $prevHashMap[$relPath] = (Get-FileHash -Path $pf.FullName -Algorithm SHA256).Hash.ToLower()
+            }
+            Write-Host "Previous version has $($prevHashMap.Count) files for comparison"
+          }
+
+          foreach ($file in $files) {
+            $relativePath = $file.FullName.Substring($currentAppPath.Length).TrimStart('\', '/')
+            $relativePath = $relativePath.Replace('\', '/')
+
+            # Skip deployment marker files
+            if ($relativePath -match '^\.(current|partial|destroy)$') {
+              continue
+            }
+
+            $hash = (Get-FileHash -Path $file.FullName -Algorithm SHA256).Hash.ToLower()
+
+            if ($prevHashMap.ContainsKey($relativePath)) {
+              $prevHash = $prevHashMap[$relativePath]
+              if ($hash -eq $prevHash) {
+                $fileEntries += @{ Path = $relativePath; Action = "reuse"; Sha256 = $hash }
+                $reusedCount++
+              } else {
+                $fileEntries += @{ Path = $relativePath; Action = "replace"; Sha256 = $hash; ArchivePath = $relativePath }
+                $changedFiles += $file
+                $replacedCount++
+              }
+              $prevHashMap.Remove($relativePath)
+            } else {
+              $fileEntries += @{ Path = $relativePath; Action = "add"; Sha256 = $hash; ArchivePath = $relativePath }
+              $changedFiles += $file
+              $addedCount++
+            }
+          }
+
+          # Files in previous version but not in current = deleted
+          foreach ($deletedPath in $prevHashMap.Keys) {
+            $fileEntries += @{ Path = $deletedPath; Action = "delete" }
+            $deletedCount++
+          }
+
+          Write-Host "Delta summary: $reusedCount reused, $replacedCount replaced, $addedCount added, $deletedCount deleted"
+          Write-Host "Changed files to include in update.zip: $($changedFiles.Count)"
+
+          $filesJson = @{
+            FromVersion = $previousVersion
+            ToVersion = $version
+            Platform = "windows"
+            Arch = "x64"
+            Files = $fileEntries
+          } | ConvertTo-Json -Depth 10
+
+          $filesJsonPath = Join-Path $outputDir "files.json"
+          $filesJson | Set-Content -Path $filesJsonPath -Encoding UTF8
+          Write-Host "Generated files.json with $($fileEntries.Count) entries"
+
+          # Create update.zip with only changed files
+          $tempDir = Join-Path $outputDir "temp_staging"
+          New-Item -ItemType Directory -Path $tempDir -Force | Out-Null
+          foreach ($file in $changedFiles) {
+            $relativePath = $file.FullName.Substring($currentAppPath.Length).TrimStart('\', '/')
+            $destPath = Join-Path $tempDir $relativePath
+            $destDir = Split-Path -Parent $destPath
+            if (-not (Test-Path $destDir)) { New-Item -ItemType Directory -Path $destDir -Force | Out-Null }
+            Copy-Item -Path $file.FullName -Destination $destPath -Force
+          }
+
+          $updateZipPath = Join-Path $outputDir "update.zip"
+          if ($changedFiles.Count -gt 0) {
+            Compress-Archive -Path "$tempDir\*" -DestinationPath $updateZipPath -CompressionLevel Optimal
+          } else {
+            # No changed files - create a minimal zip
+            $emptyMarker = Join-Path $tempDir ".no-changes"
+            Set-Content -Path $emptyMarker -Value ""
+            Compress-Archive -Path "$tempDir\*" -DestinationPath $updateZipPath -CompressionLevel Optimal
+          }
+          Remove-Item -Path $tempDir -Recurse -Force
+
+          Write-Host "Created update.zip: $([Math]::Round((Get-Item $updateZipPath).Length / 1MB, 2)) MB"
+
+          # Clean up previous version extraction
+          if ($previousAppPath -and (Test-Path $previousAppPath)) {
+            Remove-Item -Path $previousAppPath -Recurse -Force -ErrorAction SilentlyContinue
+          }
+        shell: pwsh
+
+      - name: Sign File Map
+        if: matrix.self_contained == true && matrix.arch == 'x64'
+        run: |
+          $outputDir = "delta-output"
+          $filesJsonPath = Join-Path $outputDir "files.json"
+          $signaturePath = Join-Path $outputDir "files.json.sig"
+
+          if (-not (Test-Path $filesJsonPath)) {
+            Write-Error "files.json not found at $filesJsonPath"
+            exit 1
+          }
+
+          $privateKeyPem = "${{ secrets.UPDATE_PRIVATE_KEY_PEM }}"
+          if ([string]::IsNullOrWhiteSpace($privateKeyPem)) {
+            Write-Warning "UPDATE_PRIVATE_KEY_PEM secret not configured - generating unsigned placeholder"
+            Set-Content -Path $signaturePath -Value "" -Encoding ASCII
+            exit 0
+          }
+
+          $privateKeyPath = Join-Path $env:RUNNER_TEMP "signing-key.pem"
+          Set-Content -Path $privateKeyPath -Value $privateKeyPem -Encoding ASCII
+
+          Add-Type -ReferencedAssemblies @("System.Security.Cryptography", "System.IO") -TypeDefinition @"
+          using System;
+          using System.IO;
+          using System.Security.Cryptography;
+          public class RsaSigner {
+              public static void Sign(string jsonPath, string keyPath, string sigPath) {
+                  var jsonBytes = File.ReadAllBytes(jsonPath);
+                  var rsa = RSA.Create();
+                  rsa.ImportFromPem(File.ReadAllText(keyPath));
+                  var sig = rsa.SignData(jsonBytes, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+                  File.WriteAllText(sigPath, Convert.ToBase64String(sig));
+              }
+          }
+          "@
+
+          [RsaSigner]::Sign($filesJsonPath, $privateKeyPath, $signaturePath)
+          Remove-Item -Path $privateKeyPath -Force
+
+          Write-Host "Signed files.json -> files.json.sig"
+        shell: pwsh
+
+      - name: Upload Delta Package
+        if: matrix.self_contained == true && matrix.arch == 'x64'
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-delta-windows-x64
+          path: |
+            delta-output/files.json
+            delta-output/files.json.sig
+            delta-output/update.zip
+          if-no-files-found: error
+          retention-days: 90
+
       - name: Upload Installer
         uses: actions/upload-artifact@v4
         with:
-          name: release-windows-${{ matrix.arch }}
+          name: release-windows-${{ matrix.arch }}${{ matrix.suffix }}
           path: build-installer/*.exe
           if-no-files-found: error
           retention-days: 30
@@ -222,7 +518,7 @@ jobs:
     needs: prepare
     runs-on: ubuntu-latest
     name: Build_Linux
-    
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -256,11 +552,24 @@ jobs:
           -p:FileVersion=${{ needs.prepare.outputs.assembly_version }}
           -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
 
-      - name: Publish
+      - name: Publish Launcher
+        run: |
+          dotnet publish LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj \
+            -c Release \
+            -o ./publish/launcher-linux-x64 \
+            --self-contained \
+            -r linux-x64 \
+            -p:PublishSingleFile=false \
+            -p:PublishTrimmed=false \
+            -p:PublishReadyToRun=false \
+            -p:DebugType=none \
+            -p:DebugSymbols=false
+
+      - name: Publish Main App
         run: |
           dotnet publish LanMountainDesktop/LanMountainDesktop.csproj \
             -c Release \
-            -o ./publish/linux-x64 \
+            -o ./publish/linux-x64-app \
             --self-contained \
             -r linux-x64 \
             -p:PublishSingleFile=false \
@@ -274,6 +583,34 @@ jobs:
             -p:FileVersion=${{ needs.prepare.outputs.assembly_version }} \
             -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
 
+      - name: Restructure for Launcher
+        run: |
+          version="${{ needs.prepare.outputs.version }}"
+          publishDir="publish/linux-x64"
+          appDir="app-$version"
+          launcherDir="publish/launcher-linux-x64"
+
+          echo "Restructuring for Launcher mode..."
+          echo "Version: $version"
+
+          mkdir -p "$publishDir"
+          mv "publish/linux-x64-app" "$publishDir/$appDir"
+
+          if [ -d "$launcherDir" ]; then
+            echo "Copying Launcher to root..."
+            cp -r "$launcherDir"/* "$publishDir/"
+            chmod +x "$publishDir/LanMountainDesktop.Launcher" 2>/dev/null || true
+          else
+            echo "Warning: Launcher publish dir not found: $launcherDir"
+          fi
+
+          touch "$publishDir/$appDir/.current"
+
+          echo "New directory structure:"
+          find "$publishDir" -maxdepth 2 | head -50
+
+          rm -rf "$launcherDir"
+
       - name: Package as DEB
         run: |
           version="${{ needs.prepare.outputs.version }}"
@@ -283,28 +620,24 @@ jobs:
           arch="amd64"
           desktop_template="LanMountainDesktop/packaging/linux/LanMountainDesktop.desktop"
           icon_source="LanMountainDesktop/packaging/linux/lanmountaindesktop.png"
-          
-          # Verify source directory exists
+
           if [ ! -d "$source" ]; then
             echo "Error: Source directory not found: $source"
             ls -la publish/ || echo "publish directory not found"
             exit 1
           fi
-          
-          # Create DEB package structure
+
           mkdir -p "build-deb/DEBIAN"
           mkdir -p "build-deb/usr/local/bin"
           mkdir -p "build-deb/usr/share/applications"
           mkdir -p "build-deb/usr/share/pixmaps"
           mkdir -p "build-deb/usr/share/icons/hicolor/256x256/apps"
-          
-          # Copy application files
+
           cp -r "$source"/* "build-deb/usr/local/bin/"
-          
-          # Verify copy was successful
+
           item_count=$(find build-deb/usr/local/bin -type f 2>/dev/null | wc -l)
           echo "DEB package contains $item_count files"
-          
+
           if [ "$item_count" -eq 0 ]; then
             echo "Error: DEB package is empty after copy"
             exit 1
@@ -317,7 +650,7 @@ jobs:
           fi
 
           sed \
-            -e "s|@@EXEC@@|/usr/local/bin/LanMountainDesktop|g" \
+            -e "s|@@EXEC@@|/usr/local/bin/LanMountainDesktop.Launcher|g" \
             -e "s|@@ICON@@|lanmountaindesktop|g" \
             "$desktop_template" > "build-deb/usr/share/applications/LanMountainDesktop.desktop"
 
@@ -334,8 +667,7 @@ jobs:
             printf '%s\n' '  gtk-update-icon-cache /usr/share/icons/hicolor >/dev/null 2>&1 || true'
             printf '%s\n' 'fi'
           } > "build-deb/DEBIAN/postinst"
-          
-          # Create control file (NOTE: No leading spaces in control file)
+
           {
             printf '%s\n' "Package: $package_name"
             printf '%s\n' "Version: $package_version"
@@ -344,15 +676,13 @@ jobs:
             printf '%s\n' "Description: LanMountain Desktop Application"
             printf '%s\n' " A desktop application for LanMountain."
           } > "build-deb/DEBIAN/control"
-          
-          # Set proper permissions
-          chmod 755 "build-deb/usr/local/bin/LanMountainDesktop" || chmod 755 "build-deb/usr/local/bin"/*
+
+          chmod 755 "build-deb/usr/local/bin/LanMountainDesktop.Launcher" 2>/dev/null || chmod 755 "build-deb/usr/local/bin"/*
           chmod 644 "build-deb/usr/share/applications/LanMountainDesktop.desktop"
           chmod 644 "build-deb/usr/share/pixmaps/lanmountaindesktop.png"
           chmod 644 "build-deb/usr/share/icons/hicolor/256x256/apps/lanmountaindesktop.png"
           chmod 755 "build-deb/DEBIAN/postinst"
-          
-          # Create DEB file
+
           if dpkg-deb --build "build-deb" "${package_name}_${package_version}_${arch}.deb"; then
             echo "Successfully created: ${package_name}_${package_version}_${arch}.deb"
             ls -lh "${package_name}_${package_version}_${arch}.deb"
@@ -376,7 +706,7 @@ jobs:
       matrix:
         arch: [x64, arm64]
     name: Build_macOS_${{ matrix.arch }}
-    
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -401,11 +731,24 @@ jobs:
           -p:FileVersion=${{ needs.prepare.outputs.assembly_version }}
           -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
 
-      - name: Publish
+      - name: Publish Launcher
+        run: |
+          dotnet publish LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj \
+            -c Release \
+            -o ./publish/launcher-macos-${{ matrix.arch }} \
+            --self-contained \
+            -r osx-${{ matrix.arch }} \
+            -p:PublishSingleFile=false \
+            -p:PublishTrimmed=false \
+            -p:PublishReadyToRun=false \
+            -p:DebugType=none \
+            -p:DebugSymbols=false
+
+      - name: Publish Main App
         run: |
           dotnet publish LanMountainDesktop/LanMountainDesktop.csproj \
             -c Release \
-            -o ./publish/macos-${{ matrix.arch }} \
+            -o ./publish/macos-${{ matrix.arch }}-app \
             --self-contained \
             -r osx-${{ matrix.arch }} \
             -p:PublishSingleFile=false \
@@ -419,45 +762,57 @@ jobs:
             -p:FileVersion=${{ needs.prepare.outputs.assembly_version }} \
             -p:InformationalVersion=${{ needs.prepare.outputs.informational_version }}
 
-      - name: Package as DMG
+      - name: Restructure and Package as DMG
         run: |
           version="${{ needs.prepare.outputs.version }}"
           arch="${{ matrix.arch }}"
-          source="publish/macos-$arch"
           app_name="LanMountainDesktop"
           package_name="${app_name}-${version}-macos-${arch}"
-          
-          # Verify source directory exists
-          if [ ! -d "$source" ]; then
-            echo "Error: Source directory not found: $source"
-            ls -la publish/ || echo "publish directory not found"
+          launcherDir="publish/launcher-macos-$arch"
+          appSourceDir="publish/macos-$arch-app"
+
+          echo "Restructuring for Launcher mode..."
+          echo "Version: $version"
+
+          mkdir -p "${app_name}.app/Contents/MacOS"
+
+          appDir="app-$version"
+          mkdir -p "${app_name}.app/Contents/MacOS/$appDir"
+
+          if [ -d "$appSourceDir" ]; then
+            cp -r "$appSourceDir"/* "${app_name}.app/Contents/MacOS/$appDir/"
+          else
+            echo "Error: Main app source directory not found: $appSourceDir"
             exit 1
           fi
-          
-          # Create app bundle structure
-          mkdir -p "${app_name}.app/Contents/MacOS"
+
+          if [ -d "$launcherDir" ]; then
+            echo "Copying Launcher to root..."
+            cp -r "$launcherDir"/* "${app_name}.app/Contents/MacOS/"
+            chmod +x "${app_name}.app/Contents/MacOS/LanMountainDesktop.Launcher" 2>/dev/null || true
+          else
+            echo "Warning: Launcher publish dir not found: $launcherDir"
+          fi
+
+          touch "${app_name}.app/Contents/MacOS/$appDir/.current"
+
           mkdir -p "${app_name}.app/Contents/Resources"
-          
-          # Copy application files
-          cp -r "$source"/* "${app_name}.app/Contents/MacOS/"
-          
-          # Verify copy was successful
+
           item_count=$(find "${app_name}.app/Contents/MacOS" -type f | wc -l)
           echo "App bundle contains $item_count files"
-          
+
           if [ "$item_count" -eq 0 ]; then
             echo "Error: App bundle is empty after copy"
             exit 1
           fi
 
-          # Create Info.plist
           {
             printf '%s\n' '<?xml version="1.0" encoding="UTF-8"?>'
             printf '%s\n' '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">'
             printf '%s\n' '<plist version="1.0">'
             printf '%s\n' '<dict>'
             printf '%s\n' '  <key>CFBundleExecutable</key>'
-            printf '%s\n' '  <string>LanMountainDesktop</string>'
+            printf '%s\n' '  <string>LanMountainDesktop.Launcher</string>'
             printf '%s\n' '  <key>CFBundleName</key>'
             printf '%s\n' '  <string>LanMountain Desktop</string>'
             printf '%s\n' '  <key>CFBundleVersion</key>'
@@ -471,11 +826,10 @@ jobs:
             printf '%s\n' '</dict>'
             printf '%s\n' '</plist>'
           } > "${app_name}.app/Contents/Info.plist"
-          
-          # Create DMG
+
           mkdir -p dmg-temp
           cp -r "${app_name}.app" dmg-temp/
-          
+
           if hdiutil create -volname "${app_name}" -srcfolder dmg-temp -ov -format UDZO "${package_name}.dmg" 2>&1; then
             echo "Successfully created: ${package_name}.dmg"
             ls -lh "${package_name}.dmg"
@@ -483,8 +837,7 @@ jobs:
             echo "Error: Failed to create DMG"
             exit 1
           fi
-          
-          # Cleanup
+
           rm -rf dmg-temp "${app_name}.app"
 
       - name: Upload
@@ -500,7 +853,7 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: write
-    
+
     steps:
       - name: Download artifacts
         uses: actions/download-artifact@v4
@@ -510,29 +863,32 @@ jobs:
 
       - name: List artifacts structure
         run: |
-          echo "🔍 Artifact directory structure:"
+          echo "Artifact directory structure:"
           find artifacts -type f -o -type d | sort
           echo ""
-          echo "📊 Files found:"
+          echo "Files found:"
           find artifacts -type f -exec ls -lh {} \;
           echo ""
-          echo "📁 Full tree:"
+          echo "Full tree:"
           tree artifacts || find artifacts -print | sed -e 's;[^/]*/;|____;g;s;____|; |;g'
 
       - name: Flatten artifacts for release
         run: |
-          echo "📦 Organizing artifacts..."
+          echo "Organizing artifacts..."
           mkdir -p release-files
+          # Copy installers and packages
           find artifacts -type f \( -name "*.exe" -o -name "*.deb" -o -name "*.dmg" \) -exec cp -v {} release-files/ \;
+          # Copy delta update files (files.json, files.json.sig, update.zip)
+          find artifacts -type f \( -name "files.json" -o -name "files.json.sig" -o -name "update.zip" \) -exec cp -v {} release-files/ \;
           echo ""
-          echo "✅ Files ready for release:"
-          ls -lh release-files/ || echo "⚠️ No files found in release-files"
+          echo "Files ready for release:"
+          ls -lh release-files/ || echo "No files found in release-files"
           echo ""
-          echo "📋 Total files:"
+          echo "Total files:"
           file_count=$(find release-files -type f | wc -l)
           echo "$file_count"
           if [ "$file_count" -eq 0 ]; then
-            echo "Error: No installer/package files found for release"
+            echo "Error: No release files found"
             exit 1
           fi
 
@@ -548,19 +904,26 @@ jobs:
           artifacts: "release-files/**"
           body: |
             ## Release ${{ needs.prepare.outputs.version }}
-            
+
             ### Windows
-            - **LanMountainDesktop-Setup-{version}-x64.exe** - 64-bit installer
-            - **LanMountainDesktop-Setup-{version}-x86.exe** - 32-bit installer
-            
+            - **LanMountainDesktop-Setup-${{ needs.prepare.outputs.version }}-x64.exe** - 64-bit installer (includes .NET runtime)
+            - **LanMountainDesktop-Setup-${{ needs.prepare.outputs.version }}-x86.exe** - 32-bit installer (includes .NET runtime)
+
             Installation: Double-click the .exe file and follow the wizard.
-            
+
+            ### Incremental Update (Windows x64)
+            - **files.json** - Update manifest listing changed files
+            - **files.json.sig** - RSA signature of the manifest
+            - **update.zip** - Archive containing changed files
+
+            Existing users: The app will automatically detect and apply the incremental update on next launch.
+
             ### Linux
-            - **LanMountainDesktop-{version}-linux-x64.deb** - Debian package (x64)
-            
+            - **LanMountainDesktop-${{ needs.prepare.outputs.version }}-linux-x64.deb** - Debian package (x64)
+
             ### macOS
-            - **LanMountainDesktop-{version}-macos-x64.dmg** - Intel processor
-            - **LanMountainDesktop-{version}-macos-arm64.dmg** - Apple Silicon (M1/M2/M3)
-            
+            - **LanMountainDesktop-${{ needs.prepare.outputs.version }}-macos-x64.dmg** - Intel processor
+            - **LanMountainDesktop-${{ needs.prepare.outputs.version }}-macos-arm64.dmg** - Apple Silicon (M1/M2/M3)
+
             See commits for changes.
           token: ${{ secrets.GITHUB_TOKEN }}

.trae/skills/refactoring-insight/SKILL.md

@@ -0,0 +1,112 @@
+---
+name: "refactoring-insight"
+description: "Analyzes codebase for refactoring opportunities: large files, code duplication, god classes, naming inconsistencies, tight coupling, and missing abstractions. Invoke when user asks for refactoring insight/analysis or wants to improve code architecture."
+---
+
+# Refactoring Insight
+
+Deep codebase analysis skill that identifies structural problems and produces prioritized refactoring recommendations.
+
+## When to Invoke
+
+- User asks for "refactoring insight", "refactoring analysis", "code quality analysis", "architecture review"
+- User wants to understand what should be refactored in the codebase
+- User asks "where are the code smells?" or "what needs refactoring?"
+
+## Analysis Dimensions
+
+Run all 6 dimensions in parallel where possible. For each dimension, use search agents to gather data, then synthesize findings.
+
+### 1. Large Files / God Classes
+
+- Find all .cs files over 300 lines, sorted by line count descending
+- Identify partial classes and sum their total line count across files
+- Flag classes with 15+ methods or constructors taking 8+ parameters
+- Focus on: Views/, ViewModels/, Services/, plugins/
+
+**Output**: Table of files with line counts and responsibility summary.
+
+### 2. Code Duplication
+
+Search for these specific duplication patterns:
+
+- **Service boilerplate**: Repeated DI registration, `new` instantiation instead of DI
+- **Data service pattern**: Services that fetch/parse/transform data similarly (Load → Map → Save)
+- **Localization pattern**: `private readonly LocalizationService _localizationService = new();` and `L()` helper method repetitions
+- **Helper method duplication**: Methods like `ResolveUnifiedMainRadiusValue`, `NormalizeConfig`, `ParticleState` classes copied across files
+- **Error handling pattern**: Identical try-catch blocks repeated in multiple methods
+- **Settings snapshot pattern**: `_settingsFacade.Settings.LoadSnapshot<T>(scope)` call sites
+
+**Output**: List of duplicated patterns with file locations and line numbers.
+
+### 3. Tight Coupling
+
+- Services instantiated via `new` instead of DI injection
+- ViewModels directly accessing infrastructure-layer APIs (e.g., `LoadSnapshot/SaveSnapshot`)
+- Hard-coded dependencies (GitHub repo owner/name, default values)
+- `Application.Current` upcasting to access services: `(Application.Current as App)?.SomeService`
+- Platform-specific code embedded in cross-platform services without interface abstraction
+
+**Output**: Table of coupling violations with severity (high/medium/low).
+
+### 4. Naming Inconsistencies
+
+- Service suffix inconsistency: `Service` vs `Store` vs `Helper` vs `Provider` vs `Manager` vs `Factory` for similar responsibilities
+- Model suffix inconsistency: `Snapshot` vs `State` vs `Types` for similar concepts
+- Platform prefix inconsistency: `Windows`/`Linux` full name vs `Mac` abbreviation
+- Confusing names: services with similar names but different responsibilities (e.g., `NotificationService` vs `NotificationListenerService`)
+
+**Output**: Categorized list of naming inconsistencies.
+
+### 5. Missing Abstractions
+
+- Services without corresponding interfaces (check for `I<ServiceName>` pattern)
+- Common patterns that could be extracted into base classes:
+  - `SettingsPageViewModelBase` for shared ViewModel boilerplate
+  - `JsonFileSettingsService<TSnapshot>` for repeated settings persistence
+  - `SettingsDomainServiceBase<TState>` for Load-Map-Save pattern
+  - `DesktopComponentWidgetBase` for shared Widget code
+  - `ComponentEditorViewBase` enhancements (e.g., `_suppressEvents` pattern)
+- Static singleton/Factory providers repeating thread-safe lazy-load boilerplate
+
+**Output**: List of missing abstractions with proposed base class/interface names.
+
+### 6. Misplaced Responsibilities
+
+- Files in wrong directories (e.g., data access in Settings/, UI services mixed with data services)
+- ViewModels containing business logic or file system operations
+- Widget code-behind files with excessive logic (>200 lines)
+- Platform-specific services not organized into subdirectories
+
+**Output**: List of misplaced files/classes with recommended new locations.
+
+## Output Format
+
+Produce a structured report with:
+
+1. **Summary table**: Total metrics (file count, duplication count, etc.)
+2. **Priority-ranked findings**: P0 (must fix), P1 (should fix), P2 (recommended), P3 (nice to have)
+3. **Each finding includes**: Problem description, affected files with links, specific line numbers, recommended action, estimated impact
+
+### Priority Criteria
+
+- **P0**: Files over 1000 lines with mixed responsibilities; patterns duplicated 10+ times; god classes with 20+ dependencies
+- **P1**: Patterns duplicated 5-9 times; services without interfaces that are widely used; DI bypass affecting testability
+- **P2**: Patterns duplicated 3-4 times; naming inconsistencies affecting readability; misplaced files
+- **P3**: Minor naming variations; single-instance duplications; organizational improvements
+
+## Project-Specific Context
+
+This skill is aware of the LanMountainDesktop project structure:
+
+- `LanMountainDesktop/Services/` — Business and infrastructure services
+- `LanMountainDesktop/Services/Settings/` — Settings subsystem
+- `LanMountainDesktop/ViewModels/` — View models
+- `LanMountainDesktop/Views/Components/` — Desktop widget components
+- `LanMountainDesktop/Views/ComponentEditors/` — Widget editor views
+- `LanMountainDesktop/plugins/` — Plugin runtime
+- `LanMountainDesktop.PluginSdk/` — Plugin SDK public API
+- `LanMountainDesktop.Shared.Contracts/` — Host/plugin shared contracts
+- `LanMountainDesktop.Appearance/` — Appearance and corner radius infrastructure
+
+When analyzing, respect the project's architectural boundaries documented in `docs/ARCHITECTURE.md` and `docs/ECOSYSTEM_BOUNDARIES.md`.

.trae/specs/fused-desktop-library-redesign/spec.md

@@ -0,0 +1,166 @@
+# 融合桌面组件库窗口重设计规格
+
+## Why
+
+当前融合桌面组件库窗口（FusedDesktopComponentLibraryWindow）的UI设计较为基础，与Windows 11小组件编辑面板相比，缺乏现代化的交互体验和视觉层次。用户需要一个更直观、更美观的界面来浏览和添加组件到系统桌面（负一屏）。
+
+参考Windows 11小组件编辑面板的设计特点：
+
+* 左侧分类列表，右侧选中组件的详细预览
+
+* 大型组件预览区域，让用户清楚看到组件效果
+
+* 底部明显的"添加"操作按钮
+
+* 简洁的关闭按钮（X）在右上角
+
+* 深色主题配合毛玻璃效果
+
+## What Changes
+
+* **重新设计窗口布局**：从左右分栏（分类列表+组件网格）改为左侧面板+右侧预览区的布局
+
+* **添加组件详情预览区**：选中组件后右侧显示大尺寸预览和组件信息
+
+* **优化关闭按钮**：使用标准的X图标按钮，不使用圆形样式
+
+* **添加底部操作栏**：包含"添加到桌面"主操作按钮和"查找更多组件"链接
+
+* **复用阑山桌面组件库分类**：使用相同的分类ID、图标和本地化文本
+
+* **移除搜索功能**：参考Windows 11设计，暂不提供搜索
+
+## Impact
+
+* 受影响文件：
+
+  * `LanMountainDesktop/Views/FusedDesktopComponentLibraryWindow.axaml`
+
+  * `LanMountainDesktop/Views/FusedDesktopComponentLibraryWindow.axaml.cs`
+
+  * `LanMountainDesktop/Views/FusedDesktopComponentLibraryControl.axaml`
+
+  * `LanMountainDesktop/Views/FusedDesktopComponentLibraryControl.axaml.cs`
+
+  * `LanMountainDesktop/ViewModels/ComponentLibraryWindowViewModel.cs`（可能需要添加新属性）
+
+## ADDED Requirements
+
+### Requirement: 窗口布局重设计
+
+系统应提供一个类似于Windows 11小组件编辑面板的组件库窗口。
+
+#### Scenario: 窗口整体结构
+
+* **GIVEN** 用户从托盘菜单打开融合桌面组件库
+
+* **WHEN** 窗口显示时
+
+* **THEN** 窗口应呈现：
+
+  * 顶部标题栏：左侧显示"添加小组件"标题，右侧有关闭按钮（X）
+
+  * 左侧面板：分类列表（复用阑山桌面组件库的分类和图标）
+
+  * 右侧主区域：选中组件的大尺寸预览 + 组件信息 + 添加按钮
+
+  * 底部："查找更多组件"链接
+
+#### Scenario: 分类列表交互
+
+* **GIVEN** 左侧显示组件分类列表
+
+* **WHEN** 用户点击某个分类
+
+* **THEN** 右侧应显示该分类下的第一个组件的预览
+
+* **AND** 分类项应有选中状态视觉反馈
+
+* **AND** 分类图标和名称应与阑山桌面组件库保持一致
+
+#### Scenario: 组件预览区
+
+* **GIVEN** 用户选中一个组件
+
+* **WHEN** 预览区显示时
+
+* **THEN** 应显示：
+
+  * 组件标题（大字号）
+
+  * 大尺寸组件预览图（接近实际尺寸）
+
+  * 组件描述/功能说明
+
+  * 底部"添加到桌面"按钮
+
+#### Scenario: 添加组件操作
+
+* **GIVEN** 用户查看组件预览
+
+* **WHEN** 用户点击"添加到桌面"按钮
+
+* **THEN** 组件应被添加到系统桌面（负一屏）中央
+
+* **AND** 窗口应关闭
+
+#### Scenario: 关闭按钮样式
+
+* **GIVEN** 窗口标题栏有关闭按钮
+
+* **THEN** 关闭按钮应使用标准的X图标
+
+* **AND** 不使用圆形背景或特殊样式
+
+* **AND** 使用 `DesignCornerRadiusSm` 动态资源
+
+#### Scenario: 查找更多组件链接
+
+* **GIVEN** 窗口底部显示"查找更多组件"链接
+
+* **WHEN** 用户点击该链接
+
+* **THEN** 应打开设置窗口的插件目录页面（后续将改为插件市场）
+
+## MODIFIED Requirements
+
+### Requirement: 组件列表展示
+
+原实现使用网格展示所有组件，新实现改为：
+
+* 左侧列表仅显示分类（复用阑山桌面组件库的分类ID和图标映射）
+
+* 右侧预览区一次只显示一个组件的详细信息
+
+* ~~移除搜索功能~~（根据Windows 11设计，暂不提供搜索）
+
+### Requirement: 关闭按钮圆角规范
+
+原实现关闭按钮使用硬编码 `CornerRadius="18"`，应改为使用动态资源 `DesignCornerRadiusSm`。
+
+### Requirement: 分类图标复用
+
+分类图标映射应与阑山桌面组件库保持一致：
+
+* Clock -> Symbol.Clock
+
+* Date -> Symbol.CalendarDate
+
+* Weather -> Symbol.WeatherSunny
+
+* Board -> Symbol.Edit
+
+* Media -> Symbol.Play
+
+* Info -> Symbol.Info
+
+* Calculator -> Symbol.Calculator
+
+* Study -> Symbol.Hourglass
+
+* 其他 -> Symbol.Apps
+
+## REMOVED Requirements
+
+* ~~搜索功能~~：根据Windows 11小组件面板设计，暂不提供搜索功能
+

.trae/specs/fused-desktop-library-redesign/tasks.md

@@ -0,0 +1,35 @@
+# Tasks
+
+- [x] Task 1: 修改 FusedDesktopComponentLibraryWindow.axaml 窗口布局
+  - [x] SubTask 1.1: 重新设计标题栏，使用标准X关闭按钮，移除圆形样式，使用 DesignCornerRadiusSm
+  - [x] SubTask 1.2: 调整窗口整体布局为左侧面板+右侧预览区
+  - [x] SubTask 1.3: 添加底部"查找更多组件"链接区域
+
+- [x] Task 2: 修改 FusedDesktopComponentLibraryControl.axaml 控件布局
+  - [x] SubTask 2.1: 重新设计左侧面板：仅保留分类列表（移除搜索框）
+  - [x] SubTask 2.2: 重新设计右侧预览区：组件标题 + 大尺寸预览 + 描述 + 添加按钮
+  - [x] SubTask 2.3: 优化分类列表项样式，添加选中状态视觉反馈
+  - [x] SubTask 2.4: 复用阑山桌面组件库的分类图标映射
+
+- [x] Task 3: 更新 ViewModel 支持新交互模式
+  - [x] SubTask 3.1: 在 ComponentLibraryWindowViewModel 中添加 SelectedComponent 属性
+  - [x] SubTask 3.2: 添加组件描述属性支持
+
+- [x] Task 4: 更新 FusedDesktopComponentLibraryControl.axaml.cs 代码逻辑
+  - [x] SubTask 4.1: 修改分类选择逻辑，选中分类时显示该分类第一个组件
+  - [x] SubTask 4.2: 添加组件选中逻辑
+  - [x] SubTask 4.3: 移除搜索相关代码
+  - [x] SubTask 4.4: 复用阑山桌面组件库的分类图标和本地化方法
+  - [x] SubTask 4.5: 添加"查找更多组件"链接点击处理（打开设置窗口插件目录）
+
+- [x] Task 5: 验证和测试
+  - [x] SubTask 5.1: 验证关闭按钮使用动态圆角资源 DesignCornerRadiusSm
+  - [x] SubTask 5.2: 验证窗口布局符合Windows 11小组件面板风格
+  - [x] SubTask 5.3: 验证分类图标与阑山桌面组件库一致
+  - [x] SubTask 5.4: 验证组件添加功能正常工作
+  - [x] SubTask 5.5: 验证"查找更多组件"链接能打开设置窗口
+
+# Task Dependencies
+- Task 3 依赖于 Task 1 和 Task 2 的UI设计确定
+- Task 4 依赖于 Task 3 的ViewModel更新
+- Task 5 依赖于所有前置任务完成

.trae/specs/launcher-upgrade/checklist.md

@@ -0,0 +1,8 @@
+# Launcher Upgrade Checklist
+
+- [x] Build passes for `LanMountainDesktop.Launcher`.
+- [x] `update check` command returns structured JSON result.
+- [x] `plugin update` command returns structured JSON result.
+- [x] Legacy plugin install arguments still execute.
+- [x] OOBE and splash are implemented as separate windows.
+- [x] Update and rollback logic use version directory markers.

.trae/specs/launcher-upgrade/spec.md

@@ -0,0 +1,54 @@
+# Launcher Upgrade Spec
+
+## Goal
+
+Upgrade `LanMountainDesktop.Launcher` into the unified Launcher for:
+
+- OOBE first-run entry
+- startup splash window
+- silent/incremental/rollback update
+- plugin install/update
+
+## Scope (Phase 1)
+
+- Avalonia GUI launcher with two windows:
+  - `OOBEWindow` (first run only)
+  - `SplashWindow` (every launch)
+- Default command `launch`
+- CLI commands:
+  - `update check|download|apply|rollback`
+  - `plugin install|update`
+- Legacy compatibility:
+  - `--source --plugins-dir --result` still works for plugin install
+
+## Update Behavior
+
+- ClassIsland-style deployment folders:
+  - `app-<version>-<number>/`
+  - marker files `.current`, `.partial`, `.destroy`
+- Signed file map:
+  - `files.json`
+  - `files.json.sig`
+  - `public-key.pem`
+- Incremental update:
+  - `replace` from archive
+  - `reuse` from current deployment
+  - `delete` skip file in target deployment
+- Rollback:
+  - snapshot metadata is written before apply
+  - automatic rollback on apply failure
+  - manual rollback via command
+
+## OOBE and Splash
+
+- OOBE is independent from splash.
+- OOBE shows only:
+  - welcome text: `欢迎使用阑山桌面`
+  - arrow button for continue
+- Splash shows only:
+  - app name: `阑山桌面`
+
+## Extensibility
+
+- `IOobeStep` for future multi-step OOBE
+- `ISplashStageReporter` for future startup progress visualization

.trae/specs/launcher-upgrade/tasks.md

@@ -0,0 +1,12 @@
+# Launcher Upgrade Tasks
+
+- [x] Convert `LanMountainDesktop.Launcher` to Avalonia launcher entry.
+- [x] Add OOBE window with first-run marker handling.
+- [x] Add splash window for every startup.
+- [x] Implement unified command parsing with default `launch`.
+- [x] Keep legacy plugin install args compatibility.
+- [x] Add plugin pending upgrade queue processing.
+- [x] Implement incremental update apply with signed file map.
+- [x] Implement snapshot-based rollback and manual rollback command.
+- [x] Add update check/download/apply/rollback CLI commands.
+- [x] Add launcher spec files under `.trae/specs/launcher-upgrade/`.

.trae/specs/window-slide-transition/checklist.md

@@ -0,0 +1,24 @@
+* [x] AppSettingsSnapshot 包含 EnableSlideTransition 字段且默认为 false
+
+* [x] DesktopPage 拥有名为 DesktopPageSlideTransform 的 TranslateTransform
+
+* [x] DesktopPage.Transitions 包含 Opacity 和 TranslateTransform.X 两个 DoubleTransition
+
+* [x] 点击"回到 Windows"时播放退场动画（Opacity 淡出 或 Opacity+滑动），动画完成后再最小化
+
+* [x] 从最小化恢复时 DesktopPage 先以 Opacity=0 遮住 Normal 中间态，FullScreen 生效后播放入场动画
+
+* [x] 动画期间 DesktopPage.IsHitTestVisible 为 false，动画完成后恢复
+
+* [x] 动画期间 OnWindowPropertyChanged 不执行强制全屏纠正
+
+* [x] 快速连续操作不会导致动画冲突
+
+* [x] GeneralSettingsPage 在 Windows 平台显示"滑入滑出过渡效果"开关
+
+* [x] GeneralSettingsPage 在非 Windows 平台不显示该开关
+
+* [x] EnableSlideTransition 设置持久化到 AppSettingsSnapshot 且立即生效
+
+* [x] dotnet build 无编译错误
+

.trae/specs/window-slide-transition/spec.md

@@ -0,0 +1,138 @@
+# 窗口过渡动画 Spec
+
+## Why
+
+当前全屏窗口在"回到 Windows"（最小化）和"恢复应用"时存在严重的视觉问题：
+1. 恢复时经历 `Minimized → Normal → FullScreen` 两步跳变，用户会短暂看到无框小窗口
+2. 状态切换无任何过渡动画，体验生硬
+3. `OnWindowPropertyChanged` 使用 `Dispatcher.UIThread.Post` 延迟纠正，进一步延长了 Normal 中间态的可见时间
+
+## What Changes
+
+- 在 `MainWindow.axaml` 的 `DesktopPage` 上添加 `TranslateTransform` 和 `TranslateTransform.X` 过渡动画
+- 修改 `MainWindow.axaml.cs` 的 `OnMinimizeClick`，实现退场动画（滑出/淡出 → 最小化）
+- 修改 `App.axaml.cs` 的 `RestoreOrCreateMainWindow`，实现入场动画（全屏 → 滑入/淡入）
+- 修改 `MainWindow.axaml.cs` 的 `OnWindowPropertyChanged`，在动画期间暂停强制全屏逻辑
+- 在 `AppSettingsSnapshot` 中添加 `EnableSlideTransition` 设置项（默认关闭）
+- 在 `GeneralSettingsPageViewModel` 中添加对应 ViewModel 属性
+- 在 `GeneralSettingsPage.axaml` 中添加开关 UI（仅 Windows 平台显示）
+- 添加平台检测逻辑：Windows 且开启设置时使用滑入滑出，其他情况使用 Opacity 淡入淡出
+
+## Impact
+
+- Affected specs: 窗口生命周期过渡动画
+- Affected code:
+  - `LanMountainDesktop/Views/MainWindow.axaml` - DesktopPage 添加 TranslateTransform
+  - `LanMountainDesktop/Views/MainWindow.axaml.cs` - OnMinimizeClick、OnWindowPropertyChanged、新增动画方法
+  - `LanMountainDesktop/App.axaml.cs` - RestoreOrCreateMainWindow、OnMainWindowPropertyChanged
+  - `LanMountainDesktop/Models/AppSettingsSnapshot.cs` - 新增 EnableSlideTransition 字段
+  - `LanMountainDesktop/ViewModels/SettingsViewModels.cs` - GeneralSettingsPageViewModel 新增属性
+  - `LanMountainDesktop/Views/SettingsPages/GeneralSettingsPage.axaml` - 新增开关 UI
+
+---
+
+## ADDED Requirements
+
+### Requirement: 窗口退场过渡动画
+
+系统 SHALL 在主窗口最小化/隐藏时播放退场过渡动画，消除窗口状态跳变的视觉闪烁。
+
+#### Scenario: Opacity 淡出退场（所有平台默认）
+- **WHEN** 用户点击"回到 Windows"或触发最小化
+- **THEN** 系统将 `DesktopPage.Opacity` 设为 0，触发淡出动画
+- **AND THEN** 动画完成后执行 `WindowState = Minimized`
+- **AND THEN** 最小化完成后重置 `DesktopPage.Opacity = 1`（窗口已不可见）
+
+#### Scenario: 滑出退场（Windows + 开启设置）
+- **WHEN** 用户点击"回到 Windows"且运行在 Windows 平台且已开启滑入滑出设置
+- **THEN** 系统同时将 `DesktopPage.Opacity` 设为 0 且 `DesktopPageSlideTransform.X` 设为屏幕宽度
+- **AND THEN** 动画完成后执行 `WindowState = Minimized`
+- **AND THEN** 最小化完成后重置 `DesktopPageSlideTransform.X = 0` 和 `DesktopPage.Opacity = 1`
+
+### Requirement: 窗口入场过渡动画
+
+系统 SHALL 在主窗口恢复时播放入场过渡动画，消除 Normal 中间态的视觉闪烁。
+
+#### Scenario: Opacity 淡入入场（所有平台默认）
+- **WHEN** 主窗口从最小化/隐藏状态恢复
+- **THEN** 系统先将 `DesktopPage.Opacity` 设为 0（遮住 Normal 中间态）
+- **AND THEN** 完成 `Minimized → Normal → FullScreen` 状态切换
+- **AND THEN** 等 FullScreen 状态生效后将 `DesktopPage.Opacity` 设为 1，触发淡入动画
+
+#### Scenario: 滑入入场（Windows + 开启设置）
+- **WHEN** 主窗口从最小化/隐藏状态恢复且运行在 Windows 平台且已开启滑入滑出设置
+- **THEN** 系统先将 `DesktopPage.Opacity` 设为 0 且 `DesktopPageSlideTransform.X` 设为屏幕宽度
+- **AND THEN** 完成 `Minimized → Normal → FullScreen` 状态切换
+- **AND THEN** 等 FullScreen 状态生效后同时将 `DesktopPage.Opacity` 设为 1 且 `DesktopPageSlideTransform.X` 设为 0，触发滑入+淡入组合动画
+
+### Requirement: 动画期间交互保护
+
+系统 SHALL 在过渡动画播放期间防止用户交互和状态冲突。
+
+#### Scenario: 动画期间禁止交互
+- **WHEN** 退场或入场动画正在播放
+- **THEN** `DesktopPage.IsHitTestVisible` 设为 `false`
+- **AND THEN** 动画完成后恢复为 `true`
+
+#### Scenario: 动画期间暂停强制全屏
+- **WHEN** 入场动画正在播放且窗口临时处于 Normal 状态
+- **THEN** `OnWindowPropertyChanged` 不执行强制全屏纠正
+- **AND THEN** 入场动画完成后恢复正常强制全屏逻辑
+
+#### Scenario: 防止快速连续操作
+- **WHEN** 用户在动画播放期间再次触发最小化或恢复
+- **THEN** 系统忽略重复操作，避免动画冲突
+
+### Requirement: 滑入滑出设置项
+
+系统 SHALL 在基本设置页面提供"滑入滑出过渡效果"开关，仅 Windows 平台可见。
+
+#### Scenario: 设置项可见性
+- **WHEN** 用户在 Windows 平台打开基本设置页面
+- **THEN** 显示"滑入滑出过渡效果"开关
+- **WHEN** 用户在非 Windows 平台打开基本设置页面
+- **THEN** 不显示该开关
+
+#### Scenario: 设置项默认值
+- **WHEN** 用户首次安装应用
+- **THEN** `EnableSlideTransition` 默认为 `false`
+
+#### Scenario: 设置持久化
+- **WHEN** 用户切换"滑入滑出过渡效果"开关
+- **THEN** 设置值立即持久化到 `AppSettingsSnapshot.EnableSlideTransition`
+- **AND THEN** 下次窗口过渡时立即生效，无需重启
+
+### Requirement: DesktopPage TranslateTransform 声明
+
+系统 SHALL 在 `DesktopPage` 上声明 `TranslateTransform` 和对应的过渡动画。
+
+#### Scenario: XAML 声明
+- **WHEN** MainWindow 初始化
+- **THEN** `DesktopPage` 拥有名为 `DesktopPageSlideTransform` 的 `TranslateTransform`
+- **AND THEN** `DesktopPage.Transitions` 包含 `Opacity` 和 `TranslateTransform.X` 两个过渡
+- **AND THEN** 过渡时长使用 `FluttermotionToken.Duration.Page`（320ms）和 `FluttermotionToken.Duration.Intro`（400ms）
+- **AND THEN** 缓动函数使用 `0.05,0.75,0.10,1.00`（DecelerateBezier）
+
+## MODIFIED Requirements
+
+### Requirement: OnMinimizeClick 行为
+
+**当前**: 直接设置 `WindowState = WindowState.Minimized`，无动画
+
+**修改后**: 先播放退场动画，动画完成后再设置 `WindowState = WindowState.Minimized`
+
+### Requirement: RestoreOrCreateMainWindow 行为
+
+**当前**: `Show() → Normal → FullScreen`，无过渡动画，用户可见 Normal 中间态
+
+**修改后**: 先将 `DesktopPage` 设为不可见（Opacity=0 + 可选滑出位），再执行状态切换，最后播放入场动画
+
+### Requirement: OnWindowPropertyChanged 强制全屏逻辑
+
+**当前**: 任何非 Minimized/FullScreen 状态立即纠正为 FullScreen
+
+**修改后**: 动画期间允许临时 Normal 状态存在，动画完成后恢复强制全屏逻辑
+
+## REMOVED Requirements
+
+无移除的需求。

.trae/specs/window-slide-transition/tasks.md

@@ -0,0 +1,52 @@
+# Tasks
+
+- [x] Task 1: 在 `AppSettingsSnapshot` 中添加 `EnableSlideTransition` 字段
+  - [x] 添加 `public bool EnableSlideTransition { get; set; } = false;`
+  - [x] 在 `Clone()` 方法中无需特殊处理（bool 是值类型）
+
+- [x] Task 2: 在 `MainWindow.axaml` 的 `DesktopPage` 上添加 `TranslateTransform` 和过渡动画
+  - [x] 添加 `<TranslateTransform />`
+  - [x] 在 `Grid.Transitions` 中添加 `TranslateTransform.X` 的 `DoubleTransition`，使用 `FluttermotionToken.Duration.Intro` 和 DecelerateBezier 缓动
+
+- [x] Task 3: 在 `MainWindow.axaml.cs` 中实现退场动画逻辑
+  - [x] 添加 `_isSlideAnimationActive` 标志位
+  - [x] 修改 `OnMinimizeClick`，调用新的 `SlideOutAndMinimizeAsync` 方法
+  - [x] 实现 `SlideOutAndMinimizeAsync`：读取设置 → 播放退场动画（Opacity + 可选滑动）→ 等动画完成 → 最小化 → 重置位置
+  - [x] 动画期间设置 `DesktopPage.IsHitTestVisible = false`
+
+- [x] Task 4: 在 `MainWindow.axaml.cs` 中实现入场动画逻辑
+  - [x] 添加 `public void PrepareEnterAnimation()` 方法：禁用过渡 → 设置初始位置（Opacity=0, X=屏幕宽度或0）→ 重新启用过渡
+  - [x] 添加 `public void PlayEnterAnimation()` 方法：触发入场动画（Opacity=1, X=0）
+  - [x] 添加 `private bool IsSlideTransitionEnabled()` 方法，从设置中读取
+
+- [x] Task 5: 修改 `App.axaml.cs` 的 `RestoreOrCreateMainWindow`
+  - [x] 在窗口状态切换前调用 `mainWindow.PrepareEnterAnimation()`
+  - [x] 在 FullScreen 状态生效后调用 `mainWindow.PlayEnterAnimation()`
+
+- [x] Task 6: 修改 `MainWindow.axaml.cs` 的 `OnWindowPropertyChanged`
+  - [x] 当 `_isSlideAnimationActive` 为 true 时跳过强制全屏逻辑
+
+- [x] Task 7: 在 `GeneralSettingsPageViewModel` 中添加 `EnableSlideTransition` 属性
+  - [x] 添加 `[ObservableProperty] private bool _enableSlideTransition;`
+  - [x] 添加 `OnEnableSlideTransitionChanged` 持久化方法
+  - [x] 在构造函数和 `OnSettingsChanged` 中加载/同步该设置
+  - [x] 添加 `IsSlideTransitionAvailable` 平台检测属性
+
+- [x] Task 8: 在 `GeneralSettingsPage.axaml` 中添加"滑入滑出过渡效果"开关
+  - [x] 在"运行时设置"分组中添加 `SettingsExpander`
+  - [x] 仅 Windows 平台显示（使用 `IsVisible` 绑定到 `IsSlideTransitionAvailable`）
+  - [x] 图标使用 `ArrowRight`
+
+- [x] Task 9: 构建验证
+  - [x] 执行 `dotnet build` 确保无编译错误
+
+# Task Dependencies
+
+- [Task 2] depends on [Task 1]
+- [Task 3] depends on [Task 1, Task 2]
+- [Task 4] depends on [Task 1, Task 2]
+- [Task 5] depends on [Task 4]
+- [Task 6] depends on [Task 3]
+- [Task 7] depends on [Task 1]
+- [Task 8] depends on [Task 7]
+- [Task 9] depends on [Task 3, Task 4, Task 5, Task 6, Task 7, Task 8]

CHANGELOG.md

@@ -1,40 +1,139 @@
 # 更新日志 / Changelog
 
-所有重要的更改都将记录在此文件中。
-
-格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/),
-并且本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
-
----
-
-## [Unreleased]
+## [0.8.4](https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.4) - 2026-04-12
 
 ### 新增 (Added)
-- 待发布的新功能
+
+- ✨ **全新淡入淡出动画系统**: 引入了一套全新的淡入淡出动画效果
+  - 提升界面切换和元素显示的视觉流畅度
+  - 为用户带来更加自然优雅的交互体验
 
 ### 变更 (Changed)
-- 待发布的变更
+
+- ♻️ **SDK 更新**: 更新插件 SDK，优化插件开发接口和兼容性
+- 🎨 **网速显示组件优化**: 优化了网速显示组件的显示效果
+  - 改进数据展示方式，提升可读性
+  - 优化视觉样式，与整体设计语言更加协调
 
 ### 修复 (Fixed)
-- 待发布的修复
+
+- 无
 
 ### 移除 (Removed)
-- 待发布的移除项
 
----
+- 无
 
-## [0.8.3.2] - 2026-04-09
+***
+
+## [0.8.3.5](https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.5) - 2026-04-12
 
 ### 新增 (Added)
+
+- 无
+
+### 变更 (Changed)
+
+- ✨ **插件设置页面支持 View 展示**: 插件设置页面现在支持使用 View 进行展示
+  - 插件开发者可以通过 View 自定义设置页面的 UI 和交互
+  - 提供更灵活的设置页面展示方式，提升插件用户体验
+  - 兼容原有的设置方式，平滑过渡
+- 🔧 **三指滑动与融合桌面功能开关位置调整**: 将三指滑动与融合桌面功能开关移动到了开发者设置界面
+  - 优化设置页面结构，将高级功能集中管理
+  - 普通用户界面更加简洁，开发者可在已有的开发者设置界面中访问相关设置
+
+### 修复 (Fixed)
+
+- 🐛 **快捷方式组件透明问题**: 修复了快捷方式组件无法正常透明的问题
+  - 问题原因: 组件背景透明属性设置异常或渲染层级问题
+  - 修复方案: 修正透明属性配置，确保快捷方式组件背景透明效果正常显示
+- 🐛 **插件无法正常升级问题**: 修复了插件无法正常升级的问题
+  - 问题原因: 插件升级流程中存在异常，导致升级操作失败或中断
+  - 修复方案: 修复插件升级逻辑，确保插件可以正常检测、下载和安装更新
+- 🐛 **开发者设置项持久化问题**: 修复了开发者设置项不能正确持久化的问题
+  - 问题原因: 开发者设置项的保存或读取逻辑存在缺陷，导致设置无法正确保存或恢复
+  - 修复方案: 修复设置持久化逻辑，确保开发者设置项能够正确保存并在重启后恢复
+
+### 移除 (Removed)
+
+- 🗑️ **不附带 .NET 10 依赖的轻量版安装包**: 移除了不附带 .NET 10 依赖的轻量版安装包
+  - 简化版本发布和维护流程，统一提供完整依赖的安装包
+  - 用户无需担心 .NET 运行时环境，安装后即可直接使用
+
+***
+
+## [0.8.3.4](https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.4) - 2026-04-12
+
+### 新增 (Added)
+
+- 无
+
+### 变更 (Changed)
+
+- ♻️ **插件 SDK 更新**: 更新插件 SDK，优化插件开发接口和兼容性
+
+### 修复 (Fixed)
+
+- 🐛 **轻量版 .NET 依赖问题（实验性）**: 实验性修复了轻量版在 .NET 环境下的依赖问题
+  - 问题原因: 轻量版与 .NET 的依赖兼容性存在冲突
+  - 修复方案: 调整依赖配置，提升兼容性（实验性修复，持续观察中）
+
+### 移除 (Removed)
+
+- 无
+
+***
+
+## [0.8.3.3](https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.3) - 2026-04-12
+
+### 新增 (Added)
+
+- ✨ **便签组件**: 全新便签组件上线，支持 Markdown 语法
+  - 支持丰富的 Markdown 格式：标题、列表、加粗、斜体、代码块等
+  - 便签内容自动保存，方便记录和管理日常备忘。丰富信息展示途径，让作业布置也可在阑山桌面完成。
+- ✨ **白板主题自适应笔色**: 白板功能新增主题自适应笔色支持
+  - 根据当前主题自动调整画笔颜色，确保在不同主题下都有良好的书写体验
+  - 深色主题下自动切换为浅色笔迹，浅色主题下使用深色笔迹
+
+### 变更 (Changed)
+
+- 🎨 **融合桌面设置组件库样式更新**: 优化融合桌面设置页面的组件库样式
+  - 提升视觉一致性和用户体验
+  - 统一组件风格，与整体设计语言保持协调
+
+### 修复 (Fixed)
+
+- 🐛 **白板无法使用问题**: 修复了白板功能无法正常使用的问题
+  - 问题原因: 相关依赖或初始化逻辑异常导致白板功能失效
+  - 修复方案: 修复了白板的依赖加载和初始化流程，恢复正常使用
+- 🐛 **央官网新闻组件显示问题**: 修复了央官网新闻组件的显示异常
+  - 优化组件渲染逻辑，确保新闻内容正确展示
+- 🐛 **课程表组件显示问题**: 修复了课程表组件的显示异常
+  - 优化组件布局和渲染，确保课程信息正确显示
+- 🐛 **轻量版 .NET 10 依赖问题（实验性）**: 实验性修复了轻量版在 .NET 10 环境下的依赖问题
+  - 问题原因: 轻量版与 .NET 10 的依赖兼容性存在冲突
+  - 修复方案: 调整依赖配置，提升与 .NET 10 的兼容性（实验性修复，持续观察中）
+
+### 移除 (Removed)
+
+- 无
+
+***
+
+## [0.8.3.2](https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.2) - 2026-04-09
+
+### 新增 (Added)
+
 - ✨ **应用启动台图标卡片显示选项**: 新增应用启动台图标卡片显示设置
   - 用户可在设置中选择是否显示应用图标的专属卡片背景
   - 关闭后仅显示应用图标本身，更加简洁
   - 支持动态切换，实时预览效果
 
 ### 变更 (Changed)
+
 - 无
 
 ### 修复 (Fixed)
+
 - 🐛 **应用启动台文件夹应用数量限制**: 修复了应用启动台文件夹无法查看超过12个应用的问题
   - 问题原因: 文件夹弹窗未实现滚动功能，应用列表超出显示区域后被截断
   - 修复方案: 为文件夹内容区域添加滚动支持，允许用户滚动查看所有应用
@@ -46,13 +145,15 @@
   - 修复方案: 在 `IncrementalUpdateItems()` 方法中同步更新课程项的文字颜色
 
 ### 移除 (Removed)
+
 - 🗑️ **更新页面重复标题**: 移除了更新页面中重复的更新标题，优化页面布局
 
----
+***
 
-## [0.8.3.1] - 2026-04-08
+## [0.8.3.1](https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.1) - 2026-04-08
 
 ### 新增 (Added)
+
 - ✨ **快捷方式组件**: 新增快捷方式组件,可在阑山桌面内便捷打开系统应用与文件
   - 支持创建快捷方式,统一管理应用和文件
   - 提供单击打开和双击打开两种交互模式
@@ -60,15 +161,45 @@
 - 📝 初始化更新日志文档,为后续版本发布建立基础
 
 ### 变更 (Changed)
+
 - 无
 
 ### 修复 (Fixed)
+
 - 无
 
 ### 移除 (Removed)
+
 - 无
 
----
+***
+
+所有重要的更改都将记录在此文件中。
+
+格式基于 [Keep a Changelog](https://keepachangelog.com/zh-CN/1.0.0/),
+并且本项目遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
+
+***
+
+## \[格式示例]
+
+### 新增 (Added)
+
+- 待发布的新功能
+
+### 变更 (Changed)
+
+- 待发布的变更
+
+### 修复 (Fixed)
+
+- 待发布的修复
+
+### 移除 (Removed)
+
+- 待发布的移除项
+
+***
 
 ## 版本说明
 
@@ -101,10 +232,6 @@
 - 🔒 **安全**: 安全相关
 - 🌐 **国际化**: 国际化/本地化
 
----
+***
 
 ## 链接
-
-[Unreleased]: https://github.com/yourorg/LanMountainDesktop/compare/v0.8.3.2...HEAD
-[0.8.3.2]: https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.2
-[0.8.3.1]: https://github.com/yourorg/LanMountainDesktop/releases/tag/v0.8.3.1

Directory.Build.props

@@ -4,5 +4,6 @@
     <TargetFramework Condition="'$(TargetFramework)' == ''">net10.0</TargetFramework>
     <Nullable Condition="'$(Nullable)' == ''">enable</Nullable>
     <ImplicitUsings Condition="'$(ImplicitUsings)' == ''">enable</ImplicitUsings>
+    <ServerGarbageCollection>true</ServerGarbageCollection>
   </PropertyGroup>
 </Project>

LanMountainDesktop.Launcher/App.axaml

@@ -0,0 +1,8 @@
+<Application xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="LanMountainDesktop.Launcher.App"
+             RequestedThemeVariant="Default">
+  <Application.Styles>
+    <FluentTheme />
+  </Application.Styles>
+</Application>

LanMountainDesktop.Launcher/App.axaml.cs

@@ -0,0 +1,50 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
+using LanMountainDesktop.Launcher.Services;
+
+namespace LanMountainDesktop.Launcher;
+
+public partial class App : Application
+{
+    public override void Initialize()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+
+    public override void OnFrameworkInitializationCompleted()
+    {
+        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+        {
+            var context = LauncherRuntimeContext.Current;
+            var appRoot = Commands.ResolveAppRoot(context);
+            var deploymentLocator = new DeploymentLocator(appRoot);
+            
+            // TODO: 从配置读取 GitHub 仓库信息
+            var updateCheckService = new UpdateCheckService("ClassIsland", "LanMountainDesktop");
+            
+            var coordinator = new LauncherFlowCoordinator(
+                context,
+                deploymentLocator,
+                new OobeStateService(appRoot),
+                new UpdateEngineService(deploymentLocator),
+                updateCheckService,
+                new PluginInstallerService());
+
+            _ = RunCoordinatorAsync(desktop, coordinator);
+        }
+
+        base.OnFrameworkInitializationCompleted();
+    }
+
+    private static async Task RunCoordinatorAsync(
+        IClassicDesktopStyleApplicationLifetime desktop,
+        LauncherFlowCoordinator coordinator)
+    {
+        var result = await coordinator.RunAsync().ConfigureAwait(false);
+        await Commands.WriteResultIfNeededAsync(LauncherRuntimeContext.Current.GetOption("result"), result).ConfigureAwait(false);
+        Environment.ExitCode = result.Success ? 0 : 1;
+        await Dispatcher.UIThread.InvokeAsync(() => desktop.Shutdown(Environment.ExitCode), DispatcherPriority.Background);
+    }
+}

LanMountainDesktop.Launcher/Assets/public-key.pem

@@ -0,0 +1,8 @@
+-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAxPqgXsrnG8Re0kV4HBb+x61HQpjCahJoilzKvvlnXanuGtGxbjZT
+B+kMzmPUwyx8gt1fcaBNoKPwpwP0UZRWjvJDZQ++5ex7LGGw0YRWtJmeeigS17YI
+90vEfX3xQ5InJoBKnndsRy2a742chE6YwHGrJ4b107ZJ+zd26FmokQS47Uzay3go
+msbQHdehwCdCiW1mh8YFDm0xny+PYoYZkGXiDOYY0nvg4yJ/BG2fQkkC5TNizr0l
+YcE3RrMRcyJB7zU3jN1QnjHIvIvwfCOXaLdcXtxgQFRv45sYpmj9amNjuurM5iUa
+20Mk1ilYBuLxqe6P9C8DakZY/akVxpzxrQIDAQAB
+-----END RSA PUBLIC KEY-----

LanMountainDesktop.Launcher/CommandContext.cs

@@ -0,0 +1,79 @@
+using System.Globalization;
+
+namespace LanMountainDesktop.Launcher;
+
+internal sealed class CommandContext
+{
+    public string Command { get; }
+
+    public string SubCommand { get; }
+
+    public IReadOnlyDictionary<string, string> Options { get; }
+
+    public bool IsLegacyPluginInstall =>
+        Options.ContainsKey("source") &&
+        Options.ContainsKey("plugins-dir") &&
+        Options.ContainsKey("result");
+
+    private CommandContext(string command, string subCommand, Dictionary<string, string> options)
+    {
+        Command = command;
+        SubCommand = subCommand;
+        Options = options;
+    }
+
+    public static CommandContext FromArgs(string[] args)
+    {
+        var options = ParseOptions(args);
+        var command = args.Length > 0 && !args[0].StartsWith("--", StringComparison.Ordinal)
+            ? args[0]
+            : "launch";
+        var subCommand = args.Length > 1 && !args[1].StartsWith("--", StringComparison.Ordinal)
+            ? args[1]
+            : string.Empty;
+
+        return new CommandContext(command, subCommand, options);
+    }
+
+    public string? GetOption(string key)
+    {
+        return Options.TryGetValue(key, out var value) ? value : null;
+    }
+
+    public int GetIntOption(string key, int fallback)
+    {
+        var raw = GetOption(key);
+        return int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out var value)
+            ? value
+            : fallback;
+    }
+
+    private static Dictionary<string, string> ParseOptions(string[] args)
+    {
+        var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        for (var i = 0; i < args.Length; i++)
+        {
+            var current = args[i];
+            if (!current.StartsWith("--", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            var key = current[2..];
+            if (string.IsNullOrWhiteSpace(key))
+            {
+                continue;
+            }
+
+            if (i + 1 < args.Length && !args[i + 1].StartsWith("--", StringComparison.Ordinal))
+            {
+                values[key] = args[++i];
+                continue;
+            }
+
+            values[key] = "true";
+        }
+
+        return values;
+    }
+}

LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj

@@ -0,0 +1,48 @@
+<Project Sdk="Microsoft.NET.Sdk" TreatAsLocalProperty="Version;PackageVersion;InformationalVersion;AssemblyVersion;FileVersion">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Version>1.0.0</Version>
+    <PackageVersion>$(Version)</PackageVersion>
+    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LanMountainDesktop.PluginSdk\LanMountainDesktop.PluginSdk.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia" Version="11.3.12" />
+    <PackageReference Include="Avalonia.Desktop" Version="11.3.12" />
+    <PackageReference Include="Avalonia.Themes.Fluent" Version="11.3.12" />
+    <PackageReference Include="Avalonia.Fonts.Inter" Version="11.3.12" />
+    <PackageReference Include="Microsoft.Windows.CsWin32" Version="0.3.106" PrivateAssets="all" />
+    <PackageReference Include="Tmds.DBus.Protocol" Version="0.92.0" />
+  </ItemGroup>
+
+  <!-- Embed public-key.pem and copy to .launcher/update/ in output directory -->
+  <ItemGroup>
+    <None Include="Assets\public-key.pem" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <Target Name="CopyPublicKeyToLauncherDir" AfterTargets="Build">
+    <PropertyGroup>
+      <PublicKeySource>$(MSBuildProjectDirectory)\Assets\public-key.pem</PublicKeySource>
+      <PublicKeyDestDir>$(OutDir).launcher\update</PublicKeyDestDir>
+    </PropertyGroup>
+    <MakeDir Directories="$(PublicKeyDestDir)" />
+    <Copy SourceFiles="$(PublicKeySource)" DestinationFolder="$(PublicKeyDestDir)" SkipUnchangedFiles="true" />
+  </Target>
+
+  <Target Name="CopyPublicKeyToPublishDir" AfterTargets="Publish">
+    <PropertyGroup>
+      <PublishedKeySource>$(MSBuildProjectDirectory)\Assets\public-key.pem</PublishedKeySource>
+      <PublishedKeyDestDir>$(PublishDir).launcher\update</PublishedKeyDestDir>
+    </PropertyGroup>
+    <MakeDir Directories="$(PublishedKeyDestDir)" />
+    <Copy SourceFiles="$(PublishedKeySource)" DestinationFolder="$(PublishedKeyDestDir)" SkipUnchangedFiles="true" />
+  </Target>
+
+</Project>

LanMountainDesktop.Launcher/LauncherRuntimeContext.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.Launcher;
+
+internal static class LauncherRuntimeContext
+{
+    public static CommandContext Current { get; set; } = CommandContext.FromArgs([]);
+}

LanMountainDesktop.Launcher/Models/LauncherResult.cs

@@ -0,0 +1,42 @@
+using System.Text.Json.Serialization;
+
+namespace LanMountainDesktop.Launcher.Models;
+
+internal sealed class LauncherResult
+{
+    [JsonPropertyName("success")]
+    public bool Success { get; init; }
+
+    [JsonPropertyName("stage")]
+    public string Stage { get; init; } = string.Empty;
+
+    [JsonPropertyName("code")]
+    public string Code { get; init; } = "ok";
+
+    [JsonPropertyName("message")]
+    public string Message { get; init; } = string.Empty;
+
+    [JsonPropertyName("currentVersion")]
+    public string? CurrentVersion { get; init; }
+
+    [JsonPropertyName("targetVersion")]
+    public string? TargetVersion { get; init; }
+
+    [JsonPropertyName("rolledBackTo")]
+    public string? RolledBackTo { get; init; }
+
+    [JsonPropertyName("details")]
+    public Dictionary<string, string> Details { get; init; } = [];
+
+    [JsonPropertyName("installedPackagePath")]
+    public string? InstalledPackagePath { get; init; }
+
+    [JsonPropertyName("manifestId")]
+    public string? ManifestId { get; init; }
+
+    [JsonPropertyName("manifestName")]
+    public string? ManifestName { get; init; }
+
+    [JsonPropertyName("errorMessage")]
+    public string? ErrorMessage { get; init; }
+}

LanMountainDesktop.Launcher/Models/ReleaseInfo.cs

@@ -0,0 +1,24 @@
+namespace LanMountainDesktop.Launcher.Models;
+
+/// <summary>
+/// GitHub Release 信息
+/// </summary>
+public sealed class ReleaseInfo
+{
+    public required string TagName { get; init; }
+    public required string Name { get; init; }
+    public required bool Prerelease { get; init; }
+    public required DateTime PublishedAt { get; init; }
+    public required List<ReleaseAsset> Assets { get; init; }
+    public string? Body { get; init; }
+}
+
+/// <summary>
+/// Release 资源文件
+/// </summary>
+public sealed class ReleaseAsset
+{
+    public required string Name { get; init; }
+    public required string BrowserDownloadUrl { get; init; }
+    public required long Size { get; init; }
+}

LanMountainDesktop.Launcher/Models/UpdateChannel.cs

@@ -0,0 +1,17 @@
+namespace LanMountainDesktop.Launcher.Models;
+
+/// <summary>
+/// 更新频道
+/// </summary>
+public enum UpdateChannel
+{
+    /// <summary>
+    /// 正式版 - 只检查 prerelease=false 的版本
+    /// </summary>
+    Stable,
+
+    /// <summary>
+    /// 预览版 - 检查所有版本(包括 prerelease=true)
+    /// </summary>
+    Preview
+}

LanMountainDesktop.Launcher/Models/UpdateCheckResult.cs

@@ -0,0 +1,13 @@
+namespace LanMountainDesktop.Launcher.Models;
+
+/// <summary>
+/// 更新检查结果
+/// </summary>
+public sealed class UpdateCheckResult
+{
+    public bool HasUpdate { get; init; }
+    public string? LatestVersion { get; init; }
+    public string? CurrentVersion { get; init; }
+    public ReleaseInfo? Release { get; init; }
+    public string? ErrorMessage { get; init; }
+}

LanMountainDesktop.Launcher/Models/UpdateModels.cs

@@ -0,0 +1,55 @@
+namespace LanMountainDesktop.Launcher.Models;
+
+internal sealed class SignedFileMap
+{
+    public string? FromVersion { get; set; }
+
+    public string? ToVersion { get; set; }
+
+    public string? Platform { get; set; }
+
+    public string? Arch { get; set; }
+
+    public List<UpdateFileEntry> Files { get; set; } = [];
+}
+
+internal sealed class UpdateFileEntry
+{
+    public string Path { get; set; } = string.Empty;
+
+    public string? ArchivePath { get; set; }
+
+    public string Action { get; set; } = "replace";
+
+    public string? Sha256 { get; set; }
+}
+
+internal sealed class SnapshotMetadata
+{
+    public string SnapshotId { get; set; } = string.Empty;
+
+    public string SourceVersion { get; set; } = string.Empty;
+
+    public string? TargetVersion { get; set; }
+
+    public DateTimeOffset CreatedAt { get; set; }
+
+    public string SourceDirectory { get; set; } = string.Empty;
+
+    public string? TargetDirectory { get; set; }
+
+    public string Status { get; set; } = "pending";
+}
+
+internal sealed class UpdateApplyResult
+{
+    public bool Success { get; init; }
+
+    public string Message { get; init; } = string.Empty;
+
+    public string? FromVersion { get; init; }
+
+    public string? ToVersion { get; init; }
+
+    public string? RolledBackTo { get; init; }
+}

LanMountainDesktop.Launcher/NativeMethods.txt

@@ -0,0 +1 @@
+MessageBox

LanMountainDesktop.Launcher/Program.cs

@@ -0,0 +1,191 @@
+using System.Diagnostics;
+using Avalonia;
+using LanMountainDesktop.Launcher.Models;
+using LanMountainDesktop.Launcher.Services;
+
+#if WINDOWS
+using Windows.Win32;
+using Windows.Win32.Foundation;
+using Windows.Win32.UI.WindowsAndMessaging;
+#endif
+
+namespace LanMountainDesktop.Launcher;
+
+internal static class Program
+{
+    [STAThread]
+    private static async Task<int> Main(string[] args)
+    {
+        var commandContext = CommandContext.FromArgs(args);
+
+        // 处理遗留插件安装命令
+        if (commandContext.IsLegacyPluginInstall)
+        {
+            var installer = new PluginInstallerService();
+            return await Commands.RunLegacyPluginInstallAsync(commandContext, installer).ConfigureAwait(false);
+        }
+
+        // 处理其他 CLI 命令 (update, plugin, rollback 等)
+        if (!string.Equals(commandContext.Command, "launch", StringComparison.OrdinalIgnoreCase))
+        {
+            return await Commands.RunCliCommandAsync(commandContext).ConfigureAwait(false);
+        }
+
+        // 主启动流程: OOBE -> Splash -> 版本选择 -> 启动主程序
+        LauncherRuntimeContext.Current = commandContext;
+        BuildAvaloniaApp().StartWithClassicDesktopLifetime(args);
+        return Environment.ExitCode;
+    }
+
+    private static int LaunchMainApplication(string[] args)
+    {
+        // 获取可执行文件名
+        string executableName = OperatingSystem.IsWindows() 
+            ? "LanMountainDesktop.exe" 
+            : "LanMountainDesktop";
+
+        // 获取安装根目录
+        var rootDir = Path.GetFullPath(Path.GetDirectoryName(Environment.ProcessPath) ?? "");
+
+        // 查找最佳版本
+        var installation = FindBestVersion(rootDir, executableName);
+
+        if (installation == null)
+        {
+            ShowError("找不到有效的 LanMountainDesktop 版本，可能是安装已损坏。\n请访问 https://github.com/ClassIsland/LanMountainDesktop 重新下载并安装。");
+            return 1;
+        }
+
+        var exePath = Path.Combine(installation, executableName);
+
+        // Linux/macOS: 自动添加可执行权限
+        if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
+        {
+            try
+            {
+                var chmod = Process.Start(new ProcessStartInfo
+                {
+                    FileName = "chmod",
+                    Arguments = $"+x \"{exePath}\"",
+                    CreateNoWindow = true
+                });
+                chmod?.WaitForExit();
+            }
+            catch (Exception ex)
+            {
+                Console.Error.WriteLine($"无法设置可执行权限: {ex.Message}");
+            }
+        }
+
+        // 清理待删除的旧版本
+        CleanupDestroyedVersions(rootDir);
+
+        // 启动主程序
+        var startInfo = new ProcessStartInfo
+        {
+            FileName = exePath,
+            WorkingDirectory = rootDir,
+            UseShellExecute = false
+        };
+
+        foreach (var arg in args)
+        {
+            startInfo.ArgumentList.Add(arg);
+        }
+
+        // 传递包根目录环境变量
+        startInfo.EnvironmentVariables["LanMountainDesktop_PackageRoot"] = rootDir;
+
+        try
+        {
+            Process.Start(startInfo);
+            return 0;
+        }
+        catch (Exception ex)
+        {
+            ShowError($"启动主程序失败: {ex.Message}");
+            return 1;
+        }
+    }
+
+    private static string? FindBestVersion(string rootDir, string executableName)
+    {
+        return Directory.GetDirectories(rootDir)
+            .Where(x =>
+            {
+                var dirName = Path.GetFileName(x);
+                return dirName.StartsWith("app-") &&
+                       !File.Exists(Path.Combine(x, ".destroy")) &&
+                       !File.Exists(Path.Combine(x, ".partial")) &&
+                       File.Exists(Path.Combine(x, executableName));
+            })
+            .OrderBy(x => File.Exists(Path.Combine(x, ".current")) ? 0 : 1)  // .current 优先
+            .ThenByDescending(x => ParseVersion(Path.GetFileName(x)))         // 版本号降序
+            .FirstOrDefault();
+    }
+
+    private static Version ParseVersion(string dirName)
+    {
+        // 从 "app-1.0.0" 格式解析版本号
+        var parts = dirName.Split('-');
+        if (parts.Length >= 2 && Version.TryParse(parts[1], out var version))
+        {
+            return version;
+        }
+        return new Version(0, 0, 0);
+    }
+
+    private static void CleanupDestroyedVersions(string rootDir)
+    {
+        try
+        {
+            var destroyedDirs = Directory.GetDirectories(rootDir)
+                .Where(x => File.Exists(Path.Combine(x, ".destroy")));
+
+            foreach (var dir in destroyedDirs)
+            {
+                try
+                {
+                    Directory.Delete(dir, recursive: true);
+                }
+                catch
+                {
+                    // 忽略删除失败(可能文件被占用),下次启动再试
+                }
+            }
+        }
+        catch
+        {
+            // 忽略清理失败
+        }
+    }
+
+    private static void ShowError(string message)
+    {
+#if WINDOWS
+        try
+        {
+            PInvoke.MessageBox(
+                HWND.Null,
+                message,
+                "LanMountainDesktop Launcher",
+                MESSAGEBOX_STYLE.MB_ICONERROR | MESSAGEBOX_STYLE.MB_OK
+            );
+        }
+        catch
+        {
+            Console.Error.WriteLine(message);
+        }
+#else
+        Console.Error.WriteLine(message);
+#endif
+    }
+
+    private static AppBuilder BuildAvaloniaApp()
+    {
+        return AppBuilder.Configure<App>()
+            .UsePlatformDetect()
+            .WithInterFont()
+            .LogToTrace();
+    }
+}

LanMountainDesktop.Launcher/Properties/launchSettings.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "Launcher (Launch Mode)": {
+      "commandName": "Project",
+      "commandLineArgs": "launch",
+      "workingDirectory": "$(SolutionDir)",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    },
+    "Launcher (Update Check)": {
+      "commandName": "Project",
+      "commandLineArgs": "update check",
+      "workingDirectory": "$(SolutionDir)",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    },
+    "Launcher (Plugin Install)": {
+      "commandName": "Project",
+      "commandLineArgs": "plugin install <path-to-plugin.laapp>",
+      "workingDirectory": "$(SolutionDir)",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

LanMountainDesktop.Launcher/Services/Commands.cs

@@ -0,0 +1,174 @@
+using System.Text;
+using System.Text.Json;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal static class Commands
+{
+    public static async Task<int> RunLegacyPluginInstallAsync(CommandContext context, PluginInstallerService installer)
+    {
+        var resultPath = context.GetOption("result");
+        LauncherResult result;
+        try
+        {
+            var source = context.GetOption("source") ?? string.Empty;
+            var pluginsDir = context.GetOption("plugins-dir") ?? string.Empty;
+            result = installer.InstallPackage(source, pluginsDir);
+        }
+        catch (Exception ex)
+        {
+            result = new LauncherResult
+            {
+                Success = false,
+                Stage = "plugin.install",
+                Code = "failed",
+                Message = ex.Message,
+                ErrorMessage = ex.Message
+            };
+        }
+
+        await WriteResultIfNeededAsync(resultPath, result).ConfigureAwait(false);
+        return result.Success ? 0 : 1;
+    }
+
+    public static async Task<int> RunCliCommandAsync(CommandContext context)
+    {
+        var appRoot = ResolveAppRoot(context);
+        var deploymentLocator = new DeploymentLocator(appRoot);
+        var updateEngine = new UpdateEngineService(deploymentLocator);
+        var pluginInstaller = new PluginInstallerService();
+        var pluginUpgrades = new PluginUpgradeQueueService(pluginInstaller);
+
+        LauncherResult result;
+        try
+        {
+            result = await ExecuteCoreAsync(context, updateEngine, pluginInstaller, pluginUpgrades).ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            result = new LauncherResult
+            {
+                Success = false,
+                Stage = "command",
+                Code = "exception",
+                Message = ex.Message,
+                ErrorMessage = ex.Message
+            };
+        }
+
+        await WriteResultIfNeededAsync(context.GetOption("result"), result).ConfigureAwait(false);
+        return result.Success ? 0 : 1;
+    }
+
+    private static async Task<LauncherResult> ExecuteCoreAsync(
+        CommandContext context,
+        UpdateEngineService updateEngine,
+        PluginInstallerService pluginInstaller,
+        PluginUpgradeQueueService pluginUpgrades)
+    {
+        switch (context.Command.ToLowerInvariant())
+        {
+            case "update":
+                return await ExecuteUpdateAsync(context, updateEngine).ConfigureAwait(false);
+            case "plugin":
+                return ExecutePluginCommand(context, pluginInstaller, pluginUpgrades);
+            default:
+                return new LauncherResult
+                {
+                    Success = false,
+                    Stage = "command",
+                    Code = "unsupported_command",
+                    Message = $"Unsupported command '{context.Command}'."
+                };
+        }
+    }
+
+    private static async Task<LauncherResult> ExecuteUpdateAsync(CommandContext context, UpdateEngineService updateEngine)
+    {
+        return context.SubCommand.ToLowerInvariant() switch
+        {
+            "check" => updateEngine.CheckPendingUpdate(),
+            "apply" => await updateEngine.ApplyPendingUpdateAsync().ConfigureAwait(false),
+            "rollback" => updateEngine.RollbackLatest(),
+            "download" => await updateEngine.DownloadAsync(
+                context.GetOption("manifest-url") ?? throw new InvalidOperationException("Missing --manifest-url."),
+                context.GetOption("signature-url") ?? throw new InvalidOperationException("Missing --signature-url."),
+                context.GetOption("archive-url") ?? throw new InvalidOperationException("Missing --archive-url."),
+                CancellationToken.None).ConfigureAwait(false),
+            _ => new LauncherResult
+            {
+                Success = false,
+                Stage = "update",
+                Code = "unsupported_subcommand",
+                Message = $"Unsupported update sub-command '{context.SubCommand}'."
+            }
+        };
+    }
+
+    private static LauncherResult ExecutePluginCommand(
+        CommandContext context,
+        PluginInstallerService pluginInstaller,
+        PluginUpgradeQueueService pluginUpgrades)
+    {
+        switch (context.SubCommand.ToLowerInvariant())
+        {
+            case "install":
+            {
+                var source = context.GetOption("source") ?? throw new InvalidOperationException("Missing --source.");
+                var pluginsDir = context.GetOption("plugins-dir") ?? throw new InvalidOperationException("Missing --plugins-dir.");
+                return pluginInstaller.InstallPackage(source, pluginsDir);
+            }
+            case "update":
+            {
+                var pluginsDir = context.GetOption("plugins-dir") ?? throw new InvalidOperationException("Missing --plugins-dir.");
+                return pluginUpgrades.ApplyPendingUpgrades(pluginsDir);
+            }
+            default:
+                return new LauncherResult
+                {
+                    Success = false,
+                    Stage = "plugin",
+                    Code = "unsupported_subcommand",
+                    Message = $"Unsupported plugin sub-command '{context.SubCommand}'."
+                };
+        }
+    }
+
+    public static async Task WriteResultIfNeededAsync(string? resultPath, LauncherResult result)
+    {
+        if (string.IsNullOrWhiteSpace(resultPath))
+        {
+            return;
+        }
+
+        var fullPath = Path.GetFullPath(resultPath);
+        var dir = Path.GetDirectoryName(fullPath);
+        if (!string.IsNullOrWhiteSpace(dir))
+        {
+            Directory.CreateDirectory(dir);
+        }
+
+        var json = JsonSerializer.Serialize(result, new JsonSerializerOptions
+        {
+            WriteIndented = true
+        });
+        await File.WriteAllTextAsync(fullPath, json, Encoding.UTF8).ConfigureAwait(false);
+    }
+
+    public static string ResolveAppRoot(CommandContext context)
+    {
+        var configured = context.GetOption("app-root");
+        if (!string.IsNullOrWhiteSpace(configured))
+        {
+            return Path.GetFullPath(configured);
+        }
+
+        var baseDir = AppContext.BaseDirectory;
+        var parent = Path.GetFullPath(Path.Combine(baseDir, ".."));
+        var parentHost = OperatingSystem.IsWindows()
+            ? Path.Combine(parent, "LanMountainDesktop.exe")
+            : Path.Combine(parent, "LanMountainDesktop");
+        return File.Exists(parentHost) ? parent : baseDir;
+    }
+}

LanMountainDesktop.Launcher/Services/DeferredSplashStageReporter.cs

@@ -0,0 +1,32 @@
+using Avalonia.Threading;
+using LanMountainDesktop.Launcher.Views;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class DeferredSplashStageReporter : ISplashStageReporter
+{
+    private ISplashStageReporter? _inner;
+    private readonly List<(string Stage, string Message)> _pending = [];
+
+    public void SetInner(ISplashStageReporter inner)
+    {
+        _inner = inner;
+        foreach (var (stage, message) in _pending)
+        {
+            _inner.Report(stage, message);
+        }
+        _pending.Clear();
+    }
+
+    public void Report(string stage, string message)
+    {
+        if (_inner is not null)
+        {
+            _inner.Report(stage, message);
+        }
+        else
+        {
+            _pending.Add((stage, message));
+        }
+    }
+}

LanMountainDesktop.Launcher/Services/DeploymentLocator.cs

@@ -0,0 +1,160 @@
+using System.Globalization;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class DeploymentLocator
+{
+    private readonly string _appRoot;
+
+    public DeploymentLocator(string appRoot)
+    {
+        _appRoot = appRoot;
+    }
+
+    public string GetAppRoot() => _appRoot;
+
+    public string? FindCurrentDeploymentDirectory()
+    {
+        var candidates = Directory.Exists(_appRoot)
+            ? Directory.GetDirectories(_appRoot, "app-*", SearchOption.TopDirectoryOnly)
+            : [];
+
+        // 过滤掉无效的部署目录
+        var validCandidates = candidates
+            .Where(path => 
+                !File.Exists(Path.Combine(path, ".destroy")) &&    // 排除待删除
+                !File.Exists(Path.Combine(path, ".partial")))      // 排除未完成
+            .ToList();
+
+        // 优先选择带 .current 标记的版本
+        var withMarkers = validCandidates
+            .Where(path => File.Exists(Path.Combine(path, ".current")))
+            .Select(path => new
+            {
+                Path = path,
+                Version = ParseVersionFromDirectory(path)
+            })
+            .OrderByDescending(item => item.Version)
+            .ToList();
+
+        if (withMarkers.Count > 0)
+        {
+            return withMarkers[0].Path;
+        }
+
+        // 如果没有 .current 标记,选择最新版本
+        var byVersion = validCandidates
+            .Select(path => new
+            {
+                Path = path,
+                Version = ParseVersionFromDirectory(path)
+            })
+            .OrderByDescending(item => item.Version)
+            .ToList();
+
+        return byVersion.Count > 0 ? byVersion[0].Path : null;
+    }
+
+    public string? ResolveHostExecutablePath()
+    {
+        var executable = OperatingSystem.IsWindows() ? "LanMountainDesktop.exe" : "LanMountainDesktop";
+        var currentDeployment = FindCurrentDeploymentDirectory();
+        if (!string.IsNullOrWhiteSpace(currentDeployment))
+        {
+            var inDeployment = Path.Combine(currentDeployment, executable);
+            if (File.Exists(inDeployment))
+            {
+                return inDeployment;
+            }
+        }
+
+        var inRoot = Path.Combine(_appRoot, executable);
+        if (File.Exists(inRoot))
+        {
+            return inRoot;
+        }
+
+        var parent = Path.GetFullPath(Path.Combine(_appRoot, ".."));
+        var inParent = Path.Combine(parent, executable);
+        return File.Exists(inParent) ? inParent : null;
+    }
+
+    public string GetCurrentVersion()
+    {
+        var deployment = FindCurrentDeploymentDirectory();
+        if (string.IsNullOrWhiteSpace(deployment))
+        {
+            return "0.0.0";
+        }
+
+        return ParseVersionTextFromDirectory(deployment) ?? "0.0.0";
+    }
+
+    public string BuildNextDeploymentDirectory(string targetVersion)
+    {
+        var sanitized = string.IsNullOrWhiteSpace(targetVersion) ? "0.0.0" : targetVersion.Trim();
+        var index = 0;
+        while (true)
+        {
+            var candidate = Path.Combine(_appRoot, $"app-{sanitized}-{index.ToString(CultureInfo.InvariantCulture)}");
+            if (!Directory.Exists(candidate))
+            {
+                return candidate;
+            }
+
+            index++;
+        }
+    }
+
+    public void CleanupDestroyedDeployments()
+    {
+        try
+        {
+            var candidates = Directory.Exists(_appRoot)
+                ? Directory.GetDirectories(_appRoot, "app-*", SearchOption.TopDirectoryOnly)
+                : [];
+
+            var destroyedDirs = candidates
+                .Where(path => File.Exists(Path.Combine(path, ".destroy")));
+
+            foreach (var dir in destroyedDirs)
+            {
+                try
+                {
+                    Directory.Delete(dir, recursive: true);
+                }
+                catch
+                {
+                    // 忽略删除失败(可能文件被占用),下次启动再试
+                }
+            }
+        }
+        catch
+        {
+            // 忽略清理失败
+        }
+    }
+
+    public static Version ParseVersionFromDirectory(string path)
+    {
+        var text = ParseVersionTextFromDirectory(path);
+        return Version.TryParse(text, out var version) ? version : new Version(0, 0, 0);
+    }
+
+    private static string? ParseVersionTextFromDirectory(string path)
+    {
+        var fileName = Path.GetFileName(path);
+        if (string.IsNullOrWhiteSpace(fileName))
+        {
+            return null;
+        }
+
+        var segments = fileName.Split('-');
+        if (segments.Length < 2)
+        {
+            return null;
+        }
+
+        return segments[1];
+    }
+}

LanMountainDesktop.Launcher/Services/IOobeStep.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.Launcher.Services;
+
+internal interface IOobeStep
+{
+    Task RunAsync(CancellationToken cancellationToken);
+}

LanMountainDesktop.Launcher/Services/ISplashStageReporter.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.Launcher.Services;
+
+internal interface ISplashStageReporter
+{
+    void Report(string stage, string message);
+}

LanMountainDesktop.Launcher/Services/LauncherFlowCoordinator.cs

@@ -0,0 +1,194 @@
+using System.Diagnostics;
+using Avalonia.Threading;
+using LanMountainDesktop.Launcher.Models;
+using LanMountainDesktop.Launcher.Views;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class LauncherFlowCoordinator
+{
+    private readonly CommandContext _context;
+    private readonly DeploymentLocator _deploymentLocator;
+    private readonly OobeStateService _oobeStateService;
+    private readonly UpdateEngineService _updateEngine;
+    private readonly UpdateCheckService _updateCheckService;
+    private readonly PluginInstallerService _pluginInstallerService;
+    private readonly IReadOnlyList<IOobeStep> _oobeSteps;
+
+    public LauncherFlowCoordinator(
+        CommandContext context,
+        DeploymentLocator deploymentLocator,
+        OobeStateService oobeStateService,
+        UpdateEngineService updateEngine,
+        UpdateCheckService updateCheckService,
+        PluginInstallerService pluginInstallerService)
+    {
+        _context = context;
+        _deploymentLocator = deploymentLocator;
+        _oobeStateService = oobeStateService;
+        _updateEngine = updateEngine;
+        _updateCheckService = updateCheckService;
+        _pluginInstallerService = pluginInstallerService;
+        _oobeSteps = [new WelcomeOobeStep(_oobeStateService)];
+    }
+
+    public async Task<LauncherResult> RunAsync()
+    {
+        try
+        {
+            // 清理待删除的旧版本
+            _deploymentLocator.CleanupDestroyedDeployments();
+
+            if (_oobeStateService.IsFirstRun())
+            {
+                foreach (var step in _oobeSteps)
+                {
+                    await step.RunAsync(CancellationToken.None).ConfigureAwait(false);
+                }
+            }
+
+            var splashWindow = await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                var window = new SplashWindow();
+                window.Show();
+                return window;
+            });
+
+            var reporter = (ISplashStageReporter)splashWindow;
+
+            try
+            {
+                reporter.Report("silentUpdate", "update");
+                var updateResult = await _updateEngine.ApplyPendingUpdateAsync().ConfigureAwait(false);
+                if (!updateResult.Success)
+                {
+                    return updateResult;
+                }
+
+                reporter.Report("pluginTasks", "plugins");
+                var pluginsDir = _context.GetOption("plugins-dir")
+                                 ?? Path.Combine(_deploymentLocator.GetAppRoot(), "plugins");
+                var queueResult = new PluginUpgradeQueueService(_pluginInstallerService).ApplyPendingUpgrades(pluginsDir);
+                if (!queueResult.Success)
+                {
+                    return queueResult;
+                }
+
+                reporter.Report("launchHost", "launch");
+                var hostResult = LaunchHost();
+                if (!hostResult.Success)
+                {
+                    return hostResult;
+                }
+
+                return new LauncherResult
+                {
+                    Success = true,
+                    Stage = "exit",
+                    Code = "ok",
+                    Message = "Launcher completed successfully."
+                };
+            }
+            finally
+            {
+                await Dispatcher.UIThread.InvokeAsync(() => splashWindow.Close());
+            }
+        }
+        catch (Exception ex)
+        {
+            return new LauncherResult
+            {
+                Success = false,
+                Stage = "launch",
+                Code = "exception",
+                Message = ex.Message,
+                ErrorMessage = ex.Message
+            };
+        }
+    }
+
+    private LauncherResult LaunchHost()
+    {
+        var hostPath = _deploymentLocator.ResolveHostExecutablePath();
+        if (string.IsNullOrWhiteSpace(hostPath))
+        {
+            return new LauncherResult
+            {
+                Success = false,
+                Stage = "launchHost",
+                Code = "host_not_found",
+                Message = "LanMountainDesktop host executable not found."
+            };
+        }
+
+        if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
+        {
+            EnsureExecutable(hostPath);
+        }
+
+        var processStartInfo = new ProcessStartInfo
+        {
+            FileName = hostPath,
+            UseShellExecute = true,
+            WorkingDirectory = Path.GetDirectoryName(hostPath) ?? _deploymentLocator.GetAppRoot()
+        };
+
+        Process.Start(processStartInfo);
+        return new LauncherResult
+        {
+            Success = true,
+            Stage = "launchHost",
+            Code = "ok",
+            Message = "Host launched."
+        };
+    }
+
+    private static void EnsureExecutable(string path)
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            return;
+        }
+
+        try
+        {
+            var mode = File.GetUnixFileMode(path);
+            mode |= UnixFileMode.UserExecute | UnixFileMode.GroupExecute | UnixFileMode.OtherExecute;
+            File.SetUnixFileMode(path, mode);
+        }
+        catch
+        {
+        }
+    }
+
+    private sealed class WelcomeOobeStep : IOobeStep
+    {
+        private readonly OobeStateService _stateService;
+
+        public WelcomeOobeStep(OobeStateService stateService)
+        {
+            _stateService = stateService;
+        }
+
+        public async Task RunAsync(CancellationToken cancellationToken)
+        {
+            var window = await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                var oobeWindow = new OobeWindow();
+                oobeWindow.Show();
+                return oobeWindow;
+            });
+
+            try
+            {
+                using var _ = cancellationToken.Register(() => window.Close());
+                await window.WaitForEnterAsync().ConfigureAwait(false);
+                _stateService.MarkCompleted();
+            }
+            finally
+            {
+                await Dispatcher.UIThread.InvokeAsync(() => window.Close());
+            }
+        }
+    }
+}

LanMountainDesktop.Launcher/Services/OobeStateService.cs

@@ -0,0 +1,29 @@
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class OobeStateService
+{
+    private readonly string _markerPath;
+
+    public OobeStateService(string appRoot)
+    {
+        var stateDir = Path.Combine(appRoot, ".launcher", "state");
+        Directory.CreateDirectory(stateDir);
+        _markerPath = Path.Combine(stateDir, "first_run_completed");
+    }
+
+    public bool IsFirstRun()
+    {
+        return !File.Exists(_markerPath);
+    }
+
+    public void MarkCompleted()
+    {
+        var dir = Path.GetDirectoryName(_markerPath);
+        if (!string.IsNullOrWhiteSpace(dir))
+        {
+            Directory.CreateDirectory(dir);
+        }
+
+        File.WriteAllText(_markerPath, DateTimeOffset.UtcNow.ToString("O"));
+    }
+}

LanMountainDesktop.Launcher/Services/PluginInstallerService.cs

@@ -1,10 +1,10 @@
 using System.IO.Compression;
-using System.Security.Cryptography;
-using System.Text;
-using System.Text.Json;
 using LanMountainDesktop.PluginSdk;
+using LanMountainDesktop.Launcher.Models;
 
-internal static class Program
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class PluginInstallerService
 {
     private static readonly TimeSpan[] RetryDelays =
     [
@@ -13,103 +13,38 @@ internal static class Program
         TimeSpan.FromMilliseconds(500)
     ];
 
-    private static async Task<int> Main(string[] args)
+    public LauncherResult InstallPackage(string sourcePath, string pluginsDirectory)
     {
-        var result = new HelperResult();
-        string? resultPath = null;
+        var fullSourcePath = Path.GetFullPath(sourcePath);
+        var fullPluginsDirectory = Path.GetFullPath(pluginsDirectory);
 
-        try
+        if (!File.Exists(fullSourcePath))
         {
-            var parsedArgs = ParseArgs(args);
-            if (!parsedArgs.TryGetValue("source", out var sourcePath) ||
-                !parsedArgs.TryGetValue("plugins-dir", out var pluginsDirectory) ||
-                !parsedArgs.TryGetValue("result", out resultPath) ||
-                string.IsNullOrWhiteSpace(sourcePath) ||
-                string.IsNullOrWhiteSpace(pluginsDirectory) ||
-                string.IsNullOrWhiteSpace(resultPath))
-            {
-                throw new InvalidOperationException("Required arguments: --source <path> --plugins-dir <path> --result <path>.");
-            }
-
-            var fullSourcePath = Path.GetFullPath(sourcePath);
-            var fullPluginsDirectory = Path.GetFullPath(pluginsDirectory);
-            resultPath = Path.GetFullPath(resultPath);
-
-            if (!File.Exists(fullSourcePath))
-            {
-                throw new FileNotFoundException($"Plugin package '{fullSourcePath}' was not found.", fullSourcePath);
-            }
-
-            var manifest = ReadManifestFromPackage(fullSourcePath);
-            Directory.CreateDirectory(fullPluginsDirectory);
-            var destinationPath = Path.Combine(fullPluginsDirectory, BuildInstalledPackageFileName(manifest.Id));
-            var stagingPath = destinationPath + ".incoming";
-            DeleteFileWithRetry(stagingPath);
-            CopyWithRetry(fullSourcePath, stagingPath, overwrite: true);
-            RemoveExistingPluginPackages(fullPluginsDirectory, manifest.Id, destinationPath, stagingPath);
-            MoveWithOverwriteRetry(stagingPath, destinationPath);
-
-            result = new HelperResult
-            {
-                Success = true,
-                InstalledPackagePath = destinationPath,
-                ManifestId = manifest.Id,
-                ManifestName = manifest.Name
-            };
-        }
-        catch (Exception ex)
-        {
-            result = new HelperResult
-            {
-                Success = false,
-                ErrorMessage = ex.Message
-            };
+            throw new FileNotFoundException($"Plugin package '{fullSourcePath}' was not found.", fullSourcePath);
         }
 
-        if (!string.IsNullOrWhiteSpace(resultPath))
+        var manifest = ReadManifestFromPackage(fullSourcePath);
+        Directory.CreateDirectory(fullPluginsDirectory);
+        var destinationPath = Path.Combine(fullPluginsDirectory, BuildInstalledPackageFileName(manifest.Id));
+        var stagingPath = destinationPath + ".incoming";
+        DeleteFileWithRetry(stagingPath);
+        CopyWithRetry(fullSourcePath, stagingPath, overwrite: true);
+        RemoveExistingPluginPackages(fullPluginsDirectory, manifest.Id, destinationPath, stagingPath);
+        MoveWithOverwriteRetry(stagingPath, destinationPath);
+
+        return new LauncherResult
         {
-            var resultDirectory = Path.GetDirectoryName(resultPath);
-            if (!string.IsNullOrWhiteSpace(resultDirectory))
-            {
-                Directory.CreateDirectory(resultDirectory);
-            }
-
-            await File.WriteAllTextAsync(
-                resultPath,
-                JsonSerializer.Serialize(result, new JsonSerializerOptions
-                {
-                    WriteIndented = true
-                }),
-                Encoding.UTF8);
-        }
-
-        return result.Success ? 0 : 1;
+            Success = true,
+            Stage = "plugin.install",
+            Code = "ok",
+            Message = "Plugin installed.",
+            InstalledPackagePath = destinationPath,
+            ManifestId = manifest.Id,
+            ManifestName = manifest.Name
+        };
     }
 
-    private static Dictionary<string, string> ParseArgs(string[] args)
-    {
-        var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
-        for (var i = 0; i < args.Length; i++)
-        {
-            var current = args[i];
-            if (!current.StartsWith("--", StringComparison.Ordinal))
-            {
-                continue;
-            }
-
-            var key = current[2..];
-            if (string.IsNullOrWhiteSpace(key) || i + 1 >= args.Length)
-            {
-                continue;
-            }
-
-            values[key] = args[++i];
-        }
-
-        return values;
-    }
-
-    private static PluginManifest ReadManifestFromPackage(string packagePath)
+    public PluginManifest ReadManifestFromPackage(string packagePath)
     {
         using var archive = ZipFile.OpenRead(packagePath);
         var entries = archive.Entries
@@ -132,9 +67,12 @@ internal static class Program
         return PluginManifest.Load(stream, $"{packagePath}!/{entries[0].FullName}");
     }
 
-    private static void RemoveExistingPluginPackages(string pluginsDirectory, string pluginId, string destinationPath, string stagingPath)
+    private void RemoveExistingPluginPackages(string pluginsDirectory, string pluginId, string destinationPath, string stagingPath)
     {
         var runtimeRootDirectory = EnsureTrailingSeparator(Path.Combine(Path.GetFullPath(pluginsDirectory), PluginSdkInfo.RuntimeDirectoryName));
+        var pendingDeletionDir = Path.Combine(pluginsDirectory, ".pending-deletions");
+        Directory.CreateDirectory(pendingDeletionDir);
+
         foreach (var existingPackagePath in Directory
                      .EnumerateFiles(pluginsDirectory, "*" + PluginSdkInfo.PackageFileExtension, SearchOption.AllDirectories)
                      .Select(Path.GetFullPath)
@@ -154,11 +92,45 @@ internal static class Program
                     continue;
                 }
 
-                DeleteFileWithRetry(existingPackagePath);
+                TryRemoveExistingPackage(existingPackagePath, pendingDeletionDir);
+            }
+            catch
+            {
+            }
+        }
+
+        CleanupPendingDeletions(pendingDeletionDir);
+    }
+
+    private void TryRemoveExistingPackage(string existingPackagePath, string pendingDeletionDir)
+    {
+        try
+        {
+            DeleteFileWithRetry(existingPackagePath);
+        }
+        catch (IOException)
+        {
+            var fileName = Path.GetFileName(existingPackagePath);
+            var pendingPath = Path.Combine(pendingDeletionDir, $"{fileName}.{Guid.NewGuid():N}.pending");
+            File.Move(existingPackagePath, pendingPath);
+        }
+    }
+
+    private static void CleanupPendingDeletions(string pendingDeletionDir)
+    {
+        if (!Directory.Exists(pendingDeletionDir))
+        {
+            return;
+        }
+
+        foreach (var pendingFile in Directory.EnumerateFiles(pendingDeletionDir, "*.pending"))
+        {
+            try
+            {
+                File.Delete(pendingFile);
             }
             catch
             {
-                // Ignore unrelated or malformed packages while replacing an install target.
             }
         }
     }
@@ -187,7 +159,6 @@ internal static class Program
     private static void Retry(Action action)
     {
         Exception? lastException = null;
-
         for (var attempt = 0; attempt <= RetryDelays.Length; attempt++)
         {
             try
@@ -226,17 +197,4 @@ internal static class Program
             ? path
             : path + Path.DirectorySeparatorChar;
     }
-
-    private sealed class HelperResult
-    {
-        public bool Success { get; init; }
-
-        public string? InstalledPackagePath { get; init; }
-
-        public string? ManifestId { get; init; }
-
-        public string? ManifestName { get; init; }
-
-        public string? ErrorMessage { get; init; }
-    }
 }

LanMountainDesktop.Launcher/Services/PluginUpgradeQueueService.cs

@@ -0,0 +1,97 @@
+using System.Text.Json;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class PluginUpgradeQueueService
+{
+    private const string PendingUpgradesFileName = ".pending-plugin-upgrades.json";
+
+    private readonly PluginInstallerService _installerService;
+
+    public PluginUpgradeQueueService(PluginInstallerService installerService)
+    {
+        _installerService = installerService;
+    }
+
+    public LauncherResult ApplyPendingUpgrades(string pluginsDirectory)
+    {
+        var pendingPath = Path.Combine(pluginsDirectory, PendingUpgradesFileName);
+        if (!File.Exists(pendingPath))
+        {
+            return new LauncherResult
+            {
+                Success = true,
+                Stage = "plugin.update",
+                Code = "noop",
+                Message = "No pending plugin upgrades."
+            };
+        }
+
+        var text = File.ReadAllText(pendingPath);
+        var pending = JsonSerializer.Deserialize<List<PendingUpgrade>>(text) ?? [];
+        var failures = new List<string>();
+        var succeeded = new List<PendingUpgrade>();
+
+        foreach (var item in pending)
+        {
+            if (!item.IsValid())
+            {
+                failures.Add(item.PluginId);
+                continue;
+            }
+
+            try
+            {
+                _installerService.InstallPackage(item.SourcePackagePath, pluginsDirectory);
+                succeeded.Add(item);
+            }
+            catch
+            {
+                failures.Add(item.PluginId);
+            }
+        }
+
+        var remaining = pending
+            .Except(succeeded)
+            .Where(item => failures.Contains(item.PluginId, StringComparer.OrdinalIgnoreCase))
+            .ToList();
+
+        if (remaining.Count == 0)
+        {
+            File.Delete(pendingPath);
+        }
+        else
+        {
+            File.WriteAllText(pendingPath, JsonSerializer.Serialize(remaining, new JsonSerializerOptions
+            {
+                WriteIndented = true
+            }));
+        }
+
+        return new LauncherResult
+        {
+            Success = failures.Count == 0,
+            Stage = "plugin.update",
+            Code = failures.Count == 0 ? "ok" : "partial_failed",
+            Message = failures.Count == 0
+                ? $"Applied {succeeded.Count} pending plugin upgrade(s)."
+                : $"Applied {succeeded.Count} upgrades, failed: {string.Join(", ", failures)}."
+        };
+    }
+
+    private sealed record PendingUpgrade(
+        string PluginId,
+        string SourcePackagePath,
+        string TargetVersion,
+        DateTimeOffset CreatedAt)
+    {
+        public bool IsValid()
+        {
+            return !string.IsNullOrWhiteSpace(PluginId) &&
+                   !string.IsNullOrWhiteSpace(SourcePackagePath) &&
+                   !string.IsNullOrWhiteSpace(TargetVersion) &&
+                   File.Exists(SourcePackagePath);
+        }
+    }
+}

LanMountainDesktop.Launcher/Services/UpdateCheckService.cs

@@ -0,0 +1,168 @@
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+/// <summary>
+/// 更新检查服务 - 基于 GitHub Release API
+/// </summary>
+internal sealed class UpdateCheckService
+{
+    private const string GitHubApiBase = "https://api.github.com";
+    private readonly string _repoOwner;
+    private readonly string _repoName;
+    private readonly HttpClient _httpClient;
+    private readonly JsonSerializerOptions _jsonOptions;
+
+    public UpdateCheckService(string repoOwner, string repoName)
+    {
+        _repoOwner = repoOwner;
+        _repoName = repoName;
+        _httpClient = new HttpClient();
+        _httpClient.DefaultRequestHeaders.Add("User-Agent", "LanMountainDesktop-Launcher");
+        _httpClient.DefaultRequestHeaders.Add("Accept", "application/vnd.github+json");
+
+        _jsonOptions = new JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true,
+            PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower
+        };
+    }
+
+    /// <summary>
+    /// 检查更新
+    /// </summary>
+    public async Task<UpdateCheckResult> CheckForUpdateAsync(
+        string currentVersion,
+        UpdateChannel channel,
+        CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var releases = await FetchReleasesAsync(cancellationToken);
+            
+            // 根据频道过滤版本
+            var filteredReleases = channel == UpdateChannel.Stable
+                ? releases.Where(r => !r.Prerelease).ToList()
+                : releases;
+
+            // 找到最新版本
+            var latestRelease = filteredReleases
+                .OrderByDescending(r => ParseVersion(r.TagName))
+                .FirstOrDefault();
+
+            if (latestRelease == null)
+            {
+                return new UpdateCheckResult
+                {
+                    HasUpdate = false,
+                    CurrentVersion = currentVersion,
+                    ErrorMessage = "No releases found"
+                };
+            }
+
+            var latestVersion = ParseVersionString(latestRelease.TagName);
+            var current = ParseVersion(currentVersion);
+            var latest = ParseVersion(latestVersion);
+
+            return new UpdateCheckResult
+            {
+                HasUpdate = latest > current,
+                LatestVersion = latestVersion,
+                CurrentVersion = currentVersion,
+                Release = latestRelease
+            };
+        }
+        catch (Exception ex)
+        {
+            return new UpdateCheckResult
+            {
+                HasUpdate = false,
+                CurrentVersion = currentVersion,
+                ErrorMessage = ex.Message
+            };
+        }
+    }
+
+    /// <summary>
+    /// 获取所有 Release
+    /// </summary>
+    private async Task<List<ReleaseInfo>> FetchReleasesAsync(CancellationToken cancellationToken)
+    {
+        var url = $"{GitHubApiBase}/repos/{_repoOwner}/{_repoName}/releases";
+        var response = await _httpClient.GetAsync(url, cancellationToken);
+        response.EnsureSuccessStatusCode();
+
+        var json = await response.Content.ReadAsStringAsync(cancellationToken);
+        var releases = JsonSerializer.Deserialize<List<GitHubRelease>>(json, _jsonOptions);
+
+        return releases?.Select(r => new ReleaseInfo
+        {
+            TagName = r.TagName ?? "",
+            Name = r.Name ?? "",
+            Prerelease = r.Prerelease,
+            PublishedAt = r.PublishedAt,
+            Body = r.Body,
+            Assets = r.Assets?.Select(a => new ReleaseAsset
+            {
+                Name = a.Name ?? "",
+                BrowserDownloadUrl = a.BrowserDownloadUrl ?? "",
+                Size = a.Size
+            }).ToList() ?? []
+        }).ToList() ?? [];
+    }
+
+    /// <summary>
+    /// 从 tag 解析版本号 (例如: v1.0.0 -> 1.0.0)
+    /// </summary>
+    private static string ParseVersionString(string tag)
+    {
+        return tag.TrimStart('v', 'V');
+    }
+
+    /// <summary>
+    /// 解析版本号
+    /// </summary>
+    private static Version ParseVersion(string versionString)
+    {
+        var cleaned = ParseVersionString(versionString);
+        return Version.TryParse(cleaned, out var version) ? version : new Version(0, 0, 0);
+    }
+
+    // GitHub API 响应模型
+    private sealed class GitHubRelease
+    {
+        [JsonPropertyName("tag_name")]
+        public string? TagName { get; set; }
+
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        [JsonPropertyName("prerelease")]
+        public bool Prerelease { get; set; }
+
+        [JsonPropertyName("published_at")]
+        public DateTime PublishedAt { get; set; }
+
+        [JsonPropertyName("body")]
+        public string? Body { get; set; }
+
+        [JsonPropertyName("assets")]
+        public List<GitHubAsset>? Assets { get; set; }
+    }
+
+    private sealed class GitHubAsset
+    {
+        [JsonPropertyName("name")]
+        public string? Name { get; set; }
+
+        [JsonPropertyName("browser_download_url")]
+        public string? BrowserDownloadUrl { get; set; }
+
+        [JsonPropertyName("size")]
+        public long Size { get; set; }
+    }
+}

LanMountainDesktop.Launcher/Services/UpdateEngineService.cs

@@ -0,0 +1,512 @@
+using System.IO.Compression;
+using System.Security.Cryptography;
+using System.Text.Json;
+using LanMountainDesktop.Launcher.Models;
+
+namespace LanMountainDesktop.Launcher.Services;
+
+internal sealed class UpdateEngineService
+{
+    private const string LauncherDirectoryName = ".launcher";
+    private const string UpdateDirectoryName = "update";
+    private const string IncomingDirectoryName = "incoming";
+    private const string SnapshotsDirectoryName = "snapshots";
+    private const string SignedFileMapName = "files.json";
+    private const string SignatureFileName = "files.json.sig";
+    private const string ArchiveFileName = "update.zip";
+    private const string PublicKeyFileName = "public-key.pem";
+
+    private readonly DeploymentLocator _deploymentLocator;
+    private readonly string _appRoot;
+    private readonly string _launcherRoot;
+    private readonly string _incomingRoot;
+    private readonly string _snapshotsRoot;
+
+    public UpdateEngineService(DeploymentLocator deploymentLocator)
+    {
+        _deploymentLocator = deploymentLocator;
+        _appRoot = deploymentLocator.GetAppRoot();
+        _launcherRoot = Path.Combine(_appRoot, LauncherDirectoryName);
+        _incomingRoot = Path.Combine(_launcherRoot, UpdateDirectoryName, IncomingDirectoryName);
+        _snapshotsRoot = Path.Combine(_launcherRoot, SnapshotsDirectoryName);
+    }
+
+    public LauncherResult CheckPendingUpdate()
+    {
+        var fileMapPath = Path.Combine(_incomingRoot, SignedFileMapName);
+        var archivePath = Path.Combine(_incomingRoot, ArchiveFileName);
+        var signaturePath = Path.Combine(_incomingRoot, SignatureFileName);
+        if (!File.Exists(fileMapPath) || !File.Exists(archivePath))
+        {
+            return new LauncherResult
+            {
+                Success = true,
+                Stage = "update.check",
+                Code = "noop",
+                Message = "No pending update."
+            };
+        }
+
+        var fileMapText = File.ReadAllText(fileMapPath);
+        var fileMap = JsonSerializer.Deserialize<SignedFileMap>(fileMapText);
+        if (fileMap is null)
+        {
+            return Failed("update.check", "invalid_manifest", "files.json is invalid.");
+        }
+
+        var verified = VerifySignature(fileMapPath, signaturePath);
+        if (!verified.Success)
+        {
+            return Failed("update.check", "signature_failed", verified.Message);
+        }
+
+        return new LauncherResult
+        {
+            Success = true,
+            Stage = "update.check",
+            Code = "available",
+            Message = "Pending update is available.",
+            CurrentVersion = _deploymentLocator.GetCurrentVersion(),
+            TargetVersion = fileMap.ToVersion
+        };
+    }
+
+    public async Task<LauncherResult> DownloadAsync(string manifestUrl, string signatureUrl, string archiveUrl, CancellationToken cancellationToken)
+    {
+        Directory.CreateDirectory(_incomingRoot);
+        using var client = new HttpClient
+        {
+            Timeout = TimeSpan.FromMinutes(2)
+        };
+
+        var manifestPath = Path.Combine(_incomingRoot, SignedFileMapName);
+        var signaturePath = Path.Combine(_incomingRoot, SignatureFileName);
+        var archivePath = Path.Combine(_incomingRoot, ArchiveFileName);
+
+        await using (var stream = await client.GetStreamAsync(manifestUrl, cancellationToken).ConfigureAwait(false))
+        await using (var output = File.Create(manifestPath))
+        {
+            await stream.CopyToAsync(output, cancellationToken).ConfigureAwait(false);
+        }
+
+        await using (var stream = await client.GetStreamAsync(signatureUrl, cancellationToken).ConfigureAwait(false))
+        await using (var output = File.Create(signaturePath))
+        {
+            await stream.CopyToAsync(output, cancellationToken).ConfigureAwait(false);
+        }
+
+        await using (var stream = await client.GetStreamAsync(archiveUrl, cancellationToken).ConfigureAwait(false))
+        await using (var output = File.Create(archivePath))
+        {
+            await stream.CopyToAsync(output, cancellationToken).ConfigureAwait(false);
+        }
+
+        return new LauncherResult
+        {
+            Success = true,
+            Stage = "update.download",
+            Code = "ok",
+            Message = "Update downloaded."
+        };
+    }
+
+    public async Task<LauncherResult> ApplyPendingUpdateAsync()
+    {
+        Directory.CreateDirectory(_incomingRoot);
+        Directory.CreateDirectory(_snapshotsRoot);
+
+        var fileMapPath = Path.Combine(_incomingRoot, SignedFileMapName);
+        var signaturePath = Path.Combine(_incomingRoot, SignatureFileName);
+        var archivePath = Path.Combine(_incomingRoot, ArchiveFileName);
+
+        if (!File.Exists(fileMapPath) || !File.Exists(archivePath))
+        {
+            return new LauncherResult
+            {
+                Success = true,
+                Stage = "update.apply",
+                Code = "noop",
+                Message = "No update payload found."
+            };
+        }
+
+        var verifyResult = VerifySignature(fileMapPath, signaturePath);
+        if (!verifyResult.Success)
+        {
+            return Failed("update.apply", "signature_failed", verifyResult.Message);
+        }
+
+        var fileMapText = await File.ReadAllTextAsync(fileMapPath);
+        var fileMap = JsonSerializer.Deserialize<SignedFileMap>(fileMapText);
+        if (fileMap is null || fileMap.Files.Count == 0)
+        {
+            return Failed("update.apply", "invalid_manifest", "No update file entries were found.");
+        }
+
+        var currentDeployment = _deploymentLocator.FindCurrentDeploymentDirectory();
+        if (string.IsNullOrWhiteSpace(currentDeployment))
+        {
+            return Failed("update.apply", "no_current_deployment", "Current deployment directory not found.");
+        }
+
+        var currentVersion = _deploymentLocator.GetCurrentVersion();
+        if (!string.IsNullOrWhiteSpace(fileMap.FromVersion) &&
+            !string.Equals(fileMap.FromVersion, currentVersion, StringComparison.OrdinalIgnoreCase))
+        {
+            return Failed(
+                "update.apply",
+                "version_mismatch",
+                $"Update requires source version {fileMap.FromVersion} but current is {currentVersion}.");
+        }
+
+        var targetVersion = string.IsNullOrWhiteSpace(fileMap.ToVersion) ? currentVersion : fileMap.ToVersion!;
+        var targetDeployment = _deploymentLocator.BuildNextDeploymentDirectory(targetVersion);
+        var partialMarker = Path.Combine(targetDeployment, ".partial");
+        var snapshot = new SnapshotMetadata
+        {
+            SnapshotId = Guid.NewGuid().ToString("N"),
+            SourceVersion = currentVersion,
+            TargetVersion = targetVersion,
+            CreatedAt = DateTimeOffset.UtcNow,
+            SourceDirectory = currentDeployment,
+            TargetDirectory = targetDeployment,
+            Status = "pending"
+        };
+        var snapshotPath = Path.Combine(_snapshotsRoot, $"{snapshot.SnapshotId}.json");
+
+        var extractRoot = Path.Combine(_incomingRoot, "extracted");
+        try
+        {
+            SaveSnapshot(snapshotPath, snapshot);
+
+            if (Directory.Exists(extractRoot))
+            {
+                Directory.Delete(extractRoot, true);
+            }
+
+            Directory.CreateDirectory(extractRoot);
+            ZipFile.ExtractToDirectory(archivePath, extractRoot, overwriteFiles: true);
+
+            Directory.CreateDirectory(targetDeployment);
+            File.WriteAllText(partialMarker, string.Empty);
+
+            foreach (var file in fileMap.Files)
+            {
+                ApplyFileEntry(file, currentDeployment, targetDeployment, extractRoot);
+            }
+
+            foreach (var file in fileMap.Files)
+            {
+                if (!NeedsVerification(file))
+                {
+                    continue;
+                }
+
+                var fullPath = Path.Combine(targetDeployment, file.Path);
+                var actualHash = ComputeSha256Hex(fullPath);
+                if (!string.Equals(actualHash, file.Sha256, StringComparison.OrdinalIgnoreCase))
+                {
+                    throw new InvalidOperationException($"File hash mismatch for '{file.Path}'.");
+                }
+            }
+
+            ActivateDeployment(currentDeployment, targetDeployment);
+
+            snapshot.Status = "applied";
+            SaveSnapshot(snapshotPath, snapshot);
+            CleanupIncomingArtifacts();
+            CleanupDestroyedDeployments();
+
+            return new LauncherResult
+            {
+                Success = true,
+                Stage = "update.apply",
+                Code = "ok",
+                Message = $"Updated to {targetVersion}.",
+                CurrentVersion = currentVersion,
+                TargetVersion = targetVersion
+            };
+        }
+        catch (Exception ex)
+        {
+            TryRollbackOnFailure(snapshot);
+            snapshot.Status = "rolled_back";
+            SaveSnapshot(snapshotPath, snapshot);
+            return new LauncherResult
+            {
+                Success = false,
+                Stage = "update.apply",
+                Code = "apply_failed",
+                Message = "Failed to apply update. Rolled back to previous version.",
+                ErrorMessage = ex.Message,
+                CurrentVersion = currentVersion,
+                RolledBackTo = currentVersion
+            };
+        }
+        finally
+        {
+            try
+            {
+                if (Directory.Exists(extractRoot))
+                {
+                    Directory.Delete(extractRoot, true);
+                }
+            }
+            catch
+            {
+            }
+        }
+    }
+
+    public LauncherResult RollbackLatest()
+    {
+        if (!Directory.Exists(_snapshotsRoot))
+        {
+            return Failed("update.rollback", "no_snapshot", "No snapshot found.");
+        }
+
+        var snapshotPath = Directory
+            .EnumerateFiles(_snapshotsRoot, "*.json", SearchOption.TopDirectoryOnly)
+            .OrderByDescending(File.GetCreationTimeUtc)
+            .FirstOrDefault();
+        if (string.IsNullOrWhiteSpace(snapshotPath))
+        {
+            return Failed("update.rollback", "no_snapshot", "No snapshot found.");
+        }
+
+        var snapshot = JsonSerializer.Deserialize<SnapshotMetadata>(File.ReadAllText(snapshotPath));
+        if (snapshot is null || string.IsNullOrWhiteSpace(snapshot.SourceDirectory))
+        {
+            return Failed("update.rollback", "invalid_snapshot", "Invalid snapshot metadata.");
+        }
+
+        var currentDeployment = _deploymentLocator.FindCurrentDeploymentDirectory();
+        if (string.IsNullOrWhiteSpace(currentDeployment))
+        {
+            return Failed("update.rollback", "no_current_deployment", "Current deployment not found.");
+        }
+
+        ActivateDeployment(currentDeployment, snapshot.SourceDirectory);
+        snapshot.Status = "manual_rollback";
+        SaveSnapshot(snapshotPath, snapshot);
+
+        return new LauncherResult
+        {
+            Success = true,
+            Stage = "update.rollback",
+            Code = "ok",
+            Message = $"Rolled back to {snapshot.SourceVersion}.",
+            RolledBackTo = snapshot.SourceVersion
+        };
+    }
+
+    public void CleanupDestroyedDeployments()
+    {
+        foreach (var dir in Directory.EnumerateDirectories(_appRoot, "app-*", SearchOption.TopDirectoryOnly))
+        {
+            if (!File.Exists(Path.Combine(dir, ".destroy")))
+            {
+                continue;
+            }
+
+            try
+            {
+                Directory.Delete(dir, true);
+            }
+            catch
+            {
+            }
+        }
+    }
+
+    private void ApplyFileEntry(UpdateFileEntry file, string currentDeployment, string targetDeployment, string extractRoot)
+    {
+        var normalizedPath = NormalizeRelativePath(file.Path);
+        if (string.Equals(file.Action, "delete", StringComparison.OrdinalIgnoreCase))
+        {
+            return;
+        }
+
+        var targetPath = Path.Combine(targetDeployment, normalizedPath);
+        EnsurePathWithinRoot(targetPath, targetDeployment);
+        var targetDir = Path.GetDirectoryName(targetPath);
+        if (!string.IsNullOrWhiteSpace(targetDir))
+        {
+            Directory.CreateDirectory(targetDir);
+        }
+
+        if (string.Equals(file.Action, "reuse", StringComparison.OrdinalIgnoreCase))
+        {
+            var sourcePath = Path.Combine(currentDeployment, normalizedPath);
+            EnsurePathWithinRoot(sourcePath, currentDeployment);
+            if (!File.Exists(sourcePath))
+            {
+                throw new FileNotFoundException($"Cannot reuse file '{file.Path}' because it was not found in current deployment.");
+            }
+
+            File.Copy(sourcePath, targetPath, overwrite: true);
+            return;
+        }
+
+        var archiveRelative = string.IsNullOrWhiteSpace(file.ArchivePath) ? normalizedPath : NormalizeRelativePath(file.ArchivePath);
+        var extractedPath = Path.Combine(extractRoot, archiveRelative);
+        EnsurePathWithinRoot(extractedPath, extractRoot);
+        if (!File.Exists(extractedPath))
+        {
+            throw new FileNotFoundException($"Archive file '{archiveRelative}' not found for '{file.Path}'.");
+        }
+
+        File.Copy(extractedPath, targetPath, overwrite: true);
+    }
+
+    private void ActivateDeployment(string fromDeployment, string toDeployment)
+    {
+        var toCurrent = Path.Combine(toDeployment, ".current");
+        var fromCurrent = Path.Combine(fromDeployment, ".current");
+        var fromDestroy = Path.Combine(fromDeployment, ".destroy");
+        var toPartial = Path.Combine(toDeployment, ".partial");
+
+        File.WriteAllText(toCurrent, string.Empty);
+        if (File.Exists(fromCurrent))
+        {
+            File.Delete(fromCurrent);
+        }
+
+        File.WriteAllText(fromDestroy, string.Empty);
+        if (File.Exists(toPartial))
+        {
+            File.Delete(toPartial);
+        }
+    }
+
+    private void TryRollbackOnFailure(SnapshotMetadata snapshot)
+    {
+        try
+        {
+            if (!string.IsNullOrWhiteSpace(snapshot.TargetDirectory) && Directory.Exists(snapshot.TargetDirectory))
+            {
+                Directory.Delete(snapshot.TargetDirectory, true);
+            }
+
+            if (File.Exists(Path.Combine(snapshot.SourceDirectory, ".destroy")))
+            {
+                File.Delete(Path.Combine(snapshot.SourceDirectory, ".destroy"));
+            }
+
+            if (!File.Exists(Path.Combine(snapshot.SourceDirectory, ".current")))
+            {
+                File.WriteAllText(Path.Combine(snapshot.SourceDirectory, ".current"), string.Empty);
+            }
+        }
+        catch
+        {
+        }
+    }
+
+    private void CleanupIncomingArtifacts()
+    {
+        foreach (var path in new[]
+                 {
+                     Path.Combine(_incomingRoot, SignedFileMapName),
+                     Path.Combine(_incomingRoot, SignatureFileName),
+                     Path.Combine(_incomingRoot, ArchiveFileName)
+                 })
+        {
+            try
+            {
+                if (File.Exists(path))
+                {
+                    File.Delete(path);
+                }
+            }
+            catch
+            {
+            }
+        }
+    }
+
+    private (bool Success, string Message) VerifySignature(string fileMapPath, string signaturePath)
+    {
+        if (!File.Exists(signaturePath))
+        {
+            return (false, "Missing files.json.sig.");
+        }
+
+        var publicKeyPath = Path.Combine(_launcherRoot, UpdateDirectoryName, PublicKeyFileName);
+        if (!File.Exists(publicKeyPath))
+        {
+            return (false, $"Missing public key: {publicKeyPath}");
+        }
+
+        var jsonBytes = File.ReadAllBytes(fileMapPath);
+        var signatureBase64 = File.ReadAllText(signaturePath).Trim();
+        if (string.IsNullOrWhiteSpace(signatureBase64))
+        {
+            return (false, "Signature is empty.");
+        }
+
+        byte[] signature;
+        try
+        {
+            signature = Convert.FromBase64String(signatureBase64);
+        }
+        catch (FormatException)
+        {
+            return (false, "Signature is not valid base64.");
+        }
+
+        using var rsa = RSA.Create();
+        rsa.ImportFromPem(File.ReadAllText(publicKeyPath));
+        var isValid = rsa.VerifyData(jsonBytes, signature, HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
+        return isValid ? (true, "ok") : (false, "Signature verification failed.");
+    }
+
+    private static string NormalizeRelativePath(string path)
+    {
+        var normalized = path.Replace('\\', Path.DirectorySeparatorChar).Replace('/', Path.DirectorySeparatorChar);
+        return normalized.TrimStart(Path.DirectorySeparatorChar);
+    }
+
+    private static void EnsurePathWithinRoot(string targetPath, string rootPath)
+    {
+        var fullTarget = Path.GetFullPath(targetPath);
+        var fullRoot = Path.GetFullPath(rootPath);
+        if (!fullTarget.StartsWith(fullRoot, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidOperationException($"Path traversal detected: {targetPath}");
+        }
+    }
+
+    private static bool NeedsVerification(UpdateFileEntry file)
+    {
+        return !string.Equals(file.Action, "delete", StringComparison.OrdinalIgnoreCase) &&
+               !string.IsNullOrWhiteSpace(file.Sha256);
+    }
+
+    private static string ComputeSha256Hex(string filePath)
+    {
+        using var stream = File.OpenRead(filePath);
+        var hash = SHA256.HashData(stream);
+        return Convert.ToHexString(hash).ToLowerInvariant();
+    }
+
+    private static void SaveSnapshot(string path, SnapshotMetadata snapshot)
+    {
+        File.WriteAllText(path, JsonSerializer.Serialize(snapshot, new JsonSerializerOptions
+        {
+            WriteIndented = true
+        }));
+    }
+
+    private static LauncherResult Failed(string stage, string code, string message)
+    {
+        return new LauncherResult
+        {
+            Success = false,
+            Stage = stage,
+            Code = code,
+            Message = message,
+            ErrorMessage = message
+        };
+    }
+}

LanMountainDesktop.Launcher/Views/OobeWindow.axaml

@@ -0,0 +1,22 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        x:Class="LanMountainDesktop.Launcher.Views.OobeWindow"
+        Title="阑山桌面"
+        Width="420"
+        Height="260"
+        CanResize="False"
+        WindowStartupLocation="CenterScreen">
+  <Grid Margin="24" RowDefinitions="*,Auto">
+    <TextBlock Text="欢迎使用阑山桌面"
+               FontSize="26"
+               VerticalAlignment="Center"
+               HorizontalAlignment="Center" />
+    <Button Grid.Row="1"
+            x:Name="EnterButton"
+            HorizontalAlignment="Right"
+            Width="64"
+            Height="40"
+            Content="→"
+            FontSize="18" />
+  </Grid>
+</Window>

LanMountainDesktop.Launcher/Views/OobeWindow.axaml.cs

@@ -0,0 +1,27 @@
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Launcher.Views;
+
+internal partial class OobeWindow : Window
+{
+    private readonly TaskCompletionSource<bool> _completionSource = new();
+
+    public OobeWindow()
+    {
+        AvaloniaXamlLoader.Load(this);
+        var enterButton = this.FindControl<Button>("EnterButton");
+        if (enterButton is not null)
+        {
+            enterButton.Click += OnEnterClick;
+        }
+    }
+
+    public Task WaitForEnterAsync() => _completionSource.Task;
+
+    private void OnEnterClick(object? sender, RoutedEventArgs e)
+    {
+        _completionSource.TrySetResult(true);
+    }
+}

LanMountainDesktop.Launcher/Views/SplashWindow.axaml

@@ -0,0 +1,40 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        x:Class="LanMountainDesktop.Launcher.Views.SplashWindow"
+        Title="阑山桌面"
+        Width="420"
+        Height="240"
+        CanResize="False"
+        WindowStartupLocation="CenterScreen"
+        SystemDecorations="None">
+  <Grid Margin="24" RowDefinitions="*,Auto,Auto,Auto">
+    <TextBlock x:Name="AppNameText"
+               Text="阑山桌面"
+               FontSize="34"
+               VerticalAlignment="Center"
+               HorizontalAlignment="Center"
+               Grid.Row="0" />
+    <ProgressBar x:Name="ProgressIndicator"
+                 Grid.Row="1"
+                 Minimum="0"
+                 Maximum="100"
+                 Value="0"
+                 Height="4"
+                 Margin="0,12,0,0"
+                 IsIndeterminate="True" />
+    <TextBlock x:Name="StageText"
+               Grid.Row="2"
+               FontSize="12"
+               Foreground="#999999"
+               HorizontalAlignment="Center"
+               Margin="0,8,0,0"
+               Text="" />
+    <TextBlock x:Name="DetailText"
+               Grid.Row="3"
+               FontSize="11"
+               Foreground="#BBBBBB"
+               HorizontalAlignment="Center"
+               Margin="0,2,0,0"
+               Text="" />
+  </Grid>
+</Window>

LanMountainDesktop.Launcher/Views/SplashWindow.axaml.cs

@@ -0,0 +1,48 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using LanMountainDesktop.Launcher.Services;
+
+namespace LanMountainDesktop.Launcher.Views;
+
+internal partial class SplashWindow : Window, ISplashStageReporter
+{
+    private static readonly (string Stage, string Label, double Progress)[] StageMap =
+    [
+        ("bootstrap", "正在初始化...", 10),
+        ("silentUpdate", "正在应用更新...", 35),
+        ("pluginTasks", "正在处理插件...", 65),
+        ("launchHost", "正在启动...", 90),
+    ];
+
+    public SplashWindow()
+    {
+        AvaloniaXamlLoader.Load(this);
+    }
+
+    public void Report(string stage, string message)
+    {
+        var (label, progress) = ResolveStageInfo(stage);
+
+        var stageText = this.GetControl<TextBlock>("StageText");
+        var detailText = this.GetControl<TextBlock>("DetailText");
+        var progressIndicator = this.GetControl<ProgressBar>("ProgressIndicator");
+
+        stageText.Text = label;
+        detailText.Text = message;
+        progressIndicator.IsIndeterminate = false;
+        progressIndicator.Value = progress;
+    }
+
+    private static (string Label, double Progress) ResolveStageInfo(string stage)
+    {
+        foreach (var (s, label, progress) in StageMap)
+        {
+            if (string.Equals(s, stage, StringComparison.OrdinalIgnoreCase))
+            {
+                return (label, progress);
+            }
+        }
+
+        return (stage, 0);
+    }
+}

LanMountainDesktop.PluginSdk/AppearanceChangedEvent.cs

@@ -0,0 +1,109 @@
+namespace LanMountainDesktop.PluginSdk;
+
+/// <summary>
+/// 外观变更事件参数，当主题、圆角或其他外观属性变化时触发。
+/// </summary>
+public sealed class AppearanceChangedEvent : EventArgs
+{
+    /// <summary>
+    /// 创建外观变更事件实例。
+    /// </summary>
+    /// <param name="snapshot">当前外观快照</param>
+    /// <param name="changedProperties">变更的属性集合</param>
+    public AppearanceChangedEvent(
+        PluginAppearanceSnapshot snapshot,
+        IReadOnlyCollection<AppearanceProperty> changedProperties)
+    {
+        ArgumentNullException.ThrowIfNull(snapshot);
+        ArgumentNullException.ThrowIfNull(changedProperties);
+
+        Snapshot = snapshot;
+        ChangedProperties = changedProperties;
+    }
+
+    /// <summary>
+    /// 当前外观快照。
+    /// </summary>
+    public PluginAppearanceSnapshot Snapshot { get; }
+
+    /// <summary>
+    /// 变更的属性集合。
+    /// </summary>
+    public IReadOnlyCollection<AppearanceProperty> ChangedProperties { get; }
+
+    /// <summary>
+    /// 圆角是否发生变化。
+    /// </summary>
+    public bool CornerRadiusChanged => ChangedProperties.Contains(AppearanceProperty.CornerRadius);
+
+    /// <summary>
+    /// 主题变体（亮色/暗色）是否发生变化。
+    /// </summary>
+    public bool ThemeVariantChanged => ChangedProperties.Contains(AppearanceProperty.ThemeVariant);
+
+    /// <summary>
+    /// 强调色是否发生变化。
+    /// </summary>
+    public bool AccentColorChanged => ChangedProperties.Contains(AppearanceProperty.AccentColor);
+
+    /// <summary>
+    /// 圆角风格是否发生变化。
+    /// </summary>
+    public bool CornerRadiusStyleChanged => ChangedProperties.Contains(AppearanceProperty.CornerRadiusStyle);
+
+    /// <summary>
+    /// 检查指定属性是否发生变化。
+    /// </summary>
+    /// <param name="property">要检查的属性</param>
+    /// <returns>如果属性发生变化则返回 true</returns>
+    public bool HasChanged(AppearanceProperty property)
+    {
+        return ChangedProperties.Contains(property);
+    }
+
+    /// <summary>
+    /// 检查是否有任何外观属性发生变化。
+    /// </summary>
+    public bool HasAnyChanges => ChangedProperties.Count > 0;
+}
+
+/// <summary>
+/// 可变更的外观属性枚举。
+/// </summary>
+public enum AppearanceProperty
+{
+    /// <summary>
+    /// 圆角Token值发生变化。
+    /// </summary>
+    CornerRadius,
+
+    /// <summary>
+    /// 主题变体（亮色/暗色）发生变化。
+    /// </summary>
+    ThemeVariant,
+
+    /// <summary>
+    /// 强调色发生变化。
+    /// </summary>
+    AccentColor,
+
+    /// <summary>
+    /// 圆角风格（Sharp/Balanced/Rounded/Open）发生变化。
+    /// </summary>
+    CornerRadiusStyle,
+
+    /// <summary>
+    /// 壁纸发生变化。
+    /// </summary>
+    Wallpaper,
+
+    /// <summary>
+    /// 系统材质模式发生变化。
+    /// </summary>
+    SystemMaterialMode,
+
+    /// <summary>
+    /// 所有外观属性（用于批量更新）。
+    /// </summary>
+    All
+}

LanMountainDesktop.PluginSdk/AssemblyInfo.cs

@@ -0,0 +1,4 @@
+using Avalonia.Metadata;
+
+[assembly: XmlnsPrefix("http://lanmountain.tech/schemas/xaml/sdk", "lmd")]
+[assembly: XmlnsDefinition("http://lanmountain.tech/schemas/xaml/sdk", "LanMountainDesktop.PluginSdk")]

LanMountainDesktop.PluginSdk/IPluginAppearanceContext.cs

@@ -1,10 +1,35 @@
 namespace LanMountainDesktop.PluginSdk;
 
+/// <summary>
+/// 插件外观上下文接口，提供主题、圆角等外观资源的访问和变更通知。
+/// </summary>
 public interface IPluginAppearanceContext
 {
+    /// <summary>
+    /// 当前外观快照。
+    /// </summary>
     PluginAppearanceSnapshot Snapshot { get; }
 
+    /// <summary>
+    /// 外观变更事件。当主题、圆角或其他外观属性发生变化时触发。
+    /// </summary>
+    event EventHandler<AppearanceChangedEvent>? Changed;
+
+    /// <summary>
+    /// 解析带缩放的圆角半径。
+    /// </summary>
+    /// <param name="baseRadius">基础圆角半径</param>
+    /// <param name="minimum">最小值（可选）</param>
+    /// <param name="maximum">最大值（可选）</param>
+    /// <returns>解析后的圆角半径</returns>
     double ResolveScaledCornerRadius(double baseRadius, double? minimum = null, double? maximum = null);
 
+    /// <summary>
+    /// 根据预设解析圆角半径。
+    /// </summary>
+    /// <param name="preset">圆角预设</param>
+    /// <param name="minimum">最小值（可选）</param>
+    /// <param name="maximum">最大值（可选）</param>
+    /// <returns>解析后的圆角半径</returns>
     double ResolveCornerRadius(PluginCornerRadiusPreset preset, double? minimum = null, double? maximum = null);
 }

LanMountainDesktop.PluginSdk/LanMountainDesktop.PluginSdk.csproj

@@ -4,7 +4,7 @@
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <Version>4.0.0</Version>
+    <Version>4.0.2</Version>
     <PackageId>LanMountainDesktop.PluginSdk</PackageId>
     <IsPackable>true</IsPackable>
     <Authors>LanMountainDesktop</Authors>
@@ -20,6 +20,9 @@
   <ItemGroup>
     <Compile Remove="_build_verify_*\**\*.cs" />
     <PackageReference Include="Avalonia" Version="11.3.12" />
+    <PackageReference Include="FluentAvaloniaUI" Version="2.5.0" ExcludeAssets="runtime" />
+    <PackageReference Include="FluentIcons.Avalonia" Version="2.0.320" ExcludeAssets="runtime" />
+    <PackageReference Include="FluentIcons.Avalonia.Fluent" Version="2.0.320" ExcludeAssets="runtime" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="10.0.0" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.0" />
     <ProjectReference Include="..\LanMountainDesktop.Shared.Contracts\LanMountainDesktop.Shared.Contracts.csproj" />

LanMountainDesktop.PluginSdk/PluginAppearanceContext.cs

@@ -1,13 +1,22 @@
 namespace LanMountainDesktop.PluginSdk;
 
+/// <summary>
+/// 插件外观上下文实现，提供主题、圆角等外观资源的访问和变更通知。
+/// </summary>
 public sealed class PluginAppearanceContext : IPluginAppearanceContext
 {
+    private PluginAppearanceSnapshot _snapshot;
+
+    /// <summary>
+    /// 创建插件外观上下文实例。
+    /// </summary>
+    /// <param name="snapshot">初始外观快照</param>
     public PluginAppearanceContext(PluginAppearanceSnapshot snapshot)
     {
         ArgumentNullException.ThrowIfNull(snapshot);
         ArgumentNullException.ThrowIfNull(snapshot.CornerRadiusTokens);
 
-        Snapshot = snapshot with
+        _snapshot = snapshot with
         {
             ThemeVariant = string.IsNullOrWhiteSpace(snapshot.ThemeVariant)
                 ? "Unknown"
@@ -15,8 +24,37 @@ public sealed class PluginAppearanceContext : IPluginAppearanceContext
         };
     }
 
-    public PluginAppearanceSnapshot Snapshot { get; }
+    /// <inheritdoc />
+    public PluginAppearanceSnapshot Snapshot => _snapshot;
 
+    /// <inheritdoc />
+    public event EventHandler<AppearanceChangedEvent>? Changed;
+
+    /// <summary>
+    /// 更新外观快照并触发变更事件。
+    /// 此方法由宿主调用，用于在主题、圆角等外观属性变化时通知插件。
+    /// </summary>
+    /// <param name="newSnapshot">新的外观快照</param>
+    /// <param name="changedProperties">变更的属性集合</param>
+    public void UpdateSnapshot(PluginAppearanceSnapshot newSnapshot, IReadOnlyCollection<AppearanceProperty> changedProperties)
+    {
+        ArgumentNullException.ThrowIfNull(newSnapshot);
+        ArgumentNullException.ThrowIfNull(changedProperties);
+
+        _snapshot = newSnapshot with
+        {
+            ThemeVariant = string.IsNullOrWhiteSpace(newSnapshot.ThemeVariant)
+                ? "Unknown"
+                : newSnapshot.ThemeVariant.Trim()
+        };
+
+        if (changedProperties.Count > 0)
+        {
+            Changed?.Invoke(this, new AppearanceChangedEvent(_snapshot, changedProperties));
+        }
+    }
+
+    /// <inheritdoc />
     public double ResolveScaledCornerRadius(double baseRadius, double? minimum = null, double? maximum = null)
     {
         var value = Math.Max(0d, baseRadius);
@@ -30,16 +68,17 @@ public sealed class PluginAppearanceContext : IPluginAppearanceContext
         return Math.Clamp(value, clampedMin, clampedMax);
     }
 
+    /// <inheritdoc />
     public double ResolveCornerRadius(PluginCornerRadiusPreset preset, double? minimum = null, double? maximum = null)
     {
-        var resolved = Math.Max(0d, Snapshot.CornerRadiusTokens.Get(preset));
+        var resolved = Math.Max(0d, _snapshot.CornerRadiusTokens.Get(preset));
         if (!minimum.HasValue && !maximum.HasValue)
         {
             return resolved;
         }
 
-        var clampedMin = minimum ?? resolved;
-        var clampedMax = maximum ?? resolved;
+        var clampedMin = minimum ?? 0d;
+        var clampedMax = maximum ?? double.MaxValue;
         if (clampedMin > clampedMax)
         {
             (clampedMin, clampedMax) = (clampedMax, clampedMin);

LanMountainDesktop.PluginSdk/PluginAppearanceHelper.cs

@@ -0,0 +1,137 @@
+using Avalonia;
+
+namespace LanMountainDesktop.PluginSdk;
+
+/// <summary>
+/// 插件外观辅助方法，提供统一的圆角和主题资源访问。
+/// </summary>
+public static class PluginAppearanceHelper
+{
+    /// <summary>
+    /// 获取桌面组件主外壳圆角半径。
+    /// 这是组件最外层边框应该使用的圆角值，对应 DesignCornerRadiusComponent 资源。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>主外壳圆角半径（像素）</returns>
+    public static double GetShellCornerRadius(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.ResolveCornerRadius(PluginCornerRadiusPreset.Component);
+    }
+
+    /// <summary>
+    /// 获取内部卡片圆角半径。
+    /// 用于组件内部的次级卡片、内容区块等。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>内部卡片圆角半径（像素）</returns>
+    public static double GetCardCornerRadius(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.ResolveCornerRadius(PluginCornerRadiusPreset.Sm);
+    }
+
+    /// <summary>
+    /// 获取控件圆角半径。
+    /// 用于按钮、输入框、标签等交互控件。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>控件圆角半径（像素）</returns>
+    public static double GetControlCornerRadius(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.ResolveCornerRadius(PluginCornerRadiusPreset.Xs);
+    }
+
+    /// <summary>
+    /// 获取徽章/标签圆角半径。
+    /// 用于小徽章、标签、角标等微元素。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>徽章圆角半径（像素）</returns>
+    public static double GetBadgeCornerRadius(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.ResolveCornerRadius(PluginCornerRadiusPreset.Micro);
+    }
+
+    /// <summary>
+    /// 获取中等面板圆角半径。
+    /// 用于悬浮菜单、小提示框、子面板等。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>中等面板圆角半径（像素）</returns>
+    public static double GetMediumPanelCornerRadius(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.ResolveCornerRadius(PluginCornerRadiusPreset.Md);
+    }
+
+    /// <summary>
+    /// 获取大面板圆角半径。
+    /// 用于对话框、设置面板等大型容器（非桌面组件）。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>大面板圆角半径（像素）</returns>
+    public static double GetLargePanelCornerRadius(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.ResolveCornerRadius(PluginCornerRadiusPreset.Lg);
+    }
+
+    /// <summary>
+    /// 将圆角预设转换为 Avalonia CornerRadius。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <param name="preset">圆角预设</param>
+    /// <returns>Avalonia CornerRadius 结构</returns>
+    public static CornerRadius ToCornerRadius(this IPluginAppearanceContext context, PluginCornerRadiusPreset preset)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        var radius = context.ResolveCornerRadius(preset);
+        return new CornerRadius(radius);
+    }
+
+    /// <summary>
+    /// 获取当前主题变体（亮色/暗色）。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>是否为暗色主题</returns>
+    public static bool IsDarkTheme(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return string.Equals(context.Snapshot.ThemeVariant, "Dark", StringComparison.OrdinalIgnoreCase);
+    }
+
+    /// <summary>
+    /// 获取当前主题变体字符串。
+    /// </summary>
+    /// <param name="context">外观上下文</param>
+    /// <returns>主题变体字符串（"Light" 或 "Dark"）</returns>
+    public static string GetThemeVariant(this IPluginAppearanceContext context)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+        return context.Snapshot.ThemeVariant;
+    }
+}
+
+/// <summary>
+/// 内部元素层级，用于区分不同层级的圆角需求。
+/// </summary>
+public enum InnerElementLevel
+{
+    /// <summary>
+    /// 内部卡片：使用 Sm token（14px @ 1.0x）
+    /// </summary>
+    Card,
+
+    /// <summary>
+    /// 交互控件：使用 Xs token（12px @ 1.0x）
+    /// </summary>
+    Control,
+
+    /// <summary>
+    /// 微元素徽章：使用 Micro token（6px @ 1.0x）
+    /// </summary>
+    Badge
+}

LanMountainDesktop.PluginSdk/PluginDesktopComponentRegistration.cs

@@ -72,14 +72,11 @@ public sealed class PluginDesktopComponentRegistration
         var resolved = CornerRadiusResolver is not null
             ? CornerRadiusResolver(appearance, Math.Max(1d, cellSize))
             : CornerRadiusPreset == PluginCornerRadiusPreset.Default
-                ? appearance.ResolveScaledCornerRadius(
-                    Math.Clamp(Math.Max(1d, cellSize) * 0.22, 8, 18),
-                    8,
-                    18)
+                ? appearance.ResolveCornerRadius(PluginCornerRadiusPreset.Component)
                 : appearance.ResolveCornerRadius(CornerRadiusPreset);
 
         return double.IsFinite(resolved)
             ? Math.Max(0d, resolved)
-            : appearance.ResolveCornerRadius(PluginCornerRadiusPreset.Default);
+            : appearance.ResolveCornerRadius(PluginCornerRadiusPreset.Component);
     }
 }

LanMountainDesktop.PluginSdk/PluginSdkInfo.cs

@@ -2,7 +2,7 @@ namespace LanMountainDesktop.PluginSdk;
 
 public static class PluginSdkInfo
 {
-    public const string ApiVersion = "4.0.0";
+    public const string ApiVersion = "4.0.2";
     public const string ManifestFileName = "plugin.json";
     public const string PackageFileExtension = ".laapp";
     public const string DataDirectoryName = "Data";

LanMountainDesktop.PluginSdk/PluginServiceCollectionExtensions.cs

@@ -28,6 +28,35 @@ public static class PluginServiceCollectionExtensions
         return services;
     }
 
+    /// <summary>
+    /// Registers a plugin settings section with a custom AXAML view.
+    /// The host application will display <typeparamref name="TView"/> directly
+    /// in the settings window, allowing the plugin to use any Fluent Avalonia controls
+    /// and custom layouts — just like built-in settings pages.
+    /// </summary>
+    /// <typeparam name="TView">A <see cref="SettingsPageBase"/> subclass that defines the settings UI using AXAML.</typeparam>
+    public static IServiceCollection AddPluginSettingsSection<TView>(
+        this IServiceCollection services,
+        string id,
+        string titleLocalizationKey,
+        string? descriptionLocalizationKey = null,
+        string iconKey = "PuzzlePiece",
+        int sortOrder = 0)
+        where TView : SettingsPageBase
+    {
+        ArgumentNullException.ThrowIfNull(services);
+
+        var builder = new PluginSettingsSectionBuilder(
+            id,
+            titleLocalizationKey,
+            descriptionLocalizationKey,
+            iconKey,
+            sortOrder);
+        builder.SetCustomView<TView>();
+        services.AddSingleton(builder.Build());
+        return services;
+    }
+
     public static IServiceCollection AddPluginDesktopComponent<TControl>(
         this IServiceCollection services,
         PluginDesktopComponentOptions options)

LanMountainDesktop.PluginSdk/PluginSettingsSectionBuilder.cs

@@ -1,10 +1,13 @@
+using System;
 using System.Collections.Generic;
+using Avalonia.Controls;
 
 namespace LanMountainDesktop.PluginSdk;
 
 public sealed class PluginSettingsSectionBuilder
 {
     private readonly List<SettingsOptionDefinition> _options = [];
+    private Type? _customViewType;
 
     internal PluginSettingsSectionBuilder(
         string id,
@@ -30,8 +33,46 @@ public sealed class PluginSettingsSectionBuilder
 
     public int SortOrder { get; }
 
+    public Type? CustomViewType => _customViewType;
+
     public IReadOnlyList<SettingsOptionDefinition> Options => _options;
 
+    /// <summary>
+    /// Sets a custom AXAML view for this settings section.
+    /// The view type must be a subclass of <see cref="SettingsPageBase"/>.
+    /// When a custom view is provided, the host application will use it directly
+    /// instead of generating a page from the declared options, allowing the plugin
+    /// to use any Fluent Avalonia controls and custom layouts.
+    /// </summary>
+    /// <typeparam name="TView">A <see cref="SettingsPageBase"/> subclass that defines the settings UI.</typeparam>
+    public PluginSettingsSectionBuilder SetCustomView<TView>() where TView : SettingsPageBase
+    {
+        _customViewType = typeof(TView);
+        return this;
+    }
+
+    /// <summary>
+    /// Sets a custom AXAML view for this settings section.
+    /// The view type must be a subclass of <see cref="SettingsPageBase"/>.
+    /// When a custom view is provided, the host application will use it directly
+    /// instead of generating a page from the declared options.
+    /// </summary>
+    /// <param name="viewType">A <see cref="SettingsPageBase"/> subclass type that defines the settings UI.</param>
+    public PluginSettingsSectionBuilder SetCustomView(Type viewType)
+    {
+        ArgumentNullException.ThrowIfNull(viewType);
+
+        if (!typeof(SettingsPageBase).IsAssignableFrom(viewType))
+        {
+            throw new ArgumentException(
+                $"Custom view type must be a subclass of {nameof(SettingsPageBase)}.",
+                nameof(viewType));
+        }
+
+        _customViewType = viewType;
+        return this;
+    }
+
     public PluginSettingsSectionBuilder AddOption(SettingsOptionDefinition option)
     {
         ArgumentNullException.ThrowIfNull(option);
@@ -142,6 +183,7 @@ public sealed class PluginSettingsSectionBuilder
             _options.ToArray(),
             DescriptionLocalizationKey,
             IconKey,
-            SortOrder);
+            SortOrder,
+            _customViewType);
     }
 }

LanMountainDesktop.PluginSdk/PluginSettingsSectionRegistration.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 
 namespace LanMountainDesktop.PluginSdk;
@@ -10,7 +11,8 @@ public sealed class PluginSettingsSectionRegistration
         IReadOnlyList<SettingsOptionDefinition> options,
         string? descriptionLocalizationKey = null,
         string iconKey = "PuzzlePiece",
-        int sortOrder = 0)
+        int sortOrder = 0,
+        Type? customViewType = null)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(id);
         ArgumentException.ThrowIfNullOrWhiteSpace(titleLocalizationKey);
@@ -24,6 +26,15 @@ public sealed class PluginSettingsSectionRegistration
         IconKey = iconKey.Trim();
         SortOrder = sortOrder;
         Options = options ?? [];
+
+        if (customViewType is not null && !typeof(SettingsPageBase).IsAssignableFrom(customViewType))
+        {
+            throw new ArgumentException(
+                $"Custom view type must be a subclass of {nameof(SettingsPageBase)}.",
+                nameof(customViewType));
+        }
+
+        CustomViewType = customViewType;
     }
 
     public string Id { get; }
@@ -37,4 +48,11 @@ public sealed class PluginSettingsSectionRegistration
     public int SortOrder { get; }
 
     public IReadOnlyList<SettingsOptionDefinition> Options { get; }
+
+    /// <summary>
+    /// When set, the host application will instantiate this <see cref="SettingsPageBase"/> subclass
+    /// instead of generating a page from <see cref="Options"/>.
+    /// This allows plugins to provide fully custom AXAML views with any Fluent Avalonia controls.
+    /// </summary>
+    public Type? CustomViewType { get; }
 }

LanMountainDesktop.PluginSdk/README.md

@@ -14,7 +14,7 @@ Official SDK package for LanMountainDesktop plugins.
 
 ```xml
 <ItemGroup>
-  <PackageReference Include="LanMountainDesktop.PluginSdk" Version="4.0.0" />
+  <PackageReference Include="LanMountainDesktop.PluginSdk" Version="4.0.1" />
 </ItemGroup>
 ```
 

LanMountainDesktop.PluginSdk/SettingsPageCategory.cs

@@ -9,5 +9,6 @@ public enum SettingsPageCategory
     PluginCatalog = 35,
     [Obsolete("Use PluginCatalog instead.")]
     PluginMarket = 35,
-    About = 40
+    About = 40,
+    Dev = 50
 }

LanMountainDesktop.PluginTemplate/content/.template.config/template.json

@@ -47,7 +47,7 @@
     "pluginSdkVersion": {
       "type": "parameter",
       "datatype": "text",
-      "defaultValue": "4.0.0",
+      "defaultValue": "4.0.2",
       "description": "LanMountainDesktop.PluginSdk package version.",
       "replaces": "__PLUGIN_SDK_VERSION__"
     }

LanMountainDesktop.PluginTemplate/content/Plugin.cs

@@ -10,6 +10,38 @@ public sealed class Plugin : PluginBase
     public override void Initialize(HostBuilderContext context, IServiceCollection services)
     {
         _ = context;
+
+        // ── Option 1: Declarative settings (simple key-value options) ──────────
+        // The host generates a settings page automatically from the declared options.
+        // Supported option types: Toggle, Text, Number, Select, Path, List.
+        //
+        // services.AddPluginSettingsSection(
+        //     "my-plugin-settings",
+        //     "My Plugin Settings",
+        //     section => section
+        //         .AddToggle("enable_feature", "Enable Feature", defaultValue: true)
+        //         .AddNumber("refresh_interval", "Refresh Interval", defaultValue: 30, minimum: 5, maximum: 120),
+        //     iconKey: "PuzzlePiece");
+
+        // ── Option 2: Custom AXAML view (full Fluent Avalonia controls) ────────
+        // Provide a SettingsPageBase subclass to use any Fluent Avalonia control
+        // (SettingsExpander, ColorPicker, Slider, etc.) — just like built-in pages.
+        //
+        // services.AddPluginSettingsSection<MyCustomSettingsPage>(
+        //     "my-plugin-settings",
+        //     "My Plugin Settings",
+        //     iconKey: "PuzzlePiece");
+        //
+        // Or mix both: declare options AND set a custom view on the builder:
+        //
+        // services.AddPluginSettingsSection(
+        //     "my-plugin-settings",
+        //     "My Plugin Settings",
+        //     section => section
+        //         .SetCustomView<MyCustomSettingsPage>()
+        //         .AddToggle("enable_feature", "Enable Feature"),
+        //     iconKey: "PuzzlePiece");
+
         _ = services;
     }
 }

LanMountainDesktop.PluginTemplate/content/plugin.json

@@ -4,7 +4,7 @@
   "description": "__PLUGIN_DESCRIPTION__",
   "author": "__PLUGIN_AUTHOR__",
   "version": "1.0.0",
-  "apiVersion": "4.0.0",
+  "apiVersion": "4.0.2",
   "entranceAssembly": "LanMountainDesktop.PluginTemplate.dll",
   "sharedContracts": []
 }

LanMountainDesktop.PluginUpgradeHelper/LanMountainDesktop.PluginUpgradeHelper.csproj

@@ -1,14 +1,16 @@
-<Project Sdk="Microsoft.NET.Sdk" TreatAsLocalProperty="Version;PackageVersion;InformationalVersion;AssemblyVersion;FileVersion">
+<Project Sdk="Microsoft.NET.Sdk">
+
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>disable</ImplicitUsings>
     <Nullable>enable</Nullable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Version>1.0.0</Version>
-    <PackageVersion>$(Version)</PackageVersion>
+    <AssemblyName>LanMountainDesktop.PluginUpgradeHelper</AssemblyName>
+    <RootNamespace>LanMountainDesktop.PluginUpgradeHelper</RootNamespace>
   </PropertyGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\LanMountainDesktop.PluginSdk\LanMountainDesktop.PluginSdk.csproj" />
   </ItemGroup>
+
 </Project>

LanMountainDesktop.PluginUpgradeHelper/Program.cs

@@ -0,0 +1,372 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Text;
+using System.Text.Json;
+using System.Threading;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.PluginUpgradeHelper;
+
+internal static class Program
+{
+    private const string PendingUpgradesFileName = ".pending-plugin-upgrades.json";
+    private const string LogFileName = "plugin-upgrade-helper.log";
+
+    private static int Main(string[] args)
+    {
+        var logPath = Path.Combine(Path.GetTempPath(), "LanMountainDesktop", LogFileName);
+        Directory.CreateDirectory(Path.GetDirectoryName(logPath)!);
+        File.AppendAllText(logPath, $"\n[{DateTime.Now:O}] PluginUpgradeHelper started. Args: {string.Join(" ", args)}\n");
+
+        try
+        {
+            var parsedArgs = ParseArgs(args);
+
+            if (!parsedArgs.TryGetValue("plugins-dir", out var pluginsDirectory) ||
+                string.IsNullOrWhiteSpace(pluginsDirectory))
+            {
+                LogError(logPath, "Missing required argument: --plugins-dir");
+                return 1;
+            }
+
+            if (!parsedArgs.TryGetValue("parent-pid", out var parentPidStr) ||
+                !int.TryParse(parentPidStr, out var parentPid))
+            {
+                LogError(logPath, "Missing or invalid argument: --parent-pid");
+                return 1;
+            }
+
+            parsedArgs.TryGetValue("launch", out var launchCommand);
+
+            LogInfo(logPath, $"Waiting for parent process {parentPid} to exit...");
+            WaitForParentProcess(parentPid);
+
+            LogInfo(logPath, $"Processing pending upgrades in '{pluginsDirectory}'...");
+            var upgradeResults = ProcessPendingUpgrades(pluginsDirectory, logPath);
+
+            LogInfo(logPath, $"Upgrades completed. Success: {upgradeResults.SuccessCount}, Failed: {upgradeResults.FailureCount}");
+
+            if (!string.IsNullOrWhiteSpace(launchCommand))
+            {
+                LogInfo(logPath, $"Launching application: {launchCommand}");
+                LaunchApplication(launchCommand, parsedArgs);
+            }
+
+            return upgradeResults.FailureCount > 0 ? 2 : 0;
+        }
+        catch (Exception ex)
+        {
+            LogError(logPath, $"Unexpected error: {ex}");
+            return 1;
+        }
+    }
+
+    private static void WaitForParentProcess(int parentPid)
+    {
+        try
+        {
+            var parentProcess = Process.GetProcessById(parentPid);
+            parentProcess.WaitForExit(TimeSpan.FromSeconds(30));
+        }
+        catch (ArgumentException)
+        {
+            // Process already exited
+        }
+        catch (Exception)
+        {
+            // Ignore errors, continue anyway
+        }
+
+        Thread.Sleep(500);
+    }
+
+    private static UpgradeResults ProcessPendingUpgrades(string pluginsDirectory, string logPath)
+    {
+        var pendingUpgradesPath = Path.Combine(pluginsDirectory, PendingUpgradesFileName);
+        var successCount = 0;
+        var failureCount = 0;
+
+        if (!File.Exists(pendingUpgradesPath))
+        {
+            LogInfo(logPath, "No pending upgrades found.");
+            return new UpgradeResults(0, 0);
+        }
+
+        List<PendingUpgrade>? pendingUpgrades;
+        try
+        {
+            var json = File.ReadAllText(pendingUpgradesPath);
+            pendingUpgrades = JsonSerializer.Deserialize<List<PendingUpgrade>>(json);
+        }
+        catch (Exception ex)
+        {
+            LogError(logPath, $"Failed to read pending upgrades: {ex.Message}");
+            return new UpgradeResults(0, 0);
+        }
+
+        if (pendingUpgrades is null || pendingUpgrades.Count == 0)
+        {
+            LogInfo(logPath, "No pending upgrades to process.");
+            return new UpgradeResults(0, 0);
+        }
+
+        Directory.CreateDirectory(pluginsDirectory);
+        var pendingDeletionDir = Path.Combine(pluginsDirectory, ".pending-deletions");
+        Directory.CreateDirectory(pendingDeletionDir);
+
+        foreach (var upgrade in pendingUpgrades)
+        {
+            if (!upgrade.IsValid())
+            {
+                LogWarn(logPath, $"Skipping invalid upgrade entry for plugin '{upgrade.PluginId}'.");
+                failureCount++;
+                continue;
+            }
+
+            try
+            {
+                LogInfo(logPath, $"Processing upgrade for plugin '{upgrade.PluginId}' to version '{upgrade.TargetVersion}'...");
+
+                var manifest = ReadManifestFromPackage(upgrade.SourcePackagePath);
+                var destinationPath = Path.Combine(pluginsDirectory, BuildInstalledPackageFileName(manifest.Id));
+
+                RemoveExistingPluginPackages(pluginsDirectory, manifest.Id, destinationPath, pendingDeletionDir, logPath);
+
+                File.Copy(upgrade.SourcePackagePath, destinationPath, overwrite: true);
+
+                LogInfo(logPath, $"Successfully upgraded plugin '{upgrade.PluginId}' to '{upgrade.TargetVersion}'.");
+                successCount++;
+            }
+            catch (Exception ex)
+            {
+                LogError(logPath, $"Failed to upgrade plugin '{upgrade.PluginId}': {ex.Message}");
+                failureCount++;
+            }
+        }
+
+        try
+        {
+            File.Delete(pendingUpgradesPath);
+        }
+        catch (Exception ex)
+        {
+            LogWarn(logPath, $"Failed to delete pending upgrades file: {ex.Message}");
+        }
+
+        CleanupPendingDeletions(pendingDeletionDir, logPath);
+
+        return new UpgradeResults(successCount, failureCount);
+    }
+
+    private static void RemoveExistingPluginPackages(
+        string pluginsDirectory,
+        string pluginId,
+        string destinationPath,
+        string pendingDeletionDir,
+        string logPath)
+    {
+        var runtimeRootDirectory = EnsureTrailingSeparator(Path.Combine(Path.GetFullPath(pluginsDirectory), ".runtime"));
+
+        foreach (var existingPackagePath in Directory
+                     .EnumerateFiles(pluginsDirectory, "*.laapp", SearchOption.AllDirectories)
+                     .Select(Path.GetFullPath)
+                     .Where(path => !path.StartsWith(runtimeRootDirectory, StringComparison.OrdinalIgnoreCase)))
+        {
+            try
+            {
+                if (string.Equals(existingPackagePath, Path.GetFullPath(destinationPath), StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                var existingManifest = ReadManifestFromPackage(existingPackagePath);
+                if (!string.Equals(existingManifest.Id, pluginId, StringComparison.OrdinalIgnoreCase))
+                {
+                    continue;
+                }
+
+                TryDeleteOrMoveFile(existingPackagePath, pendingDeletionDir, logPath);
+            }
+            catch
+            {
+                // Ignore unrelated or malformed packages
+            }
+        }
+    }
+
+    private static void TryDeleteOrMoveFile(string filePath, string pendingDeletionDir, string logPath)
+    {
+        try
+        {
+            File.Delete(filePath);
+            LogInfo(logPath, $"Deleted existing package: {filePath}");
+        }
+        catch (IOException)
+        {
+            var fileName = Path.GetFileName(filePath);
+            var pendingPath = Path.Combine(pendingDeletionDir, $"{fileName}.{Guid.NewGuid():N}.pending");
+            try
+            {
+                File.Move(filePath, pendingPath);
+                LogInfo(logPath, $"Moved existing package to pending deletion: {filePath} -> {pendingPath}");
+            }
+            catch (Exception ex)
+            {
+                LogWarn(logPath, $"Failed to move existing package '{filePath}': {ex.Message}");
+            }
+        }
+    }
+
+    private static void CleanupPendingDeletions(string pendingDeletionDir, string logPath)
+    {
+        if (!Directory.Exists(pendingDeletionDir))
+        {
+            return;
+        }
+
+        foreach (var pendingFile in Directory.EnumerateFiles(pendingDeletionDir, "*.pending"))
+        {
+            try
+            {
+                File.Delete(pendingFile);
+            }
+            catch (Exception ex)
+            {
+                LogWarn(logPath, $"Failed to delete pending file '{pendingFile}': {ex.Message}");
+            }
+        }
+
+        try
+        {
+            if (Directory.GetFiles(pendingDeletionDir).Length == 0 &&
+                Directory.GetDirectories(pendingDeletionDir).Length == 0)
+            {
+                Directory.Delete(pendingDeletionDir);
+            }
+        }
+        catch
+        {
+            // Ignore
+        }
+    }
+
+    private static void LaunchApplication(string launchCommand, Dictionary<string, string> args)
+    {
+        try
+        {
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = launchCommand,
+                UseShellExecute = true,
+                WorkingDirectory = args.TryGetValue("working-dir", out var workingDir)
+                    ? workingDir
+                    : AppContext.BaseDirectory
+            };
+
+            if (args.TryGetValue("launch-args", out var launchArgs) && !string.IsNullOrWhiteSpace(launchArgs))
+            {
+                startInfo.Arguments = launchArgs;
+            }
+
+            Process.Start(startInfo);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"[PluginUpgradeHelper] Failed to launch application: {ex}");
+        }
+    }
+
+    private static PluginManifest ReadManifestFromPackage(string packagePath)
+    {
+        using var archive = ZipFile.OpenRead(packagePath);
+        var entries = archive.Entries
+            .Where(entry => string.Equals(entry.Name, "plugin.json", StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+
+        if (entries.Length == 0)
+        {
+            throw new InvalidOperationException($"Plugin package '{packagePath}' does not contain 'plugin.json'.");
+        }
+
+        if (entries.Length > 1)
+        {
+            throw new InvalidOperationException($"Plugin package '{packagePath}' contains multiple 'plugin.json' files.");
+        }
+
+        using var stream = entries[0].Open();
+        return PluginManifest.Load(stream, $"{packagePath}!/{entries[0].FullName}");
+    }
+
+    private static string BuildInstalledPackageFileName(string pluginId)
+    {
+        var invalidChars = Path.GetInvalidFileNameChars();
+        var fileName = new string(pluginId.Select(ch => invalidChars.Contains(ch) ? '_' : ch).ToArray());
+        return fileName + ".laapp";
+    }
+
+    private static string EnsureTrailingSeparator(string path)
+    {
+        return path.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)
+            ? path
+            : path + Path.DirectorySeparatorChar;
+    }
+
+    private static Dictionary<string, string> ParseArgs(string[] args)
+    {
+        var values = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        for (var i = 0; i < args.Length; i++)
+        {
+            var current = args[i];
+            if (!current.StartsWith("--", StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            var key = current[2..];
+            if (string.IsNullOrWhiteSpace(key) || i + 1 >= args.Length)
+            {
+                continue;
+            }
+
+            values[key] = args[++i];
+        }
+
+        return values;
+    }
+
+    private static void LogInfo(string logPath, string message)
+    {
+        File.AppendAllText(logPath, $"[{DateTime.Now:O}] [INFO] {message}\n");
+    }
+
+    private static void LogWarn(string logPath, string message)
+    {
+        File.AppendAllText(logPath, $"[{DateTime.Now:O}] [WARN] {message}\n");
+    }
+
+    private static void LogError(string logPath, string message)
+    {
+        File.AppendAllText(logPath, $"[{DateTime.Now:O}] [ERROR] {message}\n");
+    }
+
+    private sealed record PendingUpgrade(
+        string PluginId,
+        string SourcePackagePath,
+        string TargetVersion,
+        DateTimeOffset CreatedAt)
+    {
+        public bool IsValid()
+        {
+            return !string.IsNullOrWhiteSpace(PluginId) &&
+                   !string.IsNullOrWhiteSpace(SourcePackagePath) &&
+                   !string.IsNullOrWhiteSpace(TargetVersion) &&
+                   File.Exists(SourcePackagePath);
+        }
+    }
+
+    private sealed record UpgradeResults(int SuccessCount, int FailureCount);
+}

LanMountainDesktop.Tests/CornerRadiusStyleTests.cs

@@ -35,10 +35,11 @@ public sealed class CornerRadiusStyleTests
                 Component: 24d),
             ThemeVariant: "Light"));
 
-        // Preset resolution should return fixed values from tokens regardless of any legacy scale
+        // Preset resolution should return fixed values from tokens
         Assert.Equal(20d, context.ResolveCornerRadius(PluginCornerRadiusPreset.Md), 3);
-        Assert.Equal(20d, context.ResolveCornerRadius(PluginCornerRadiusPreset.Md, maximum: 15d), 3);
-        Assert.Equal(20d, context.ResolveScaledCornerRadius(18d), 3);
+        Assert.Equal(15d, context.ResolveCornerRadius(PluginCornerRadiusPreset.Md, maximum: 15d), 3);
+        // ResolveScaledCornerRadius returns baseRadius as-is when no min/max specified
+        Assert.Equal(18d, context.ResolveScaledCornerRadius(18d), 3);
         Assert.Equal(24d, context.ResolveCornerRadius(PluginCornerRadiusPreset.Component), 3);
     }
 
@@ -60,8 +61,12 @@ public sealed class CornerRadiusStyleTests
             96d,
             appearanceContext);
 
-        Assert.Equal(24d, context.ResolveScaledCornerRadius(12d), 3);
-        Assert.Equal(24d, context.ResolveScaledCornerRadius(12d, 8d, 18d), 3);
+        // ResolveScaledCornerRadius returns baseRadius as-is when no min/max specified
+        Assert.Equal(12d, context.ResolveScaledCornerRadius(12d), 3);
+        // When min/max specified, value is clamped
+        Assert.Equal(12d, context.ResolveScaledCornerRadius(12d, 8d, 18d), 3);
+        // Component token access
+        Assert.Equal(24d, context.CornerRadiusTokens.Component, 3);
     }
 
     private sealed class NullServiceProvider : IServiceProvider

LanMountainDesktop.slnx

@@ -7,7 +7,8 @@
   <Project Path="LanMountainDesktop.DesktopHost/LanMountainDesktop.DesktopHost.csproj" />
   <Project Path="LanMountainDesktop.PluginSdk/LanMountainDesktop.PluginSdk.csproj" />
   <Project Path="LanMountainDesktop.PluginTemplate/LanMountainDesktop.PluginTemplate.csproj" />
-  <Project Path="LanMountainDesktop.PluginsInstallHelper/LanMountainDesktop.PluginsInstallHelper.csproj" />
+  <Project Path="LanMountainDesktop.Launcher/LanMountainDesktop.Launcher.csproj" />
+  <Project Path="LanMountainDesktop.PluginUpgradeHelper/LanMountainDesktop.PluginUpgradeHelper.csproj" />
   <Project Path="LanMountainDesktop/LanMountainDesktop.csproj" />
   <Project Path="LanMountainDesktop.Tests/LanMountainDesktop.Tests.csproj" />
 </Solution>

LanMountainDesktop/.github/workflows/windows-ci.yml

@@ -1,217 +0,0 @@
-name: Desktop CI
-
-on:
-  push:
-    branches:
-      - "**"
-    tags:
-      - "v*"
-  pull_request:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Package version override (for example: 1.2.3)"
-        required: false
-        type: string
-
-concurrency:
-  group: desktop-ci-${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: ${{ !startsWith(github.ref, 'refs/tags/v') }}
-
-env:
-  DOTNET_VERSION: "10.0.x"
-  PROJECT_PATH: "LanMountainDesktop.csproj"
-
-jobs:
-  validate:
-    name: Validate Build (Windows)
-    runs-on: windows-latest
-    timeout-minutes: 20
-    permissions:
-      contents: read
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup .NET SDK
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: ${{ env.DOTNET_VERSION }}
-          cache: true
-          cache-dependency-path: |
-            **/*.csproj
-
-      - name: Restore
-        run: dotnet restore .\${{ env.PROJECT_PATH }}
-
-      - name: Build
-        run: dotnet build .\${{ env.PROJECT_PATH }} -c Release --no-restore
-
-      - name: Test (if test projects exist)
-        shell: pwsh
-        run: |
-          $testProjects = @(Get-ChildItem -Path . -Recurse -Filter *.csproj | Where-Object {
-            Select-String -Path $_.FullName -Pattern '<IsTestProject>\s*true\s*</IsTestProject>|Microsoft.NET.Test.Sdk' -Quiet
-          })
-
-          if ($testProjects.Count -eq 0) {
-            Write-Host "No test projects found. Skipping dotnet test."
-            exit 0
-          }
-
-          foreach ($project in $testProjects) {
-            Write-Host "Running tests in $($project.FullName)"
-            dotnet test $project.FullName -c Release --verbosity normal
-          }
-
-  resolve_version:
-    name: Resolve Package Version
-    runs-on: ubuntu-latest
-    if: github.event_name == 'workflow_dispatch' || startsWith(github.ref, 'refs/tags/v')
-    outputs:
-      value: ${{ steps.version.outputs.value }}
-    permissions:
-      contents: read
-    steps:
-      - name: Resolve version
-        id: version
-        shell: pwsh
-        run: |
-          $manualVersion = '${{ github.event.inputs.version }}'
-          if ($manualVersion) {
-            $version = $manualVersion.Trim()
-          } elseif ($env:GITHUB_REF -like "refs/tags/v*") {
-            $version = $env:GITHUB_REF_NAME.Substring(1)
-          } elseif ($env:GITHUB_REF -like "refs/tags/*") {
-            $version = $env:GITHUB_REF_NAME
-          } else {
-            $version = "0.0.$env:GITHUB_RUN_NUMBER"
-          }
-
-          if (-not $version) {
-            throw "Failed to resolve package version."
-          }
-
-          if ($version -notmatch '^\d+\.\d+\.\d+([\-+][0-9A-Za-z\.-]+)?$') {
-            throw "Invalid version format: $version"
-          }
-
-          "value=$version" >> $env:GITHUB_OUTPUT
-          Write-Host "Using package version: $version"
-
-  package:
-    name: Package (${{ matrix.name }})
-    needs:
-      - validate
-      - resolve_version
-    if: github.event_name == 'workflow_dispatch' || startsWith(github.ref, 'refs/tags/v')
-    runs-on: ${{ matrix.runner }}
-    timeout-minutes: 60
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - name: Windows
-            runner: windows-latest
-            rid: win-x64
-            artifact_name: LanMountainDesktop-Setup
-            artifact_path: artifacts/installer/*.exe
-          - name: Linux
-            runner: ubuntu-latest
-            rid: linux-x64
-            artifact_name: LanMountainDesktop-linux-x64
-            artifact_path: artifacts/packages/*linux-x64*.zip
-          - name: macOS
-            runner: macos-latest
-            rid: osx-x64
-            artifact_name: LanMountainDesktop-osx-x64
-            artifact_path: artifacts/packages/*osx-x64*.zip
-    permissions:
-      contents: read
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Setup .NET SDK
-        uses: actions/setup-dotnet@v4
-        with:
-          dotnet-version: ${{ env.DOTNET_VERSION }}
-          cache: true
-          cache-dependency-path: |
-            **/*.csproj
-
-      - name: Install Inno Setup
-        if: matrix.rid == 'win-x64'
-        shell: pwsh
-        run: |
-          if (Get-Command iscc.exe -ErrorAction SilentlyContinue) {
-            Write-Host "Inno Setup is already installed."
-            exit 0
-          }
-
-          if (Get-Command choco -ErrorAction SilentlyContinue) {
-            choco install innosetup --yes --no-progress
-          } elseif (Get-Command winget -ErrorAction SilentlyContinue) {
-            winget install --id JRSoftware.InnoSetup -e --source winget --accept-package-agreements --accept-source-agreements
-          } else {
-            throw "Neither choco nor winget is available to install Inno Setup."
-          }
-
-      - name: Build Package
-        shell: pwsh
-        run: |
-          ./scripts/package.ps1 `
-            -Configuration Release `
-            -RuntimeIdentifier ${{ matrix.rid }} `
-            -Version "${{ needs.resolve_version.outputs.value }}"
-
-      - name: Upload Package Artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: ${{ matrix.artifact_name }}-${{ needs.resolve_version.outputs.value }}
-          path: ${{ matrix.artifact_path }}
-          if-no-files-found: error
-
-      - name: Upload Windows Publish Artifact
-        if: matrix.rid == 'win-x64'
-        uses: actions/upload-artifact@v4
-        with:
-          name: LanMountainDesktop-Publish-win-x64-${{ needs.resolve_version.outputs.value }}
-          path: artifacts/publish/win-x64/**
-          if-no-files-found: error
-
-  publish_release_assets:
-    name: Attach Artifacts to GitHub Release
-    runs-on: ubuntu-latest
-    needs:
-      - package
-      - resolve_version
-    if: startsWith(github.ref, 'refs/tags/v')
-    permissions:
-      contents: write
-    steps:
-      - name: Download Windows Installer Artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: LanMountainDesktop-Setup-${{ needs.resolve_version.outputs.value }}
-          path: release-assets/windows
-
-      - name: Download Linux Package Artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: LanMountainDesktop-linux-x64-${{ needs.resolve_version.outputs.value }}
-          path: release-assets/linux
-
-      - name: Download macOS Package Artifact
-        uses: actions/download-artifact@v4
-        with:
-          name: LanMountainDesktop-osx-x64-${{ needs.resolve_version.outputs.value }}
-          path: release-assets/macos
-
-      - name: Attach Artifacts
-        uses: softprops/action-gh-release@v2
-        with:
-          files: |
-            release-assets/windows/*.exe
-            release-assets/linux/*.zip
-            release-assets/macos/*.zip

LanMountainDesktop/App.axaml.cs

@@ -404,10 +404,7 @@ public partial class App : Application
             _traySettingsMenuItem.Header = L("tray.menu.settings", "Settings");
         }
 
-        if (_trayComponentLibraryMenuItem is not null)
-        {
-            _trayComponentLibraryMenuItem.Header = L("tray.menu.component_library", "Component Library");
-        }
+        RefreshFusedDesktopMenuItemVisibility();
 
         if (_trayRestartMenuItem is not null)
         {
@@ -420,6 +417,30 @@ public partial class App : Application
         }
     }
 
+    private void RefreshFusedDesktopMenuItemVisibility()
+    {
+        if (_trayComponentLibraryMenuItem is null)
+        {
+            return;
+        }
+
+        // 仅在 Windows 上支持融合桌面功能
+        if (!OperatingSystem.IsWindows())
+        {
+            _trayComponentLibraryMenuItem.IsVisible = false;
+            return;
+        }
+
+        // 检查融合桌面功能是否启用
+        var appSnapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+        _trayComponentLibraryMenuItem.IsVisible = appSnapshot.EnableFusedDesktop;
+
+        if (_trayComponentLibraryMenuItem.IsVisible)
+        {
+            _trayComponentLibraryMenuItem.Header = L("tray.menu.component_library", "Component Library");
+        }
+    }
+
     private void DisposeTrayIcon()
     {
         if (_trayIcon is null)
@@ -545,13 +566,14 @@ public partial class App : Application
 
             try
             {
-                // 先隐藏透明覆盖层窗口
                 if (_transparentOverlayWindow is not null && _transparentOverlayWindow.IsVisible)
                 {
                     _transparentOverlayWindow.Hide();
                 }
-                
+
                 var mainWindow = GetOrCreateMainWindow(desktop, source);
+                mainWindow.PrepareEnterAnimation();
+
                 mainWindow.ShowInTaskbar = true;
 
                 if (!mainWindow.IsVisible)
@@ -572,6 +594,12 @@ public partial class App : Application
                 mainWindow.Activate();
                 mainWindow.Topmost = true;
                 mainWindow.Topmost = false;
+
+                Dispatcher.UIThread.Post(() =>
+                {
+                    mainWindow.PlayEnterAnimation();
+                }, DispatcherPriority.Background);
+
                 SetDesktopShellState(DesktopShellState.ForegroundDesktop, $"Restore:{source}");
                 AppLogger.Info(
                     "DesktopShell",
@@ -687,6 +715,16 @@ public partial class App : Application
                 ApplyCurrentCultureFromSettings();
                 RefreshTrayIconContent();
             }
+
+            // 检查融合桌面设置是否变更
+            var fusedDesktopChanged =
+                refreshAll ||
+                changedKeys.Contains(nameof(AppSettingsSnapshot.EnableFusedDesktop), StringComparer.OrdinalIgnoreCase);
+
+            if (fusedDesktopChanged)
+            {
+                RefreshFusedDesktopMenuItemVisibility();
+            }
         }, DispatcherPriority.Background);
     }
 

LanMountainDesktop/ComponentSystem/BuiltInComponentIds.cs

@@ -47,4 +47,5 @@ public static class BuiltInComponentIds
     public const string DesktopFileManager = "DesktopFileManager";
     public const string DesktopNotificationBox = "DesktopNotificationBox";
     public const string DesktopShortcut = "DesktopShortcut";
+    public const string DesktopStickyNote = "DesktopStickyNote";
 }

LanMountainDesktop/ComponentSystem/ComponentRegistry.cs

@@ -327,6 +327,16 @@ public sealed class ComponentRegistry
                 AllowStatusBarPlacement: false,
                 AllowDesktopPlacement: true,
                 ResizeMode: DesktopComponentResizeMode.Free),
+            new DesktopComponentDefinition(
+                BuiltInComponentIds.DesktopStickyNote,
+                "Sticky Note",
+                "Notepad",
+                "Board",
+                MinWidthCells: 2,
+                MinHeightCells: 2,
+                AllowStatusBarPlacement: false,
+                AllowDesktopPlacement: true,
+                ResizeMode: DesktopComponentResizeMode.Free),
             new DesktopComponentDefinition(
                 BuiltInComponentIds.DesktopBrowser,
                 "Browser",

LanMountainDesktop/LanMountainDesktop.csproj

@@ -2,12 +2,12 @@
   <PropertyGroup>
     <OutputType>WinExe</OutputType>
     <TargetFramework>net10.0</TargetFramework>
+    <RollForward>LatestMajor</RollForward>
     <Nullable>enable</Nullable>
     <Version>1.0.0</Version>
     <ApplicationManifest>app.manifest</ApplicationManifest>
     <ApplicationIcon>Assets\logo_nightly.ico</ApplicationIcon>
     <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
-    <SelfContained Condition="'$(RuntimeIdentifier)' != ''">true</SelfContained>
   </PropertyGroup>
 
   <!-- Keep Release defaults compatibility-first for desktop dependencies (WebView/interop/reflection). -->
@@ -36,7 +36,7 @@
     <ProjectReference Include="..\LanMountainDesktop.DesktopComponents.Runtime\LanMountainDesktop.DesktopComponents.Runtime.csproj" />
     <ProjectReference Include="..\LanMountainDesktop.DesktopHost\LanMountainDesktop.DesktopHost.csproj" />
     <ProjectReference Include="..\LanMountainDesktop.PluginSdk\LanMountainDesktop.PluginSdk.csproj" />
-    <ProjectReference Include="..\LanMountainDesktop.PluginsInstallHelper\LanMountainDesktop.PluginsInstallHelper.csproj" ReferenceOutputAssembly="false" />
+    <ProjectReference Include="..\LanMountainDesktop.Launcher\LanMountainDesktop.Launcher.csproj" ReferenceOutputAssembly="false" />
   </ItemGroup>
 
   <ItemGroup>
@@ -76,20 +76,37 @@
     <PackageReference Include="WebView.Avalonia" Version="11.0.0.1" />
     <PackageReference Include="WebView.Avalonia.Desktop" Version="11.0.0.1" />
     <PackageReference Include="YamlDotNet" Version="16.3.0" />
-    <PackageReference Include="Tmds.DBus.Protocol" Version="0.22.0" />
+    <PackageReference Include="Tmds.DBus.Protocol" Version="0.92.0" />
+    <PackageReference Include="log4net" Version="3.3.0" />
   </ItemGroup>
 
-  <Target Name="CopyPluginsInstallHelperToOutput" AfterTargets="Build">
+  <Target Name="CopyLauncherToOutput" AfterTargets="Build">
+    <PropertyGroup>
+      <_LauncherOutputPath>..\LanMountainDesktop.Launcher\bin\$(Configuration)\net10.0\</_LauncherOutputPath>
+    </PropertyGroup>
     <ItemGroup>
-      <PluginsInstallHelperFiles Include="..\LanMountainDesktop.PluginsInstallHelper\bin\$(Configuration)\net10.0\**\*.*" />
+      <LauncherFiles Include="$(_LauncherOutputPath)**\*.*" />
     </ItemGroup>
-    <Copy SourceFiles="@(PluginsInstallHelperFiles)" DestinationFiles="@(PluginsInstallHelperFiles->'$(OutDir)PluginsInstallHelper\%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" />
+    <Copy SourceFiles="@(LauncherFiles)" DestinationFiles="@(LauncherFiles->'$(OutDir)Launcher\%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" Condition="Exists('$(_LauncherOutputPath)')" />
   </Target>
 
-  <Target Name="CopyPluginsInstallHelperToPublish" AfterTargets="Publish" Condition="'$(PublishDir)' != ''">
+  <Target Name="PublishLauncher" BeforeTargets="CopyLauncherToPublish" Condition="'$(PublishDir)' != '' and '$(RuntimeIdentifier)' != ''">
+    <PropertyGroup>
+      <_LauncherPublishPath>..\LanMountainDesktop.Launcher\bin\$(Configuration)\net10.0\$(RuntimeIdentifier)\publish\</_LauncherPublishPath>
+    </PropertyGroup>
+    <MSBuild Projects="..\LanMountainDesktop.Launcher\LanMountainDesktop.Launcher.csproj"
+             Targets="Publish"
+             Properties="Configuration=$(Configuration);RuntimeIdentifier=$(RuntimeIdentifier);SelfContained=$(SelfContained);PublishDir=$(_LauncherPublishPath);PublishSingleFile=false;PublishTrimmed=false;PublishReadyToRun=false;DebugType=none;DebugSymbols=false" />
+  </Target>
+
+  <Target Name="CopyLauncherToPublish" AfterTargets="Publish" Condition="'$(PublishDir)' != ''">
+    <PropertyGroup>
+      <_LauncherPublishSource Condition="'$(RuntimeIdentifier)' != '' and Exists('..\LanMountainDesktop.Launcher\bin\$(Configuration)\net10.0\$(RuntimeIdentifier)\publish\')">..\LanMountainDesktop.Launcher\bin\$(Configuration)\net10.0\$(RuntimeIdentifier)\publish\</_LauncherPublishSource>
+      <_LauncherPublishSource Condition="'$(_LauncherPublishSource)' == ''">..\LanMountainDesktop.Launcher\bin\$(Configuration)\net10.0\</_LauncherPublishSource>
+    </PropertyGroup>
     <ItemGroup>
-      <PluginsInstallHelperPublishFiles Include="..\LanMountainDesktop.PluginsInstallHelper\bin\$(Configuration)\net10.0\**\*.*" />
+      <LauncherPublishFiles Include="$(_LauncherPublishSource)**\*.*" />
     </ItemGroup>
-    <Copy SourceFiles="@(PluginsInstallHelperPublishFiles)" DestinationFiles="@(PluginsInstallHelperPublishFiles->'$(PublishDir)PluginsInstallHelper\%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" />
+    <Copy SourceFiles="@(LauncherPublishFiles)" DestinationFiles="@(LauncherPublishFiles->'$(PublishDir)Launcher\%(RecursiveDir)%(Filename)%(Extension)')" SkipUnchangedFiles="true" Condition="Exists('$(_LauncherPublishSource)')" />
   </Target>
 </Project>

LanMountainDesktop/Localization/en-US.json

@@ -698,6 +698,7 @@
     "component.editor.placement_label": "Placement ID",
     "component.editor.scope_label": "Scope",
     "component.editor.scope_instance": "Instance-scoped editor",
+    "component_category.all":  "All",
     "component_category.clock":  "Clock",
     "component_category.date":  "Calendar",
     "component_category.weather":  "Weather",

LanMountainDesktop/Localization/zh-CN.json

@@ -692,6 +692,7 @@
     "component.editor.placement_label": "实例 ID",
     "component.editor.scope_label": "作用域",
     "component.editor.scope_instance": "实例级编辑器",
+    "component_category.all":  "全部",
     "component_category.clock":  "时钟",
     "component_category.date":  "日历",
     "component_category.weather":  "天气",

LanMountainDesktop/Models/AppSettingsSnapshot.cs

@@ -152,8 +152,16 @@ public sealed class AppSettingsSnapshot
 
     public bool EnableThreeFingerSwipe { get; set; } = false;
 
+    public bool EnableSlideTransition { get; set; } = false;
+
+    public bool EnableFusedDesktop { get; set; } = false;
+
     public List<string> DisabledPluginIds { get; set; } = [];
 
+    public bool IsDevModeEnabled { get; set; }
+
+    public string? DevPluginPath { get; set; }
+
     #region Study Settings
 
     public bool StudyEnabled { get; set; } = true;

LanMountainDesktop/Models/ComponentSettingsSnapshot.cs

@@ -142,6 +142,12 @@ public sealed class ComponentSettingsSnapshot
 
     #endregion
 
+    #region Sticky Note Component Settings (便签组件设置)
+
+    public string StickyNoteContent { get; set; } = string.Empty;
+
+    #endregion
+
     public ComponentSettingsSnapshot Clone()
     {
         var clone = (ComponentSettingsSnapshot)MemberwiseClone();

LanMountainDesktop/Program.cs

@@ -6,6 +6,7 @@ using Avalonia;
 using Avalonia.WebView.Desktop;
 using LanMountainDesktop.DesktopHost;
 using LanMountainDesktop.Models;
+using LanMountainDesktop.Plugins;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Services.Settings;
 
@@ -19,6 +20,7 @@ public sealed class Program
     public static void Main(string[] args)
     {
         AppLogger.Initialize();
+        DevPluginOptions.Parse(args);
         RegisterGlobalExceptionLogging();
         var restartParentProcessId = AppRestartService.TryGetRestartParentProcessId(args);
 

LanMountainDesktop/Properties/launchSettings.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json.schemastore.org/launchsettings.json",
+  "profiles": {
+    "LanMountainDesktop (Direct)": {
+      "commandName": "Project",
+      "commandLineArgs": "",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    },
+    "LanMountainDesktop (via Launcher)": {
+      "commandName": "Executable",
+      "executablePath": "$(SolutionDir)LanMountainDesktop.Launcher\\bin\\$(Configuration)\\net10.0\\LanMountainDesktop.Launcher.exe",
+      "commandLineArgs": "launch",
+      "workingDirectory": "$(SolutionDir)",
+      "environmentVariables": {
+        "DOTNET_ENVIRONMENT": "Development"
+      }
+    }
+  }
+}

LanMountainDesktop/Services/FusedDesktopManagerService.cs

@@ -58,6 +58,14 @@ internal sealed class FusedDesktopManagerService : IFusedDesktopManagerService
     {
         if (!OperatingSystem.IsWindows()) return;
         
+        // 检查融合桌面功能是否启用
+        var appSnapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+        if (!appSnapshot.EnableFusedDesktop)
+        {
+            AppLogger.Info("FusedDesktop", "Fused desktop is disabled. Skipping initialization.");
+            return;
+        }
+        
         EnsureRegistries();
         ReloadWidgets();
     }

LanMountainDesktop/Services/HostApplicationLifecycleService.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using Avalonia;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Threading;
@@ -9,6 +10,8 @@ namespace LanMountainDesktop.Services;
 
 public sealed class HostApplicationLifecycleService : IHostApplicationLifecycle
 {
+    private const string UpgradeHelperExecutableName = "LanMountainDesktop.PluginUpgradeHelper.exe";
+
     public bool TryExit(HostApplicationLifecycleRequest? request = null)
     {
         App? app = null;
@@ -50,28 +53,14 @@ public sealed class HostApplicationLifecycleService : IHostApplicationLifecycle
         App? app = null;
         try
         {
-            var startInfo = AppRestartService.CreateRestartStartInfo();
-            if (startInfo is null)
+            app = Application.Current as App;
+
+            if (HasPendingPluginUpgrades())
             {
-                AppLogger.Warn(
-                    "HostLifecycle",
-                    $"Restart request rejected because restart start info could not be resolved. Source='{request?.Source ?? "Unknown"}'.");
-                return false;
+                return TryRestartWithUpgradeHelper(request);
             }
 
-            Process.Start(startInfo);
-            app = Application.Current as App;
-            app?.PrepareForShutdown(isRestart: true, request?.Source ?? "Unknown");
-            var exitRequest = request is null
-                ? new HostApplicationLifecycleRequest(Reason: "Restart accepted.")
-                : request with
-                {
-                    Reason = string.IsNullOrWhiteSpace(request.Reason)
-                        ? "Restart accepted."
-                        : request.Reason
-                };
-
-            return TryExit(exitRequest);
+            return TryRestartDirectly(request);
         }
         catch (Exception ex)
         {
@@ -80,4 +69,92 @@ public sealed class HostApplicationLifecycleService : IHostApplicationLifecycle
             return false;
         }
     }
+
+    private static bool HasPendingPluginUpgrades()
+    {
+        try
+        {
+            var pluginsDirectory = Path.Combine(
+                Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+                "LanMountainDesktop",
+                "Extensions",
+                "Plugins");
+            var pendingUpgradesPath = Path.Combine(pluginsDirectory, ".pending-plugin-upgrades.json");
+            return File.Exists(pendingUpgradesPath);
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private bool TryRestartWithUpgradeHelper(HostApplicationLifecycleRequest? request)
+    {
+        AppLogger.Info("HostLifecycle", "Detected pending plugin upgrades. Using upgrade helper for restart.");
+
+        var helperPath = ResolveUpgradeHelperPath();
+        if (!File.Exists(helperPath))
+        {
+            AppLogger.Warn("HostLifecycle", $"Upgrade helper not found at '{helperPath}'. Falling back to direct restart.");
+            return TryRestartDirectly(request);
+        }
+
+        var pluginsDirectory = Path.Combine(
+            Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData),
+            "LanMountainDesktop",
+            "Extensions",
+            "Plugins");
+
+        var startInfo = AppRestartService.CreateRestartStartInfo();
+        var launchCommand = startInfo?.FileName ?? Process.GetCurrentProcess().MainModule?.FileName ?? AppContext.BaseDirectory;
+        var launchArgs = startInfo?.Arguments ?? "";
+
+        var helperStartInfo = new ProcessStartInfo
+        {
+            FileName = helperPath,
+            Arguments = $"--plugins-dir \"{pluginsDirectory}\" --parent-pid {Environment.ProcessId} --launch \"{launchCommand}\" --launch-args \"{launchArgs}\" --working-dir \"{AppContext.BaseDirectory}\"",
+            UseShellExecute = true,
+            WorkingDirectory = AppContext.BaseDirectory
+        };
+
+        AppLogger.Info("HostLifecycle", $"Starting upgrade helper: {helperStartInfo.FileName} {helperStartInfo.Arguments}");
+
+        Process.Start(helperStartInfo);
+
+        var app = Application.Current as App;
+        app?.PrepareForShutdown(isRestart: true, request?.Source ?? "Unknown");
+
+        return TryExit(request);
+    }
+
+    private bool TryRestartDirectly(HostApplicationLifecycleRequest? request)
+    {
+        var startInfo = AppRestartService.CreateRestartStartInfo();
+        if (startInfo is null)
+        {
+            AppLogger.Warn(
+                "HostLifecycle",
+                $"Restart request rejected because restart start info could not be resolved. Source='{request?.Source ?? "Unknown"}'.");
+            return false;
+        }
+
+        Process.Start(startInfo);
+        var app = Application.Current as App;
+        app?.PrepareForShutdown(isRestart: true, request?.Source ?? "Unknown");
+        var exitRequest = request is null
+            ? new HostApplicationLifecycleRequest(Reason: "Restart accepted.")
+            : request with
+            {
+                Reason = string.IsNullOrWhiteSpace(request.Reason)
+                    ? "Restart accepted."
+                    : request.Reason
+            };
+
+        return TryExit(exitRequest);
+    }
+
+    private static string ResolveUpgradeHelperPath()
+    {
+        return Path.Combine(AppContext.BaseDirectory, "PluginUpgradeHelper", UpgradeHelperExecutableName);
+    }
 }

LanMountainDesktop/Services/LauncherClient.cs

@@ -10,12 +10,12 @@ using System.Threading.Tasks;
 
 namespace LanMountainDesktop.Services;
 
-internal sealed class PluginsInstallHelperClient
+internal sealed class LauncherClient
 {
     private const int UserCanceledUacErrorCode = 1223;
-    private const string HelperExecutableName = "LanMountainDesktop.PluginsInstallHelper.exe";
+    private const string LauncherExecutableName = "LanMountainDesktop.Launcher.exe";
 
-    public async Task<PluginsInstallHelperResult> InstallPackageAsync(
+    public async Task<LauncherInstallResult> InstallPackageAsync(
         string packagePath,
         string pluginsDirectory,
         CancellationToken cancellationToken = default)
@@ -25,19 +25,19 @@ internal sealed class PluginsInstallHelperClient
 
         if (!OperatingSystem.IsWindows())
         {
-            return new PluginsInstallHelperResult(
+            return new LauncherInstallResult(
                 false,
                 null,
                 "Elevated helper install is only supported on Windows.");
         }
 
-        var helperPath = ResolveHelperPath();
-        if (!File.Exists(helperPath))
+        var launcherPath = ResolveLauncherPath();
+        if (!File.Exists(launcherPath))
         {
-            return new PluginsInstallHelperResult(
+            return new LauncherInstallResult(
                 false,
                 null,
-                $"Plugins install helper was not found at '{helperPath}'.");
+                $"Launcher executable was not found at '{launcherPath}'.");
         }
 
         var resultPath = Path.Combine(
@@ -50,38 +50,38 @@ internal sealed class PluginsInstallHelperClient
 
         try
         {
-            using var process = StartHelperProcess(helperPath, packagePath, pluginsDirectory, resultPath);
+            using var process = StartLauncherProcess(launcherPath, packagePath, pluginsDirectory, resultPath);
             if (process is null)
             {
-                return new PluginsInstallHelperResult(false, null, "Failed to start plugins install helper.");
+                return new LauncherInstallResult(false, null, "Failed to start launcher process.");
             }
 
             await process.WaitForExitAsync(cancellationToken);
             var result = await ReadResultAsync(resultPath, cancellationToken);
             if (result is not null)
             {
-                return new PluginsInstallHelperResult(result.Success, result.InstalledPackagePath, result.ErrorMessage);
+                return new LauncherInstallResult(result.Success, result.InstalledPackagePath, result.ErrorMessage);
             }
 
             if (process.ExitCode == 0)
             {
-                return new PluginsInstallHelperResult(
+                return new LauncherInstallResult(
                     false,
                     null,
-                    "Plugins install helper exited without producing a result file.");
+                    "Launcher exited without producing a result file.");
             }
 
-            return new PluginsInstallHelperResult(
+            return new LauncherInstallResult(
                 false,
                 null,
                 string.Format(
                     CultureInfo.InvariantCulture,
-                    "Plugins install helper exited with code {0}.",
+                    "Launcher exited with code {0}.",
                     process.ExitCode));
         }
         catch (Win32Exception ex) when (ex.NativeErrorCode == UserCanceledUacErrorCode)
         {
-            return new PluginsInstallHelperResult(false, null, "Administrator permission request was canceled.");
+            return new LauncherInstallResult(false, null, "Administrator permission request was canceled.");
         }
         finally
         {
@@ -89,18 +89,18 @@ internal sealed class PluginsInstallHelperClient
         }
     }
 
-    private static Process? StartHelperProcess(
-        string helperPath,
+    private static Process? StartLauncherProcess(
+        string launcherPath,
         string packagePath,
         string pluginsDirectory,
         string resultPath)
     {
         var startInfo = new ProcessStartInfo
         {
-            FileName = helperPath,
+            FileName = launcherPath,
             Verb = "runas",
             UseShellExecute = true,
-            WorkingDirectory = Path.GetDirectoryName(helperPath) ?? AppContext.BaseDirectory,
+            WorkingDirectory = Path.GetDirectoryName(launcherPath) ?? AppContext.BaseDirectory,
             Arguments = string.Create(
                 CultureInfo.InvariantCulture,
                 $"--source {QuoteArgument(Path.GetFullPath(packagePath))} --plugins-dir {QuoteArgument(Path.GetFullPath(pluginsDirectory))} --result {QuoteArgument(Path.GetFullPath(resultPath))}")
@@ -120,9 +120,9 @@ internal sealed class PluginsInstallHelperClient
         return await JsonSerializer.DeserializeAsync<HelperResultFile>(stream, cancellationToken: cancellationToken);
     }
 
-    private static string ResolveHelperPath()
+    private static string ResolveLauncherPath()
     {
-        return Path.Combine(AppContext.BaseDirectory, "PluginsInstallHelper", HelperExecutableName);
+        return Path.Combine(AppContext.BaseDirectory, "Launcher", LauncherExecutableName);
     }
 
     private static string QuoteArgument(string value)
@@ -180,7 +180,7 @@ internal sealed class PluginsInstallHelperClient
     }
 }
 
-internal sealed record PluginsInstallHelperResult(
+internal sealed record LauncherInstallResult(
     bool Success,
     string? InstalledPackagePath,
     string? ErrorMessage);

LanMountainDesktop/Services/PendingPluginUpgradeService.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+
+namespace LanMountainDesktop.Services;
+
+public sealed class PendingPluginUpgradeService
+{
+    private const string PendingUpgradesFileName = ".pending-plugin-upgrades.json";
+    private static readonly Lock Gate = new();
+    private readonly string _pendingUpgradesFilePath;
+
+    public PendingPluginUpgradeService(string pluginsDirectory)
+    {
+        _pendingUpgradesFilePath = Path.Combine(pluginsDirectory, PendingUpgradesFileName);
+    }
+
+    public IReadOnlyList<PendingPluginUpgrade> GetPendingUpgrades()
+    {
+        lock (Gate)
+        {
+            return ReadPendingUpgradesCore();
+        }
+    }
+
+    public void AddPendingUpgrade(string pluginId, string sourcePackagePath, string targetVersion)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(pluginId);
+        ArgumentException.ThrowIfNullOrWhiteSpace(sourcePackagePath);
+        ArgumentException.ThrowIfNullOrWhiteSpace(targetVersion);
+
+        lock (Gate)
+        {
+            var upgrades = ReadPendingUpgradesCore().ToList();
+
+            upgrades.RemoveAll(u =>
+                string.Equals(u.PluginId, pluginId, StringComparison.OrdinalIgnoreCase));
+
+            upgrades.Add(new PendingPluginUpgrade(
+                pluginId,
+                Path.GetFullPath(sourcePackagePath),
+                targetVersion,
+                DateTimeOffset.UtcNow));
+
+            SavePendingUpgradesCore(upgrades);
+
+            AppLogger.Info(
+                "PendingPluginUpgrade",
+                $"Added pending upgrade. PluginId='{pluginId}'; TargetVersion='{targetVersion}'; SourcePath='{sourcePackagePath}'.");
+        }
+    }
+
+    public void RemovePendingUpgrade(string pluginId)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(pluginId);
+
+        lock (Gate)
+        {
+            var upgrades = ReadPendingUpgradesCore().ToList();
+            var removed = upgrades.RemoveAll(u =>
+                string.Equals(u.PluginId, pluginId, StringComparison.OrdinalIgnoreCase));
+
+            if (removed > 0)
+            {
+                SavePendingUpgradesCore(upgrades);
+                AppLogger.Info(
+                    "PendingPluginUpgrade",
+                    $"Removed pending upgrade. PluginId='{pluginId}'.");
+            }
+        }
+    }
+
+    public void ClearPendingUpgrades()
+    {
+        lock (Gate)
+        {
+            if (File.Exists(_pendingUpgradesFilePath))
+            {
+                File.Delete(_pendingUpgradesFilePath);
+                AppLogger.Info("PendingPluginUpgrade", "Cleared all pending upgrades.");
+            }
+        }
+    }
+
+    public bool HasPendingUpgrades()
+    {
+        lock (Gate)
+        {
+            return ReadPendingUpgradesCore().Count > 0;
+        }
+    }
+
+    private List<PendingPluginUpgrade> ReadPendingUpgradesCore()
+    {
+        if (!File.Exists(_pendingUpgradesFilePath))
+        {
+            return [];
+        }
+
+        try
+        {
+            var json = File.ReadAllText(_pendingUpgradesFilePath);
+            var upgrades = JsonSerializer.Deserialize<List<PendingPluginUpgrade>>(json);
+            return upgrades?.Where(u => u.IsValid()).ToList() ?? [];
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Warn(
+                "PendingPluginUpgrade",
+                $"Failed to read pending upgrades from '{_pendingUpgradesFilePath}'.",
+                ex);
+            return [];
+        }
+    }
+
+    private void SavePendingUpgradesCore(List<PendingPluginUpgrade> upgrades)
+    {
+        try
+        {
+            var directory = Path.GetDirectoryName(_pendingUpgradesFilePath);
+            if (!string.IsNullOrWhiteSpace(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            var json = JsonSerializer.Serialize(upgrades, new JsonSerializerOptions
+            {
+                WriteIndented = true
+            });
+
+            File.WriteAllText(_pendingUpgradesFilePath, json);
+        }
+        catch (Exception ex)
+        {
+            AppLogger.Error(
+                "PendingPluginUpgrade",
+                $"Failed to save pending upgrades to '{_pendingUpgradesFilePath}'.",
+                ex);
+            throw;
+        }
+    }
+}
+
+public sealed record PendingPluginUpgrade(
+    string PluginId,
+    string SourcePackagePath,
+    string TargetVersion,
+    DateTimeOffset CreatedAt)
+{
+    public bool IsValid()
+    {
+        return !string.IsNullOrWhiteSpace(PluginId) &&
+               !string.IsNullOrWhiteSpace(SourcePackagePath) &&
+               !string.IsNullOrWhiteSpace(TargetVersion) &&
+               File.Exists(SourcePackagePath);
+    }
+}

LanMountainDesktop/Services/PostHogUsageTelemetryService.cs

@@ -1,29 +1,23 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Net.Http;
-using System.Text;
-using System.Text.Json;
 using System.Threading;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.PluginSdk;
 using LanMountainDesktop.Services.Settings;
+using PostHog;
 
 namespace LanMountainDesktop.Services;
 
 public sealed class PostHogUsageTelemetryService : IDisposable
 {
     private const string PostHogApiKey = "phc_bhQZvKDDfsEdLT6kkRFvrWMT8Pc5aCGGsnxoc5ijSf9";
-    private const string PostHogHost = "https://us.i.posthog.com/capture/";
+    private const string PostHogHostUrl = "https://us.i.posthog.com";
 
     private readonly ISettingsFacadeService _settingsFacade;
     private readonly ISettingsService _settingsService;
-    private readonly HttpClient _httpClient = new()
-    {
-        Timeout = TimeSpan.FromSeconds(10)
-    };
-    private readonly Queue<TelemetryEvent> _eventQueue = new();
-    private readonly object _queueLock = new();
+    private readonly PostHogClient _client;
+    private readonly CancellationTokenSource _cts = new();
 
     private Timer? _flushTimer;
     private bool _isInitialized;
@@ -39,6 +33,14 @@ public sealed class PostHogUsageTelemetryService : IDisposable
         _settingsFacade = settingsFacade ?? throw new ArgumentNullException(nameof(settingsFacade));
         _settingsService = settingsFacade.Settings;
         _settingsService.Changed += OnSettingsChanged;
+
+        _client = new PostHogClient(new PostHogOptions
+        {
+            ProjectApiKey = PostHogApiKey,
+            HostUrl = new Uri(PostHogHostUrl),
+            FlushAt = 20,
+            FlushInterval = TimeSpan.FromSeconds(30)
+        });
     }
 
     public bool IsUsageEnabled => _isUsageEnabled;
@@ -56,7 +58,7 @@ public sealed class PostHogUsageTelemetryService : IDisposable
         RefreshEnabledState(forceSessionStart: true);
 
         _flushTimer = new Timer(
-            _ => FlushEvents(),
+            _ => _ = _client.FlushAsync(),
             null,
             TimeSpan.FromSeconds(10),
             TimeSpan.FromSeconds(30));
@@ -88,14 +90,12 @@ public sealed class PostHogUsageTelemetryService : IDisposable
                 return;
             }
 
-            ClearQueuedEvents();
             StopSessionWithoutSending();
         }
         catch (Exception ex)
         {
             AppLogger.Warn("PostHogUsage", "Failed to refresh usage analytics enabled state.", ex);
             _isUsageEnabled = false;
-            ClearQueuedEvents();
             StopSessionWithoutSending();
         }
     }
@@ -278,7 +278,7 @@ public sealed class PostHogUsageTelemetryService : IDisposable
             EndSession(source, isRestart);
         }
 
-        FlushEvents();
+        _ = _client.FlushAsync();
         AppLogger.Info(
             "PostHogUsage",
             $"Usage telemetry shutdown complete. Source='{source}'; Restart='{isRestart}'; Enabled={_isUsageEnabled}.");
@@ -291,16 +291,13 @@ public sealed class PostHogUsageTelemetryService : IDisposable
             _flushTimer?.Dispose();
             _settingsService.Changed -= OnSettingsChanged;
             Shutdown(isRestart: false, source: "Dispose");
-            FlushEvents();
+            _cts.Cancel();
+            _client.Dispose();
         }
         catch (Exception ex)
         {
             AppLogger.Warn("PostHogUsage", "Error disposing usage telemetry service.", ex);
         }
-        finally
-        {
-            _httpClient.Dispose();
-        }
     }
 
     private void EnsureBaselineEventSent()
@@ -313,66 +310,35 @@ public sealed class PostHogUsageTelemetryService : IDisposable
                 return;
             }
 
-            var now = DateTimeOffset.UtcNow;
-            if (SendBaselineEventToPostHog(identity.InstallId, now))
+            var distinctId = identity.InstallId;
+            var personProps = new Dictionary<string, object?>
             {
-                identity.MarkBaselineReported();
-            }
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Warn("PostHogUsage", "Failed to send baseline launch event.", ex);
-        }
-    }
-
-    private bool SendBaselineEventToPostHog(string installId, DateTimeOffset timestamp)
-    {
-        try
-        {
-            var requestBody = new Dictionary<string, object?>
-            {
-                ["api_key"] = PostHogApiKey,
-                ["event"] = "app_first_launch",
-                ["distinct_id"] = installId,
-                ["timestamp"] = timestamp.ToString("o"),
-                ["properties"] = new Dictionary<string, object?>
-                {
-                    ["install_id"] = installId,
-                    ["app_version"] = TelemetryEnvironmentInfo.GetAppVersion(),
-                    ["os_name"] = TelemetryEnvironmentInfo.GetOsName(),
-                    ["os_version"] = TelemetryEnvironmentInfo.GetOsVersion(),
-                    ["device_model"] = TelemetryEnvironmentInfo.GetDeviceModel(),
-                    ["device_arch"] = TelemetryEnvironmentInfo.GetDeviceArchitecture(),
-                    ["runtime_version"] = TelemetryEnvironmentInfo.GetRuntimeVersion(),
-                    ["language"] = TelemetryEnvironmentInfo.GetSystemLanguage(),
-                    ["launch_time_utc"] = timestamp.ToString("o")
-                }
+                ["install_id"] = identity.InstallId,
+                ["app_version"] = TelemetryEnvironmentInfo.GetAppVersion(),
+                ["os_name"] = TelemetryEnvironmentInfo.GetOsName(),
+                ["os_version"] = TelemetryEnvironmentInfo.GetOsVersion(),
+                ["device_model"] = TelemetryEnvironmentInfo.GetDeviceModel(),
+                ["device_arch"] = TelemetryEnvironmentInfo.GetDeviceArchitecture(),
+                ["runtime_version"] = TelemetryEnvironmentInfo.GetRuntimeVersion(),
+                ["language"] = TelemetryEnvironmentInfo.GetSystemLanguage()
             };
 
-            var json = JsonSerializer.Serialize(requestBody);
-            var bytes = Encoding.UTF8.GetBytes(json);
+            _ = _client.IdentifyAsync(distinctId, personProps, null, _cts.Token);
 
-            using var content = new ByteArrayContent(bytes);
-            content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
+            _client.Capture(
+                distinctId,
+                "app_first_launch",
+                personProps,
+                groups: null,
+                sendFeatureFlags: false);
 
-            var response = _httpClient.PostAsync(PostHogHost, content).GetAwaiter().GetResult();
-            var responseBody = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
-
-            if (!response.IsSuccessStatusCode)
-            {
-                AppLogger.Warn(
-                    "PostHogUsage",
-                    $"PostHog baseline event failed: {response.StatusCode} - {responseBody}");
-                return false;
-            }
-
-            AppLogger.Info("PostHogUsage", "Sent first-launch baseline event.");
-            return true;
+            _ = _client.FlushAsync();
+            identity.MarkBaselineReported();
+            AppLogger.Info("PostHogUsage", "Sent first-launch baseline event via SDK.");
         }
         catch (Exception ex)
         {
             AppLogger.Warn("PostHogUsage", "Failed to send baseline launch event.", ex);
-            return false;
         }
     }
 
@@ -479,137 +445,60 @@ public sealed class PostHogUsageTelemetryService : IDisposable
             return;
         }
 
-        var eventData = new TelemetryEvent(
-            eventName,
-            TelemetryIdentityService.Instance.TelemetryId,
-            TelemetryIdentityService.Instance.InstallId,
-            TelemetryIdentityService.Instance.TelemetryId,
-            _sessionId,
-            Interlocked.Increment(ref _sequence),
-            DateTimeOffset.UtcNow,
-            payload ?? new Dictionary<string, object?>(),
-            stateBefore,
-            stateAfter);
+        var identity = TelemetryIdentityService.Instance;
+        var distinctId = identity.TelemetryId;
+        var seq = Interlocked.Increment(ref _sequence);
 
-        lock (_queueLock)
+        var properties = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
         {
-            _eventQueue.Enqueue(eventData);
+            ["install_id"] = identity.InstallId,
+            ["telemetry_id"] = identity.TelemetryId,
+            ["session_id"] = _sessionId,
+            ["sequence"] = seq,
+            ["timestamp_utc"] = DateTimeOffset.UtcNow.ToString("o"),
+            ["app_version"] = TelemetryEnvironmentInfo.GetAppVersion(),
+            ["os_name"] = TelemetryEnvironmentInfo.GetOsName(),
+            ["os_version"] = TelemetryEnvironmentInfo.GetOsVersion(),
+            ["device_model"] = TelemetryEnvironmentInfo.GetDeviceModel(),
+            ["device_arch"] = TelemetryEnvironmentInfo.GetDeviceArchitecture(),
+            ["runtime_version"] = TelemetryEnvironmentInfo.GetRuntimeVersion(),
+            ["language"] = TelemetryEnvironmentInfo.GetSystemLanguage()
+        };
+
+        if (payload is not null)
+        {
+            foreach (var kvp in payload)
+            {
+                properties[$"payload_{kvp.Key}"] = kvp.Value;
+            }
         }
 
+        if (stateBefore is not null && stateBefore.Count > 0)
+        {
+            foreach (var kvp in stateBefore)
+            {
+                properties[$"state_before_{kvp.Key}"] = kvp.Value;
+            }
+        }
+
+        if (stateAfter is not null && stateAfter.Count > 0)
+        {
+            foreach (var kvp in stateAfter)
+            {
+                properties[$"state_after_{kvp.Key}"] = kvp.Value;
+            }
+        }
+
+        _client.Capture(
+            distinctId,
+            eventName,
+            properties,
+            groups: null,
+            sendFeatureFlags: false);
+
         if (forceFlush)
         {
-            FlushEvents();
-            return;
-        }
-
-        var shouldFlush = false;
-        lock (_queueLock)
-        {
-            shouldFlush = _eventQueue.Count >= 20;
-        }
-
-        if (shouldFlush)
-        {
-            FlushEvents();
-        }
-    }
-
-    private void FlushEvents()
-    {
-        List<TelemetryEvent> eventsToSend;
-
-        lock (_queueLock)
-        {
-            if (_eventQueue.Count == 0)
-            {
-                return;
-            }
-
-            eventsToSend = new List<TelemetryEvent>();
-            while (_eventQueue.Count > 0 && eventsToSend.Count < 20)
-            {
-                eventsToSend.Add(_eventQueue.Dequeue());
-            }
-        }
-
-        try
-        {
-            foreach (var telemetryEvent in eventsToSend)
-            {
-                if (!SendEventToPostHog(telemetryEvent, flushImmediately: false))
-                {
-                    throw new InvalidOperationException($"Failed to send PostHog event '{telemetryEvent.EventName}'.");
-                }
-            }
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Warn("PostHogUsage", "Failed to send queued events to PostHog.", ex);
-
-            lock (_queueLock)
-            {
-                foreach (var evt in eventsToSend)
-                {
-                    if (_eventQueue.Count >= 100)
-                    {
-                        break;
-                    }
-
-                    _eventQueue.Enqueue(evt);
-                }
-            }
-        }
-    }
-
-    private bool SendEventToPostHog(TelemetryEvent telemetryEvent, bool flushImmediately)
-    {
-        try
-        {
-            var requestBody = new Dictionary<string, object?>
-            {
-                ["api_key"] = PostHogApiKey,
-                ["event"] = telemetryEvent.EventName,
-                ["distinct_id"] = telemetryEvent.DistinctId,
-                ["timestamp"] = telemetryEvent.Timestamp.ToString("o"),
-                ["properties"] = telemetryEvent.ToPostHogProperties()
-            };
-
-            var json = JsonSerializer.Serialize(requestBody);
-            var bytes = Encoding.UTF8.GetBytes(json);
-
-            using var content = new ByteArrayContent(bytes);
-            content.Headers.ContentType = new System.Net.Http.Headers.MediaTypeHeaderValue("application/json");
-
-            var response = _httpClient.PostAsync(PostHogHost, content).GetAwaiter().GetResult();
-            var responseBody = response.Content.ReadAsStringAsync().GetAwaiter().GetResult();
-
-            if (!response.IsSuccessStatusCode)
-            {
-                AppLogger.Warn(
-                    "PostHogUsage",
-                    $"PostHog event '{telemetryEvent.EventName}' failed: {response.StatusCode} - {responseBody}");
-                return false;
-            }
-
-            if (flushImmediately)
-            {
-                AppLogger.Info("PostHogUsage", $"Sent event '{telemetryEvent.EventName}' immediately.");
-            }
-
-            return true;
-        }
-        catch (Exception ex)
-        {
-            AppLogger.Warn("PostHogUsage", $"Failed to send PostHog event '{telemetryEvent.EventName}'.", ex);
-            return false;
-        }
-    }
-
-    private void ClearQueuedEvents()
-    {
-        lock (_queueLock)
-        {
-            _eventQueue.Clear();
+            _ = _client.FlushAsync();
         }
     }
 

LanMountainDesktop/Services/Settings/SettingsPageRegistry.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using Avalonia.Controls;
+using LanMountainDesktop.Models;
 using LanMountainDesktop.PluginSdk;
 using LanMountainDesktop.Plugins;
 using LanMountainDesktop.Services.PluginMarket;
@@ -204,6 +205,10 @@ internal sealed class SettingsPageRegistry : ISettingsPageRegistry, IDisposable
         string? pluginId,
         bool isBuiltIn)
     {
+        var isDevModeEnabled = _settingsFacade.Settings
+            .LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App)
+            .IsDevModeEnabled;
+
         foreach (var pageType in assembly.GetTypes()
                      .Where(type => !type.IsAbstract && typeof(SettingsPageBase).IsAssignableFrom(type)))
         {
@@ -214,6 +219,12 @@ internal sealed class SettingsPageRegistry : ISettingsPageRegistry, IDisposable
             }
 
             var category = isBuiltIn ? pageInfo.Category : SettingsPageCategory.Plugins;
+
+            if (category == SettingsPageCategory.Dev && !isDevModeEnabled)
+            {
+                continue;
+            }
+
             var sortOrder = isBuiltIn ? pageInfo.SortOrder : 100 + pageInfo.SortOrder;
             var title = ResolveLocalizedText(pageInfo.TitleLocalizationKey, pageInfo.Name);
             var description = ResolveLocalizedText(pageInfo.DescriptionLocalizationKey, null);
@@ -256,6 +267,29 @@ internal sealed class SettingsPageRegistry : ISettingsPageRegistry, IDisposable
                 ? null
                 : localizer.GetString(section.DescriptionLocalizationKey, section.DescriptionLocalizationKey);
 
+            Func<ISettingsPageHostContext, Control> factory;
+
+            if (section.CustomViewType is not null)
+            {
+                var customViewType = section.CustomViewType;
+                var pluginServices = loadedPlugin.Services;
+                factory = hostContext => CreatePage(pluginServices, customViewType, hostContext);
+            }
+            else
+            {
+                factory = hostContext =>
+                {
+                    var page = new GeneratedPluginSettingsPage(
+                        new PluginGeneratedSettingsPageViewModel(
+                            _settingsFacade.Settings,
+                            loadedPlugin.Manifest.Id,
+                            section,
+                            localizer));
+                    page.InitializeHostContext(hostContext);
+                    return page;
+                };
+            }
+
             _pages.Add(new SettingsPageDescriptor(
                 pageId,
                 title,
@@ -270,17 +304,7 @@ internal sealed class SettingsPageRegistry : ISettingsPageRegistry, IDisposable
                 hidePageTitle: false,
                 useFullWidth: false,
                 groupId: null,
-                hostContext =>
-                {
-                    var page = new GeneratedPluginSettingsPage(
-                        new PluginGeneratedSettingsPageViewModel(
-                            _settingsFacade.Settings,
-                            loadedPlugin.Manifest.Id,
-                            section,
-                            localizer));
-                    page.InitializeHostContext(hostContext);
-                    return page;
-                }));
+                factory));
         }
     }
 

LanMountainDesktop/Services/Settings/SettingsWindowService.cs

@@ -72,6 +72,7 @@ internal sealed class SettingsWindowService : ISettingsWindowService
         _localizationService = new();
         _settingsFacade.Settings.Changed += OnSettingsChanged;
         _appearanceThemeService.Changed += OnAppearanceThemeChanged;
+        AppSettingsService.SettingsSaved += OnAppSettingsSaved;
     }
 
     private string L(string key)
@@ -279,6 +280,7 @@ internal sealed class SettingsWindowService : ISettingsWindowService
             var changedKeys = e.ChangedKeys?.ToArray();
             var refreshAll = changedKeys is null || changedKeys.Length == 0;
             var languageChanged = refreshAll || changedKeys.Contains(nameof(AppSettingsSnapshot.LanguageCode), StringComparer.OrdinalIgnoreCase);
+            var devModeChanged = refreshAll || changedKeys.Contains(nameof(AppSettingsSnapshot.IsDevModeEnabled), StringComparer.OrdinalIgnoreCase);
             var liveAppearance = _appearanceThemeService.GetCurrent();
             var themeChanged =
                 refreshAll ||
@@ -291,14 +293,13 @@ internal sealed class SettingsWindowService : ISettingsWindowService
                   changedKeys.Contains(nameof(AppSettingsSnapshot.WallpaperColor), StringComparer.OrdinalIgnoreCase))) ||
                 changedKeys.Contains(nameof(AppSettingsSnapshot.UseSystemChrome), StringComparer.OrdinalIgnoreCase);
 
-            if (languageChanged)
+            if (languageChanged || devModeChanged)
             {
                 var regionState = _settingsFacade.Region.Get();
-                // 清除本地化缓存，强制重新加载语言文件
                 _localizationService.ClearCache();
                 _viewModel.RefreshLanguage(regionState.LanguageCode);
                 _pageRegistry.Rebuild();
-                _window.ReloadPages(_viewModel.CurrentPageId);
+                _window.ReloadPages(devModeChanged ? "dev" : _viewModel.CurrentPageId);
                 _window.RefreshShellText();
             }
 
@@ -311,6 +312,31 @@ internal sealed class SettingsWindowService : ISettingsWindowService
         }, DispatcherPriority.Background);
     }
 
+    private void OnAppSettingsSaved(string instanceId)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            if (_window is null || _viewModel is null)
+            {
+                return;
+            }
+
+            var snapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+            var devPageVisible = _pageRegistry.GetPages().Any(p => p.PageId == "dev");
+
+            if (snapshot.IsDevModeEnabled && !devPageVisible)
+            {
+                _pageRegistry.Rebuild();
+                _window.ReloadPages("dev");
+            }
+            else if (!snapshot.IsDevModeEnabled && devPageVisible)
+            {
+                _pageRegistry.Rebuild();
+                _window.ReloadPages(null);
+            }
+        }, DispatcherPriority.Background);
+    }
+
     private void ApplyTheme(SettingsWindow window)
     {
         var appearanceSnapshot = _appearanceThemeService.GetCurrent();

LanMountainDesktop/Services/TelemetryEvent.cs

@@ -1,55 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace LanMountainDesktop.Services;
-
-internal sealed record TelemetryEvent(
-    string EventName,
-    string DistinctId,
-    string InstallId,
-    string TelemetryId,
-    string SessionId,
-    long Sequence,
-    DateTimeOffset Timestamp,
-    IReadOnlyDictionary<string, object?> Payload,
-    IReadOnlyDictionary<string, object?>? StateBefore = null,
-    IReadOnlyDictionary<string, object?>? StateAfter = null)
-{
-    public Dictionary<string, object?> ToPostHogProperties()
-    {
-        var properties = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
-        {
-            ["install_id"] = InstallId,
-            ["telemetry_id"] = TelemetryId,
-            ["session_id"] = SessionId,
-            ["sequence"] = Sequence,
-            ["timestamp_utc"] = Timestamp.ToString("o"),
-            ["app_version"] = TelemetryEnvironmentInfo.GetAppVersion(),
-            ["os_name"] = TelemetryEnvironmentInfo.GetOsName(),
-            ["os_version"] = TelemetryEnvironmentInfo.GetOsVersion(),
-            ["device_model"] = TelemetryEnvironmentInfo.GetDeviceModel(),
-            ["device_arch"] = TelemetryEnvironmentInfo.GetDeviceArchitecture(),
-            ["runtime_version"] = TelemetryEnvironmentInfo.GetRuntimeVersion(),
-            ["language"] = TelemetryEnvironmentInfo.GetSystemLanguage(),
-            ["payload"] = Copy(Payload)
-        };
-
-        if (StateBefore is not null && StateBefore.Count > 0)
-        {
-            properties["state_before"] = Copy(StateBefore);
-        }
-
-        if (StateAfter is not null && StateAfter.Count > 0)
-        {
-            properties["state_after"] = Copy(StateAfter);
-        }
-
-        return properties;
-    }
-
-    private static Dictionary<string, object?> Copy(IReadOnlyDictionary<string, object?> source)
-    {
-        return source.ToDictionary(entry => entry.Key, entry => entry.Value, StringComparer.OrdinalIgnoreCase);
-    }
-}

LanMountainDesktop/Services/UpdateWorkflowService.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using LanMountainDesktop.PluginSdk;
@@ -47,6 +49,13 @@ public sealed class UpdateWorkflowService
     private readonly ISettingsFacadeService _settingsFacade;
     private readonly string _updatesDirectory;
 
+    private const string LauncherDirectoryName = ".launcher";
+    private const string UpdateDirectoryName = "update";
+    private const string IncomingDirectoryName = "incoming";
+    private const string DeltaManifestFileName = "files.json";
+    private const string DeltaSignatureFileName = "files.json.sig";
+    private const string DeltaArchiveFileName = "update.zip";
+
     public UpdateWorkflowService(ISettingsFacadeService settingsFacade)
     {
         _settingsFacade = settingsFacade ?? throw new ArgumentNullException(nameof(settingsFacade));
@@ -56,6 +65,175 @@ public sealed class UpdateWorkflowService
             "Updates");
     }
 
+    /// <summary>
+    /// Gets the path to the Launcher's incoming update directory where delta packages should be placed.
+    /// </summary>
+    public static string GetLauncherIncomingDirectory()
+    {
+        // The app runs from app-{version}/ subdirectory; Launcher root is one level up.
+        var appBaseDir = AppContext.BaseDirectory;
+        var launcherRoot = Path.GetDirectoryName(appBaseDir.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
+        if (string.IsNullOrWhiteSpace(launcherRoot))
+        {
+            launcherRoot = appBaseDir;
+        }
+        return Path.Combine(launcherRoot, LauncherDirectoryName, UpdateDirectoryName, IncomingDirectoryName);
+    }
+
+    /// <summary>
+    /// Checks whether a GitHub Release contains delta update assets (files.json, files.json.sig, update.zip).
+    /// </summary>
+    public static bool IsDeltaUpdateAvailable(GitHubReleaseInfo release)
+    {
+        if (release is null || release.Assets is null || release.Assets.Count == 0)
+        {
+            return false;
+        }
+
+        var assetNames = release.Assets.Select(a => a.Name).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        return assetNames.Contains(DeltaManifestFileName)
+            && assetNames.Contains(DeltaSignatureFileName)
+            && assetNames.Contains(DeltaArchiveFileName);
+    }
+
+    /// <summary>
+    /// Downloads the delta update package (files.json, files.json.sig, update.zip) from a GitHub Release
+    /// and places them in the Launcher's incoming directory for the Launcher to apply on next startup.
+    /// </summary>
+    public async Task<UpdateDownloadResult> DownloadDeltaUpdateAsync(
+        UpdateCheckResult checkResult,
+        IProgress<double>? progress = null,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(checkResult);
+
+        if (!checkResult.Success || !checkResult.IsUpdateAvailable || checkResult.Release is null)
+        {
+            return new UpdateDownloadResult(false, null, "No update available for delta download.");
+        }
+
+        if (!IsDeltaUpdateAvailable(checkResult.Release))
+        {
+            return new UpdateDownloadResult(false, null, "Release does not contain delta update assets.");
+        }
+
+        var incomingDir = GetLauncherIncomingDirectory();
+
+        try
+        {
+            Directory.CreateDirectory(incomingDir);
+        }
+        catch (Exception ex)
+        {
+            return new UpdateDownloadResult(false, null, $"Failed to create incoming directory: {ex.Message}");
+        }
+
+        var state = _settingsFacade.Update.Get();
+        var downloadSource = state.UpdateDownloadSource;
+        var downloadThreads = state.UpdateDownloadThreads;
+
+        var requiredAssets = new Dictionary<string, GitHubReleaseAsset>(StringComparer.OrdinalIgnoreCase)
+        {
+            [DeltaManifestFileName] = null!,
+            [DeltaSignatureFileName] = null!,
+            [DeltaArchiveFileName] = null!
+        };
+
+        foreach (var asset in checkResult.Release.Assets)
+        {
+            if (requiredAssets.ContainsKey(asset.Name))
+            {
+                requiredAssets[asset.Name] = asset;
+            }
+        }
+
+        if (requiredAssets.Any(kvp => kvp.Value is null))
+        {
+            return new UpdateDownloadResult(false, null, "One or more delta assets not found in release.");
+        }
+
+        var totalAssets = requiredAssets.Count;
+        var completedAssets = 0;
+
+        foreach (var (name, asset) in requiredAssets)
+        {
+            var destinationPath = Path.Combine(incomingDir, name);
+
+            // Skip if already downloaded and file exists
+            if (File.Exists(destinationPath))
+            {
+                var existingHash = await GitHubReleaseUpdateService.ComputeFileSha256Async(destinationPath, cancellationToken);
+                if (asset.Sha256 is not null && string.Equals(existingHash, asset.Sha256, StringComparison.OrdinalIgnoreCase))
+                {
+                    AppLogger.Info("UpdateWorkflow", $"Delta asset {name} already downloaded with matching hash, skipping.");
+                    completedAssets++;
+                    progress?.Report((double)completedAssets / totalAssets);
+                    continue;
+                }
+            }
+
+            var assetProgress = progress is null ? null : new Progress<double>(p =>
+            {
+                var overallProgress = ((double)completedAssets + p) / totalAssets;
+                progress.Report(overallProgress);
+            });
+
+            var result = await _settingsFacade.Update.DownloadAssetAsync(
+                asset,
+                destinationPath,
+                downloadSource,
+                downloadThreads,
+                assetProgress,
+                cancellationToken);
+
+            if (!result.Success)
+            {
+                // Clean up partially downloaded files
+                foreach (var file in requiredAssets.Keys)
+                {
+                    try { File.Delete(Path.Combine(incomingDir, file)); } catch { }
+                }
+                return new UpdateDownloadResult(false, null, $"Failed to download delta asset {name}: {result.ErrorMessage}");
+            }
+
+            completedAssets++;
+            progress?.Report((double)completedAssets / totalAssets);
+        }
+
+        // Save state indicating a delta update is pending
+        SaveState(state with
+        {
+            PendingUpdateInstallerPath = Path.Combine(incomingDir, DeltaManifestFileName),
+            PendingUpdateVersion = checkResult.LatestVersionText,
+            PendingUpdatePublishedAtUtcMs = checkResult.Release.PublishedAt == DateTimeOffset.MinValue
+                ? null
+                : checkResult.Release.PublishedAt.ToUnixTimeMilliseconds(),
+            LastUpdateCheckUtcMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
+            PendingUpdateSha256 = null
+        });
+
+        AppLogger.Info("UpdateWorkflow", $"Delta update package downloaded to {incomingDir}. Will be applied by Launcher on next startup.");
+
+        return new UpdateDownloadResult(true, Path.Combine(incomingDir, DeltaManifestFileName), null);
+    }
+
+    /// <summary>
+    /// Checks whether the pending update is a delta update (files.json in incoming dir) vs a full installer.
+    /// </summary>
+    public bool IsPendingDeltaUpdate()
+    {
+        var state = _settingsFacade.Update.Get();
+        var pendingPath = state.PendingUpdateInstallerPath?.Trim();
+        if (string.IsNullOrWhiteSpace(pendingPath))
+        {
+            return false;
+        }
+
+        // Delta updates are identified by the manifest file path
+        return pendingPath.EndsWith(DeltaManifestFileName, StringComparison.OrdinalIgnoreCase)
+            || pendingPath.Contains(IncomingDirectoryName, StringComparison.OrdinalIgnoreCase);
+    }
+
     public UpdatePendingInfo? GetPendingUpdate()
     {
         var state = _settingsFacade.Update.Get();
@@ -261,7 +439,7 @@ public sealed class UpdateWorkflowService
         {
             // Always check for updates on startup (removed AutoCheckUpdates check)
             var result = await CheckForUpdatesAsync(currentVersion, isForce: false, cancellationToken);
-            if (!result.Success || !result.IsUpdateAvailable || result.PreferredAsset is null)
+            if (!result.Success || !result.IsUpdateAvailable || result.Release is null)
             {
                 return;
             }
@@ -272,7 +450,16 @@ public sealed class UpdateWorkflowService
             if (string.Equals(normalizedMode, UpdateSettingsValues.ModeDownloadThenConfirm, StringComparison.OrdinalIgnoreCase) ||
                 string.Equals(normalizedMode, UpdateSettingsValues.ModeSilentOnExit, StringComparison.OrdinalIgnoreCase))
             {
-                await DownloadReleaseAsync(result, cancellationToken: cancellationToken);
+                // Prefer delta update if available (smaller download, faster)
+                if (IsDeltaUpdateAvailable(result.Release))
+                {
+                    AppLogger.Info("UpdateWorkflow", "Delta update available, downloading incremental package.");
+                    await DownloadDeltaUpdateAsync(result, cancellationToken: cancellationToken);
+                }
+                else if (result.PreferredAsset is not null)
+                {
+                    await DownloadReleaseAsync(result, cancellationToken: cancellationToken);
+                }
             }
             // For "Manual" mode, just check but don't download
         }
@@ -302,6 +489,15 @@ public sealed class UpdateWorkflowService
             return false;
         }
 
+        // For delta updates, the files are already in .launcher/update/incoming/.
+        // Just exit the app - the Launcher will detect and apply the update on next startup.
+        if (IsPendingDeltaUpdate())
+        {
+            AppLogger.Info("UpdateWorkflow", "Delta update pending in incoming directory. Exiting to let Launcher apply on next startup.");
+            ClearPendingUpdate();
+            return true;
+        }
+
         var result = LaunchPendingInstaller(silent: true, exitApplicationAfterLaunch: false);
         if (!result.Success && !string.IsNullOrWhiteSpace(result.ErrorMessage))
         {

LanMountainDesktop/ViewModels/ComponentLibraryWindowViewModel.cs

@@ -10,6 +10,7 @@ namespace LanMountainDesktop.ViewModels;
 public sealed class ComponentLibraryWindowViewModel : ViewModelBase
 {
     private string _title = "Widgets";
+    private ComponentLibraryItemViewModel? _selectedComponent;
 
     public string Title
     {
@@ -20,6 +21,12 @@ public sealed class ComponentLibraryWindowViewModel : ViewModelBase
     public ObservableCollection<ComponentLibraryCategoryViewModel> Categories { get; } = [];
 
     public ObservableCollection<ComponentLibraryItemViewModel> Components { get; } = [];
+
+    public ComponentLibraryItemViewModel? SelectedComponent
+    {
+        get => _selectedComponent;
+        set => SetProperty(ref _selectedComponent, value);
+    }
 }
 
 public sealed class ComponentLibraryCategoryViewModel
@@ -51,6 +58,7 @@ public sealed class ComponentLibraryItemViewModel
     private readonly string _loadingPreviewText;
     private readonly string _previewUnavailableText;
     private string _displayName;
+    private string? _description;
     private ComponentPreviewKey _previewKey;
     private ComponentPreviewImageEntry? _previewImageEntry;
     private ComponentPreviewImageState _previewState;
@@ -61,12 +69,14 @@ public sealed class ComponentLibraryItemViewModel
         string componentId,
         string displayName,
         ComponentPreviewKey previewKey,
+        string? description = null,
         string loadingPreviewText = "Loading preview...",
         string previewUnavailableText = "Preview unavailable",
         ComponentPreviewImageEntry? previewImageEntry = null)
     {
         ComponentId = componentId;
         _displayName = displayName;
+        _description = description;
         _previewKey = previewKey;
         _loadingPreviewText = loadingPreviewText;
         _previewUnavailableText = previewUnavailableText;
@@ -82,6 +92,12 @@ public sealed class ComponentLibraryItemViewModel
         set => SetProperty(ref _displayName, value);
     }
 
+    public string? Description
+    {
+        get => _description;
+        set => SetProperty(ref _description, value);
+    }
+
     public ComponentPreviewKey PreviewKey
     {
         get => _previewKey;

LanMountainDesktop/ViewModels/SettingsViewModels.cs

@@ -174,9 +174,6 @@ public sealed partial class GeneralSettingsPageViewModel : ViewModelBase, IDispo
         private bool _isInitializing;
         private bool _disposed;
 
-        [ObservableProperty]
-        private bool _enableThreeFingerSwipe;
-
     public GeneralSettingsPageViewModel(ISettingsFacadeService settingsFacade)
     {
         _settingsFacade = settingsFacade;
@@ -204,7 +201,7 @@ public sealed partial class GeneralSettingsPageViewModel : ViewModelBase, IDispo
         SelectedRenderMode = RenderModes.FirstOrDefault(option =>
             string.Equals(option.Value, normalizedRenderMode, StringComparison.OrdinalIgnoreCase))
             ?? RenderModes[0];
-        EnableThreeFingerSwipe = appSnapshot.EnableThreeFingerSwipe;
+        EnableSlideTransition = appSnapshot.EnableSlideTransition;
         _isInitializing = false;
 
         RefreshPreview();
@@ -236,33 +233,11 @@ public sealed partial class GeneralSettingsPageViewModel : ViewModelBase, IDispo
         {
             return;
         }
-        
-        // 如果是其他设置变更，重新加载我们的设置
-        _isInitializing = true;
-        try
-        {
-            var appSnapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
-            EnableThreeFingerSwipe = appSnapshot.EnableThreeFingerSwipe;
-        }
-        finally
-        {
-            _isInitializing = false;
-        }
-    }
 
-    partial void OnEnableThreeFingerSwipeChanged(bool value)
-    {
-        if (_isInitializing)
+        if (changedKeys.Contains(nameof(AppSettingsSnapshot.EnableSlideTransition)))
         {
-            return;
+            EnableSlideTransition = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App).EnableSlideTransition;
         }
-
-        var appSnapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
-        appSnapshot.EnableThreeFingerSwipe = value;
-        _settingsFacade.Settings.SaveSnapshot(
-            SettingsScope.App,
-            appSnapshot,
-            changedKeys: [nameof(AppSettingsSnapshot.EnableThreeFingerSwipe)]);
     }
 
     public event Action? RestartRequested;
@@ -282,6 +257,11 @@ public sealed partial class GeneralSettingsPageViewModel : ViewModelBase, IDispo
     [ObservableProperty]
     private SelectionOption _selectedRenderMode = new(AppRenderingModeHelper.Default, "Default");
 
+    [ObservableProperty]
+    private bool _enableSlideTransition;
+
+    public bool IsSlideTransitionAvailable => System.Runtime.InteropServices.RuntimeInformation.IsOSPlatform(System.Runtime.InteropServices.OSPlatform.Windows);
+
     [ObservableProperty]
     private string _pageTitle = string.Empty;
 
@@ -381,6 +361,24 @@ public sealed partial class GeneralSettingsPageViewModel : ViewModelBase, IDispo
         }
     }
 
+    partial void OnEnableSlideTransitionChanged(bool value)
+    {
+        if (_isInitializing) return;
+        SaveField(nameof(AppSettingsSnapshot.EnableSlideTransition), value);
+    }
+
+    private void SaveField<T>(string key, T value)
+    {
+        var snapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+        var property = typeof(AppSettingsSnapshot).GetProperty(key);
+        if (property is not null && property.CanWrite)
+        {
+            property.SetValue(snapshot, value);
+        }
+
+        _settingsFacade.Settings.SaveSnapshot(SettingsScope.App, snapshot, changedKeys: [key]);
+    }
+
     private IReadOnlyList<SelectionOption> CreateLanguageOptions()
     {
         return
@@ -3088,3 +3086,104 @@ public sealed class PluginGeneratedSettingsPageViewModel
 
     public string? Description { get; }
 }
+
+public sealed partial class DevSettingsPageViewModel : ViewModelBase
+{
+    private readonly ISettingsFacadeService _settingsFacade;
+    private bool _isInitializing;
+
+    public DevSettingsPageViewModel(ISettingsFacadeService settingsFacade)
+    {
+        _settingsFacade = settingsFacade;
+        _isInitializing = true;
+        LoadSettings();
+        _isInitializing = false;
+
+        // 监听设置变更，防止被意外重置
+        _settingsFacade.Settings.Changed += OnSettingsChanged;
+    }
+
+    [ObservableProperty]
+    private bool _isDevModeEnabled;
+
+    [ObservableProperty]
+    private string _devPluginPath = string.Empty;
+
+    [ObservableProperty]
+    private bool _enableThreeFingerSwipe;
+
+    [ObservableProperty]
+    private bool _enableFusedDesktop;
+
+    partial void OnIsDevModeEnabledChanged(bool value)
+    {
+        if (_isInitializing) return;
+        SaveField(nameof(AppSettingsSnapshot.IsDevModeEnabled), value);
+    }
+
+    partial void OnDevPluginPathChanged(string value)
+    {
+        if (_isInitializing) return;
+        SaveField(nameof(AppSettingsSnapshot.DevPluginPath), value);
+    }
+
+    partial void OnEnableThreeFingerSwipeChanged(bool value)
+    {
+        if (_isInitializing) return;
+        SaveField(nameof(AppSettingsSnapshot.EnableThreeFingerSwipe), value);
+    }
+
+    partial void OnEnableFusedDesktopChanged(bool value)
+    {
+        if (_isInitializing) return;
+        SaveField(nameof(AppSettingsSnapshot.EnableFusedDesktop), value);
+    }
+
+    private void LoadSettings()
+    {
+        var snapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+        IsDevModeEnabled = snapshot.IsDevModeEnabled;
+        DevPluginPath = snapshot.DevPluginPath ?? string.Empty;
+        EnableThreeFingerSwipe = snapshot.EnableThreeFingerSwipe;
+        EnableFusedDesktop = snapshot.EnableFusedDesktop;
+    }
+
+    private void OnSettingsChanged(object? sender, SettingsChangedEvent e)
+    {
+        if (e.Scope != SettingsScope.App)
+        {
+            return;
+        }
+
+        var changedKeys = e.ChangedKeys?.ToArray();
+        if (changedKeys is null || changedKeys.Length == 0)
+        {
+            return;
+        }
+
+        // 如果是其他设置变更，重新加载我们的设置
+        _isInitializing = true;
+        try
+        {
+            var snapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+            EnableThreeFingerSwipe = snapshot.EnableThreeFingerSwipe;
+            EnableFusedDesktop = snapshot.EnableFusedDesktop;
+        }
+        finally
+        {
+            _isInitializing = false;
+        }
+    }
+
+    private void SaveField<T>(string key, T value)
+    {
+        var snapshot = _settingsFacade.Settings.LoadSnapshot<AppSettingsSnapshot>(SettingsScope.App);
+        var property = typeof(AppSettingsSnapshot).GetProperty(key);
+        if (property is not null && property.CanWrite)
+        {
+            property.SetValue(snapshot, value);
+        }
+
+        _settingsFacade.Settings.SaveSnapshot(SettingsScope.App, snapshot, changedKeys: [key]);
+    }
+}

LanMountainDesktop/Views/ComponentLibraryWindow.axaml.cs

@@ -94,6 +94,7 @@ public partial class ComponentLibraryWindow : Window
             entry.ComponentId,
             displayName,
             previewKey,
+            description: null,
             _localize?.Invoke("component_library.preview.loading", "Loading preview...") ?? "Loading preview...",
             _localize?.Invoke("component_library.preview.unavailable", "Preview unavailable") ?? "Preview unavailable",
             previewEntry);

LanMountainDesktop/Views/Components/ClassScheduleWidget.axaml

@@ -34,11 +34,13 @@
                     <TextBlock x:Name="WeekdayTextBlock"
                                Text="周一"
                                TextAlignment="Right"
-                               FontWeight="SemiBold" />
+                               FontWeight="SemiBold"
+                               TextTrimming="CharacterEllipsis" />
                     <TextBlock x:Name="ClassCountTextBlock"
                                Text="0节课"
                                TextAlignment="Right"
-                               FontWeight="SemiBold" />
+                               FontWeight="SemiBold"
+                               TextTrimming="CharacterEllipsis" />
                 </StackPanel>
             </Grid>
 

LanMountainDesktop/Views/Components/ClassScheduleWidget.axaml.cs

@@ -928,7 +928,28 @@ public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget,
         MetaStack.Spacing = Math.Clamp(6 * scale, 3, 10);
         CourseListPanel.Spacing = Math.Clamp(6 * scale, 3, 10);
 
-        var dateFont = Math.Clamp(66 * scale, 26, 82);
+        var dateFontByScale = Math.Clamp(66 * scale, 26, 82);
+        var weekdayFontByScale = Math.Clamp(34 * scale, 13, 32);
+        var classCountFontByScale = Math.Clamp(40 * scale, 14, 36);
+
+        // 宽度感知：当头部内容总需求超过可用宽度时，按比例缩小日期字体
+        var availableWidth = Math.Max(1, Bounds.Width - rootPadding.Left - rootPadding.Right);
+        var dateGroupEstimatedWidth = dateFontByScale * 0.6 * 3 + DateGroup.Spacing * 2;
+        var metaStackEstimatedWidth = classCountFontByScale * 0.6 * 4 + MetaStack.Spacing;
+        var headerColumnSpacing = Math.Clamp(10 * scale, 4, 16);
+        var totalHeaderNeed = dateGroupEstimatedWidth + headerColumnSpacing + metaStackEstimatedWidth;
+
+        var dateFont = dateFontByScale;
+        if (totalHeaderNeed > availableWidth)
+        {
+            var shrinkRatio = availableWidth / totalHeaderNeed;
+            dateFont = Math.Max(20, dateFontByScale * shrinkRatio);
+        }
+
+        // 为 HeaderGrid 左列设置最小宽度，防止被压缩至零
+        var minDateColumnWidth = dateFont * 0.6 * 3 + DateGroup.Spacing * 2;
+        HeaderGrid.ColumnDefinitions[0].MinWidth = minDateColumnWidth;
+
         MonthTextBlock.FontSize = dateFont;
         DayTextBlock.FontSize = dateFont;
         SlashTextBlock.FontSize = dateFont;
@@ -940,8 +961,8 @@ public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget,
         ClassCountTextBlock.Foreground = CreateBrush(_isNightVisual ? "#8D95A4" : "#738095");
         StatusTextBlock.Foreground = CreateBrush(_isNightVisual ? "#9AA2B1" : "#4B5565");
 
-        WeekdayTextBlock.FontSize = Math.Clamp(34 * scale, 13, 32);
-        ClassCountTextBlock.FontSize = Math.Clamp(40 * scale, 14, 36);
+        WeekdayTextBlock.FontSize = weekdayFontByScale;
+        ClassCountTextBlock.FontSize = classCountFontByScale;
         StatusTextBlock.FontSize = Math.Clamp(30 * scale, 12, 30);
 
         WeekdayTextBlock.FontWeight = ToVariableWeight(Lerp(560, 700, Math.Clamp((scale - 0.60) / 1.2, 0, 1)));

LanMountainDesktop/Views/Components/CnrDailyNewsWidget.axaml.cs

@@ -704,6 +704,24 @@ public partial class CnrDailyNewsWidget : UserControl, IDesktopComponentWidget,
         ExtraNewsItemsPanel.Spacing = Math.Clamp(6 * scale, 3, 10);
 
         ApplyNightModeVisual();
+
+        var headerHeight = refreshHeight;
+        var newsItemHeight = Math.Max(imageHeight, mainNewsMinHeight);
+
+        var requiredHeight = verticalPadding * 2
+                          + headerHeight
+                          + rowSpacing
+                          + newsItemHeight
+                          + rowSpacing
+                          + newsItemHeight;
+
+        if (_extraNewsRows.Count > 0)
+        {
+            var extraSpacing = ExtraNewsItemsPanel.Spacing * (_extraNewsRows.Count - 1);
+            requiredHeight += rowSpacing + extraSpacing + _extraNewsRows.Count * newsItemHeight;
+        }
+
+        this.MinHeight = requiredHeight;
     }
 
     private void UpdateRefreshButtonState()
@@ -842,6 +860,11 @@ public partial class CnrDailyNewsWidget : UserControl, IDesktopComponentWidget,
         oldBitmap?.Dispose();
         _newsBitmaps[index] = bitmap;
         imageControl.Source = bitmap;
+
+        if (bitmap != null)
+        {
+            InvalidateMeasure();
+        }
     }
 
     private void DisposeNewsBitmaps()

LanMountainDesktop/Views/Components/DesktopComponentRuntimeRegistry.cs

@@ -452,6 +452,10 @@ public sealed class DesktopComponentRuntimeRegistry
                     BuiltInComponentIds.DesktopBlackboardLandscape,
                     "component.blackboard_landscape",
                     () => new WhiteboardWidget(baseWidthCells: 4)),
+                new DesktopComponentRuntimeRegistration(
+                    BuiltInComponentIds.DesktopStickyNote,
+                    "component.sticky_note",
+                    () => new StickyNoteWidget()),
                 new DesktopComponentRuntimeRegistration(
                     BuiltInComponentIds.DesktopBrowser,
                     "component.browser",

LanMountainDesktop/Views/Components/NetworkSpeedWidget.axaml

@@ -30,7 +30,10 @@
                            FontWeight="SemiBold"
                            Margin="2,0,0,0"
                            VerticalAlignment="Center"
-                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"/>
+                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                           FontFamily="Consolas, Courier New, monospace"
+                           MinWidth="42"
+                           TextAlignment="Right"/>
             </StackPanel>
 
             <!-- 分隔符 -->
@@ -55,7 +58,10 @@
                            FontWeight="SemiBold"
                            Margin="2,0,0,0"
                            VerticalAlignment="Center"
-                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"/>
+                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                           FontFamily="Consolas, Courier New, monospace"
+                           MinWidth="42"
+                           TextAlignment="Right"/>
             </StackPanel>
 
             <!-- 网络类型图标 -->

LanMountainDesktop/Views/Components/NetworkSpeedWidget.axaml.cs

@@ -317,31 +317,32 @@ public partial class NetworkSpeedWidget : UserControl, IDesktopComponentWidget
 
     private static string FormatSpeed(long bytesPerSecond)
     {
-        // 根据数值大小决定显示格式，始终保持3个字符宽度
-        // 例如: 1.23, 12.3, 123
+        // 根据数值大小选择合适的单位，确保显示始终在1-99.9范围内
+        // 当数值达到100时自动切换到更大的单位
         return bytesPerSecond switch
         {
-            >= 1024 * 1024 * 1024 => FormatWithThreeDigits(bytesPerSecond / (1024.0 * 1024.0 * 1024.0), "G"),
-            >= 1024 * 1024 => FormatWithThreeDigits(bytesPerSecond / (1024.0 * 1024.0), "M"),
-            >= 1024 => FormatWithThreeDigits(bytesPerSecond / 1024.0, "K"),
+            >= 100L * 1024 * 1024 * 1024 => FormatWithThreeDigits(bytesPerSecond / (1024.0 * 1024.0 * 1024.0), "G"),
+            >= 100L * 1024 * 1024 => FormatWithThreeDigits(bytesPerSecond / (1024.0 * 1024.0), "M"),
+            >= 100L * 1024 => FormatWithThreeDigits(bytesPerSecond / 1024.0, "K"),
+            >= 100 => FormatWithThreeDigits(bytesPerSecond / 1024.0, "K"),  // 100B+ 显示为 0.1K
             _ => FormatWithThreeDigits(bytesPerSecond, "B")
         };
     }
 
     /// <summary>
-    /// 格式化数字，始终保持3个有效数字的显示宽度
+    /// 格式化数字，始终保持3位数字+小数点，确保宽度恒定
+    /// 数值范围始终在1-99.9之间
     /// </summary>
     private static string FormatWithThreeDigits(double value, string unit)
     {
-        // 根据数值大小决定小数位数，确保总宽度一致
+        // 始终保持3位数字，小数点始终存在
+        // 数值范围: 0.0 - 99.9
         // < 10: 显示两位小数 (如 1.23)
-        // 10-99: 显示一位小数 (如 12.3)
-        // >= 100: 显示整数 (如 123)
+        // >= 10: 显示一位小数 (如 12.3, 99.9)
         string formatted = value switch
         {
-            < 10 => $"{value:F2}",
-            < 100 => $"{value:F1}",
-            _ => $"{value:F0}"
+            < 10 => $"{value:F2}",   // 1.23
+            _ => $"{value:F1}"       // 12.3, 99.9
         };
 
         return formatted + unit;

LanMountainDesktop/Views/Components/ShortcutWidget.axaml

@@ -8,9 +8,6 @@
              x:Class="LanMountainDesktop.Views.Components.ShortcutWidget">
 
     <Border x:Name="RootBorder"
-            Background="{DynamicResource AdaptiveSurfaceRaisedBrush}"
-            BorderBrush="{DynamicResource AdaptiveButtonBorderBrush}"
-            BorderThickness="1"
             CornerRadius="{DynamicResource DesignCornerRadiusComponent}"
             ClipToBounds="True">
         <Grid RowDefinitions="*,Auto"

LanMountainDesktop/Views/Components/ShortcutWidget.axaml.cs

@@ -25,6 +25,7 @@ public partial class ShortcutWidget : UserControl, IDesktopComponentWidget, ICom
     private bool _showBackground = true;
     private double _currentCellSize = 48;
     private bool _isDisposed;
+    private bool _chromeApplied;
 
     private const double TapMovementThreshold = 10;
     private const long TapTimeThresholdMs = 500;
@@ -40,9 +41,32 @@ public partial class ShortcutWidget : UserControl, IDesktopComponentWidget, ICom
     {
         InitializeComponent();
         DoubleTapped += OnDoubleTapped;
+        Loaded += OnLoaded;
         UpdateDisplay();
     }
 
+    private void OnLoaded(object? sender, RoutedEventArgs e)
+    {
+        // ApplyChrome() may have been called before the control was attached to the visual tree,
+        // causing FindResource() to fail. Re-apply now that resources are available.
+        if (!_chromeApplied)
+        {
+            ApplyChrome();
+        }
+
+        // Subscribe to theme changes so the background follows theme updates.
+        var themeService = HostAppearanceThemeProvider.GetOrCreate();
+        themeService.Changed += OnAppearanceThemeChanged;
+    }
+
+    private void OnAppearanceThemeChanged(object? sender, AppearanceThemeSnapshot e)
+    {
+        if (_isDisposed || _showBackground)
+        {
+            ApplyChrome();
+        }
+    }
+
     public void SetComponentPlacementContext(string componentId, string? placementId)
     {
         _componentId = string.IsNullOrWhiteSpace(componentId)
@@ -258,13 +282,25 @@ public partial class ShortcutWidget : UserControl, IDesktopComponentWidget, ICom
             RootBorder.Background = Brushes.Transparent;
             RootBorder.BorderBrush = Brushes.Transparent;
             RootBorder.BorderThickness = new Thickness(0);
+            _chromeApplied = true;
             return;
         }
 
-        // 恢复默认的实心背景样式
-        RootBorder.Background = this.FindResource("AdaptiveSurfaceRaisedBrush") as IBrush ?? Brushes.Transparent;
-        RootBorder.BorderBrush = this.FindResource("AdaptiveButtonBorderBrush") as IBrush ?? Brushes.Transparent;
+        // FindResource requires the control to be attached to the visual tree.
+        // If it returns null, _chromeApplied stays false so OnLoaded will retry.
+        var background = this.FindResource("AdaptiveSurfaceRaisedBrush") as IBrush;
+        var borderBrush = this.FindResource("AdaptiveButtonBorderBrush") as IBrush;
+
+        if (background is null || borderBrush is null)
+        {
+            _chromeApplied = false;
+            return;
+        }
+
+        RootBorder.Background = background;
+        RootBorder.BorderBrush = borderBrush;
         RootBorder.BorderThickness = new Thickness(1);
+        _chromeApplied = true;
     }
 
     protected override void OnPointerPressed(PointerPressedEventArgs e)
@@ -391,6 +427,10 @@ public partial class ShortcutWidget : UserControl, IDesktopComponentWidget, ICom
         }
 
         _isDisposed = true;
+
+        var themeService = HostAppearanceThemeProvider.GetOrCreate();
+        themeService.Changed -= OnAppearanceThemeChanged;
+
         _gestureStates.Clear();
     }
 }

LanMountainDesktop/Views/Components/StickyNoteWidget.axaml

@@ -0,0 +1,51 @@
+<UserControl 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:fi="using:FluentIcons.Avalonia"
+             xmlns:md="clr-namespace:Markdown.Avalonia;assembly=Markdown.Avalonia"
+             mc:Ignorable="d"
+             d:DesignWidth="200"
+             d:DesignHeight="200"
+             x:Class="LanMountainDesktop.Views.Components.StickyNoteWidget">
+
+    <Border x:Name="RootBorder"
+            CornerRadius="{DynamicResource DesignCornerRadiusComponent}"
+            BorderBrush="#E0C878"
+            BorderThickness="1">
+        <Grid>
+            <md:MarkdownScrollViewer x:Name="MarkdownViewer"
+                                     Margin="14,14,14,10"
+                                     IsVisible="True" />
+
+            <TextBox x:Name="NoteTextBox"
+                     AcceptsReturn="True"
+                     TextWrapping="Wrap"
+                     IsVisible="False"
+                     Background="Transparent"
+                     BorderThickness="0"
+                     Margin="14,14,14,10"
+                     FontFamily="Consolas,Cascadia Code,Courier New,monospace"
+                     Foreground="#5D4E37" />
+
+            <Button x:Name="ToggleButton"
+                    Width="28"
+                    Height="28"
+                    CornerRadius="14"
+                    HorizontalAlignment="Right"
+                    VerticalAlignment="Top"
+                    Margin="4,4,4,0"
+                    Padding="0"
+                    Background="#00000010"
+                    BorderThickness="0"
+                    Click="OnToggleButtonClick">
+                <fi:SymbolIcon x:Name="ToggleIcon"
+                               Symbol="Edit"
+                               IconVariant="Regular"
+                               FontSize="13"
+                               Foreground="#8B7D5A" />
+            </Button>
+        </Grid>
+    </Border>
+
+</UserControl>

LanMountainDesktop/Views/Components/StickyNoteWidget.axaml.cs

@@ -0,0 +1,371 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Media;
+using Avalonia.Styling;
+using Avalonia.Threading;
+using FluentIcons.Common;
+using LanMountainDesktop.ComponentSystem;
+using LanMountainDesktop.Host.Abstractions;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.PluginSdk;
+using LanMountainDesktop.Services.Settings;
+
+namespace LanMountainDesktop.Views.Components;
+
+public partial class StickyNoteWidget : UserControl,
+    IDesktopComponentWidget,
+    IComponentPlacementContextAware,
+    IComponentSettingsContextAware,
+    IDesktopPageVisibilityAwareComponentWidget,
+    IDisposable
+{
+    private static readonly Color LightNoteYellow = Color.FromRgb(0xFF, 0xF9, 0xC4);
+    private static readonly Color LightNoteBorder = Color.FromRgb(0xE0, 0xC8, 0x78);
+    private static readonly Color LightNoteForeground = Color.FromRgb(0x5D, 0x4E, 0x37);
+    private static readonly Color LightNoteHint = Color.FromRgb(0x8B, 0x7D, 0x5A);
+
+    private static readonly Color DarkNoteYellow = Color.FromRgb(0x5D, 0x52, 0x29);
+    private static readonly Color DarkNoteBorder = Color.FromRgb(0x7A, 0x6D, 0x3A);
+    private static readonly Color DarkNoteForeground = Color.FromRgb(0xE8, 0xE0, 0xC8);
+    private static readonly Color DarkNoteHint = Color.FromRgb(0xA0, 0x96, 0x70);
+
+    private string _componentId = BuiltInComponentIds.DesktopStickyNote;
+    private string _placementId = string.Empty;
+    private IComponentSettingsAccessor? _settingsAccessor;
+    private string _markdownContent = string.Empty;
+    private bool _isEditing;
+    private bool _isDirty;
+    private bool _isOnActivePage = true;
+    private bool _isEditMode;
+    private bool _disposed;
+    private bool _isApplyingPersistedContent;
+
+    private readonly DispatcherTimer _autoSaveTimer = new()
+    {
+        Interval = TimeSpan.FromSeconds(30)
+    };
+
+    private CancellationTokenSource? _renderDebounceCts;
+
+    public StickyNoteWidget()
+    {
+        InitializeComponent();
+
+        _autoSaveTimer.Tick += OnAutoSaveTimerTick;
+        NoteTextBox.TextChanged += OnNoteTextBoxTextChanged;
+        AttachedToVisualTree += OnAttachedToVisualTree;
+        DetachedFromVisualTree += OnDetachedFromVisualTree;
+
+        ApplyNoteColors();
+        UpdateDisplay();
+    }
+
+    public void ApplyCellSize(double cellSize)
+    {
+        var scale = Math.Clamp(cellSize / 48d, 0.82, 2.2);
+
+        RootBorder.CornerRadius = new CornerRadius(
+            ComponentChromeCornerRadiusHelper.ResolveMainRectangleRadiusValue(
+                new ComponentChromeContext(
+                    _componentId,
+                    _placementId,
+                    Math.Max(1, cellSize),
+                    Appearance.AppearanceCornerRadiusTokenFactory.Create(
+                        Settings.Core.GlobalAppearanceSettings.DefaultCornerRadiusStyle))));
+
+        RootBorder.Padding = new Thickness(
+            Math.Clamp(2 * scale, 1, 4),
+            Math.Clamp(2 * scale, 1, 4));
+
+        var contentMargin = Math.Clamp(12 * scale, 6, 20);
+        MarkdownViewer.Margin = new Thickness(contentMargin, contentMargin, contentMargin, contentMargin - 2);
+        NoteTextBox.Margin = new Thickness(contentMargin, contentMargin, contentMargin, contentMargin - 2);
+        NoteTextBox.FontSize = Math.Clamp(13 * scale, 10, 22);
+
+        var buttonSize = Math.Clamp(28 * scale, 22, 40);
+        ToggleButton.Width = buttonSize;
+        ToggleButton.Height = buttonSize;
+        ToggleButton.CornerRadius = new CornerRadius(buttonSize / 2d);
+        ToggleButton.Margin = new Thickness(Math.Clamp(4 * scale, 2, 8), Math.Clamp(4 * scale, 2, 8), Math.Clamp(4 * scale, 2, 8), 0);
+        ToggleIcon.FontSize = Math.Clamp(13 * scale, 10, 18);
+    }
+
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        if (_isDirty && !string.IsNullOrWhiteSpace(_placementId))
+        {
+            PersistNoteImmediately();
+        }
+
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopStickyNote
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+
+        if (_isEditing)
+        {
+            ExitEditMode();
+        }
+
+        LoadPersistedContent();
+    }
+
+    public void SetComponentSettingsContext(DesktopComponentSettingsContext context)
+    {
+        _settingsAccessor = context.ComponentSettingsAccessor;
+        LoadPersistedContent();
+    }
+
+    public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
+    {
+        _isOnActivePage = isOnActivePage;
+        _isEditMode = isEditMode;
+
+        ToggleButton.IsHitTestVisible = !isEditMode;
+        NoteTextBox.IsReadOnly = isEditMode;
+
+        if (isEditMode && _isEditing)
+        {
+            ExitEditMode();
+        }
+    }
+
+    private void OnToggleButtonClick(object? sender, RoutedEventArgs e)
+    {
+        if (_isEditing)
+        {
+            ExitEditMode();
+        }
+        else
+        {
+            EnterEditMode();
+        }
+    }
+
+    private void EnterEditMode()
+    {
+        _isEditing = true;
+
+        NoteTextBox.Text = _markdownContent;
+        MarkdownViewer.IsVisible = false;
+        NoteTextBox.IsVisible = true;
+        ToggleIcon.Symbol = Symbol.Checkmark;
+
+        Dispatcher.UIThread.Post(() => NoteTextBox.Focus(), DispatcherPriority.Input);
+    }
+
+    private void ExitEditMode()
+    {
+        _isEditing = false;
+
+        var editedContent = NoteTextBox.Text ?? string.Empty;
+        if (editedContent != _markdownContent)
+        {
+            _markdownContent = editedContent;
+            _isDirty = true;
+        }
+
+        NoteTextBox.IsVisible = false;
+        MarkdownViewer.IsVisible = true;
+        ToggleIcon.Symbol = Symbol.Edit;
+
+        UpdateDisplay();
+
+        if (_isDirty)
+        {
+            PersistNoteImmediately();
+        }
+    }
+
+    private void OnNoteTextBoxTextChanged(object? sender, TextChangedEventArgs e)
+    {
+        if (_isApplyingPersistedContent || !_isEditing)
+        {
+            return;
+        }
+
+        _isDirty = true;
+
+        if (!_autoSaveTimer.IsEnabled)
+        {
+            _autoSaveTimer.Start();
+        }
+    }
+
+    private void OnAutoSaveTimerTick(object? sender, EventArgs e)
+    {
+        _autoSaveTimer.Stop();
+
+        if (_isDirty && _isEditing)
+        {
+            _markdownContent = NoteTextBox.Text ?? string.Empty;
+            PersistNoteImmediately();
+        }
+    }
+
+    private void UpdateDisplay()
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(_markdownContent))
+            {
+                MarkdownViewer.Markdown = "*Click ✏️ to write a note...*";
+                return;
+            }
+
+            _renderDebounceCts?.Cancel();
+            _renderDebounceCts?.Dispose();
+            _renderDebounceCts = new CancellationTokenSource();
+            var token = _renderDebounceCts.Token;
+
+            Dispatcher.UIThread.Post(async () =>
+            {
+                try
+                {
+                    await Task.Delay(150, token);
+                    if (!token.IsCancellationRequested)
+                    {
+                        MarkdownViewer.Markdown = _markdownContent;
+                    }
+                }
+                catch (OperationCanceledException) { }
+            });
+        }
+        catch (Exception ex)
+        {
+            MarkdownViewer.Markdown = $"*Error: {ex.Message}*";
+        }
+    }
+
+    private void LoadPersistedContent()
+    {
+        if (_settingsAccessor is null)
+        {
+            return;
+        }
+
+        try
+        {
+            var snapshot = _settingsAccessor.LoadSnapshot<ComponentSettingsSnapshot>();
+            _isApplyingPersistedContent = true;
+            _markdownContent = snapshot.StickyNoteContent ?? string.Empty;
+            _isDirty = false;
+            UpdateDisplay();
+        }
+        catch
+        {
+            _markdownContent = string.Empty;
+            UpdateDisplay();
+        }
+        finally
+        {
+            _isApplyingPersistedContent = false;
+        }
+    }
+
+    private void PersistNoteImmediately()
+    {
+        if (_settingsAccessor is null || _disposed)
+        {
+            return;
+        }
+
+        try
+        {
+            var snapshot = _settingsAccessor.LoadSnapshot<ComponentSettingsSnapshot>();
+            snapshot.StickyNoteContent = _markdownContent;
+            _settingsAccessor.SaveSnapshot(snapshot,
+                [nameof(ComponentSettingsSnapshot.StickyNoteContent)]);
+            _isDirty = false;
+        }
+        catch
+        {
+        }
+    }
+
+    private void ApplyNoteColors()
+    {
+        var isDark = Application.Current?.ActualThemeVariant == ThemeVariant.Dark;
+
+        if (isDark)
+        {
+            RootBorder.Background = new SolidColorBrush(DarkNoteYellow);
+            RootBorder.BorderBrush = new SolidColorBrush(DarkNoteBorder);
+            NoteTextBox.Foreground = new SolidColorBrush(DarkNoteForeground);
+            ToggleIcon.Foreground = new SolidColorBrush(DarkNoteHint);
+        }
+        else
+        {
+            RootBorder.Background = new SolidColorBrush(LightNoteYellow);
+            RootBorder.BorderBrush = new SolidColorBrush(LightNoteBorder);
+            NoteTextBox.Foreground = new SolidColorBrush(LightNoteForeground);
+            ToggleIcon.Foreground = new SolidColorBrush(LightNoteHint);
+        }
+    }
+
+    private void OnAttachedToVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        Application.Current!.ActualThemeVariantChanged += OnThemeVariantChanged;
+        ApplyNoteColors();
+    }
+
+    private void OnDetachedFromVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        Application.Current!.ActualThemeVariantChanged -= OnThemeVariantChanged;
+
+        if (_isDirty)
+        {
+            if (_isEditing)
+            {
+                _markdownContent = NoteTextBox.Text ?? string.Empty;
+            }
+            PersistNoteImmediately();
+        }
+
+        _autoSaveTimer.Stop();
+    }
+
+    private void OnThemeVariantChanged(object? sender, EventArgs e)
+    {
+        Dispatcher.UIThread.Post(ApplyNoteColors);
+    }
+
+    public void ForceSave()
+    {
+        if (_isEditing)
+        {
+            _markdownContent = NoteTextBox.Text ?? string.Empty;
+        }
+
+        if (_isDirty || _isEditing)
+        {
+            PersistNoteImmediately();
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+        {
+            return;
+        }
+
+        _disposed = true;
+        _autoSaveTimer.Stop();
+        _renderDebounceCts?.Cancel();
+        _renderDebounceCts?.Dispose();
+
+        if (_isDirty)
+        {
+            if (_isEditing)
+            {
+                _markdownContent = NoteTextBox.Text ?? string.Empty;
+            }
+            PersistNoteImmediately();
+        }
+    }
+}

LanMountainDesktop/Views/Components/WhiteboardWidget.axaml.cs

@@ -40,13 +40,12 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
     private WhiteboardToolMode _toolMode = WhiteboardToolMode.Pen;
     private bool? _isNightModeApplied;
     private SKColor _selectedInkColor = SKColors.Black;
+    private bool _isUserCustomColor;
     private float _selectedInkThickness = 2.5f;
     private string _componentId = BuiltInComponentIds.DesktopWhiteboard;
     private string _placementId = string.Empty;
     private int _noteRetentionDays = WhiteboardNoteRetentionPolicy.DefaultDays;
     private bool _isApplyingPersistedSnapshot;
-    private bool? _lastBitmapCacheEnabled;
-    private int _lastBitmapCacheSize;
     private bool _noteDirty;
     private int _noteLoadRevision;
     private bool _disposed;
@@ -121,10 +120,11 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
         settings.IgnorePressure = true;
         settings.InkThickness = _selectedInkThickness;
         settings.EraserSize = new Size(20, 20);
+        settings.IsBitmapCacheEnabled = true;
+        settings.MaxBitmapCacheSize = 2048;
         InkCanvas.StrokeCollected += OnInkCanvasStrokeCollected;
         InkCanvas.PointerReleased += OnInkCanvasPointerReleased;
         InkCanvas.PointerCaptureLost += OnInkCanvasPointerCaptureLost;
-        UpdateInkCanvasCacheSettings(forceRefresh: true);
     }
 
     public void ApplyCellSize(double cellSize)
@@ -158,7 +158,6 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
         var settings = InkCanvas.AvaloniaSkiaInkCanvas.Settings;
         var eraserSize = Math.Clamp(_currentCellSize * 0.42, 12, 44);
         settings.EraserSize = new Size(eraserSize, eraserSize);
-        UpdateInkCanvasCacheSettings(forceRefresh: false);
     }
 
     private void ApplyThemeVisual(bool force)
@@ -169,6 +168,7 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
             return;
         }
 
+        var wasNightMode = _isNightModeApplied;
         _isNightModeApplied = isNightMode;
 
         RootBorder.Background = new SolidColorBrush(isNightMode ? Color.Parse("#FF181B22") : Color.Parse("#FFF1F4F9"));
@@ -177,9 +177,39 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
         ToolbarBorder.Background = new SolidColorBrush(isNightMode ? Color.Parse("#1AFFFFFF") : Color.Parse("#E6FFFFFF"));
         ToolbarBorder.BorderBrush = new SolidColorBrush(isNightMode ? Color.Parse("#26FFFFFF") : Color.Parse("#16000000"));
 
+        ApplyThemeDefaultInkColor(isNightMode, wasNightMode);
         RefreshToolButtonVisuals();
     }
 
+    private void ApplyThemeDefaultInkColor(bool isNightMode, bool? wasNightMode)
+    {
+        if (_isUserCustomColor || wasNightMode == isNightMode)
+        {
+            return;
+        }
+
+        var oldDefault = wasNightMode == true ? SKColors.White : SKColors.Black;
+        var newDefault = isNightMode ? SKColors.White : SKColors.Black;
+
+        if (_selectedInkColor == oldDefault)
+        {
+            _selectedInkColor = newDefault;
+            if (_toolMode == WhiteboardToolMode.Pen)
+            {
+                InkCanvas.AvaloniaSkiaInkCanvas.Settings.InkColor = _selectedInkColor;
+            }
+
+            if (InkColorPicker is not null)
+            {
+                InkColorPicker.Color = new Color(
+                    _selectedInkColor.Alpha,
+                    _selectedInkColor.Red,
+                    _selectedInkColor.Green,
+                    _selectedInkColor.Blue);
+            }
+        }
+    }
+
     public void SetComponentPlacementContext(string componentId, string? placementId)
     {
         var nextComponentId = string.IsNullOrWhiteSpace(componentId)
@@ -431,7 +461,9 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
     private void OnColorPickerColorChanged(object? sender, ColorChangedEventArgs e)
     {
         var color = e.NewColor;
-        SetInkColor(new SKColor(color.R, color.G, color.B, color.A));
+        var skColor = new SKColor(color.R, color.G, color.B, color.A);
+        _isUserCustomColor = skColor != SKColors.Black && skColor != SKColors.White;
+        SetInkColor(skColor);
     }
 
     private void OnInkThicknessSliderValueChanged(object? sender, RangeBaseValueChangedEventArgs e)
@@ -713,7 +745,8 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
             InkCanvas.AvaloniaSkiaInkCanvas.AddStaticStroke(staticStroke);
         }
 
-        UpdateInkCanvasCacheSettings(forceRefresh: true);
+        InkCanvas.AvaloniaSkiaInkCanvas.UpdateBitmapCache();
+        InkCanvas.InvalidateVisual();
     }
 
     private static InkStylusPoint ConvertStylusPoint(WhiteboardStylusPointSnapshot point)
@@ -766,7 +799,9 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
             }
         }
 
-        UpdateInkCanvasCacheSettings(forceRefresh: true);
+        InkCanvas.AvaloniaSkiaInkCanvas.UseBitmapCache(false);
+        InkCanvas.AvaloniaSkiaInkCanvas.InvalidateBitmapCache();
+        InkCanvas.InvalidateVisual();
     }
 
     private bool HasValidPersistenceContext()
@@ -784,47 +819,4 @@ public partial class WhiteboardWidget : UserControl, IDesktopComponentWidget, IC
 
         return Array.Empty<InkStylusPoint>();
     }
-
-    private void UpdateInkCanvasCacheSettings(bool forceRefresh)
-    {
-        var renderScaling = TopLevel.GetTopLevel(this)?.RenderScaling ?? 1d;
-        var widthPx = Math.Max(1d, CanvasBorder.Bounds.Width * renderScaling);
-        var heightPx = Math.Max(1d, CanvasBorder.Bounds.Height * renderScaling);
-        var longestSide = Math.Max(widthPx, heightPx);
-        var area = widthPx * heightPx;
-
-        var cacheEnabled = longestSide <= 1536d && area <= 1_400_000d;
-        var cacheSize = (int)Math.Clamp(Math.Ceiling(longestSide), 384d, 1536d);
-        if (!forceRefresh &&
-            _lastBitmapCacheEnabled == cacheEnabled &&
-            _lastBitmapCacheSize == cacheSize)
-        {
-            return;
-        }
-
-        _lastBitmapCacheEnabled = cacheEnabled;
-        _lastBitmapCacheSize = cacheSize;
-
-        var settings = InkCanvas.AvaloniaSkiaInkCanvas.Settings;
-        settings.IsBitmapCacheEnabled = cacheEnabled;
-        settings.MaxBitmapCacheSize = cacheSize;
-
-        try
-        {
-            InkCanvas.AvaloniaSkiaInkCanvas.UseBitmapCache(cacheEnabled);
-            if (cacheEnabled)
-            {
-                InkCanvas.AvaloniaSkiaInkCanvas.UpdateBitmapCache();
-            }
-            else
-            {
-                InkCanvas.AvaloniaSkiaInkCanvas.InvalidateBitmapCache();
-                InkCanvas.InvalidateVisual();
-            }
-        }
-        catch
-        {
-            // Keep drawing available even if the underlying cache backend rejects the cache update.
-        }
-    }
 }

LanMountainDesktop/Views/FusedDesktopComponentLibraryControl.axaml

@@ -1,160 +1,227 @@
 <UserControl xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:vm="using:LanMountainDesktop.ViewModels"
-             xmlns:fi="using:FluentIcons.Avalonia"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             xmlns:converters="using:Avalonia.Data.Converters"
              x:Class="LanMountainDesktop.Views.FusedDesktopComponentLibraryControl"
              x:DataType="vm:ComponentLibraryWindowViewModel">
-    
-    <Grid ColumnDefinitions="240,*"
-          ColumnSpacing="12"
+
+    <UserControl.Styles>
+        <!-- 分类列表项样式 - 遵循 Fluent NavigationView 风格 -->
+        <Style Selector="ListBoxItem.category-item">
+            <Setter Property="Padding" Value="0"/>
+            <Setter Property="Margin" Value="0,2"/>
+            <Setter Property="Background" Value="Transparent"/>
+            <Setter Property="CornerRadius" Value="{DynamicResource DesignCornerRadiusSm}"/>
+            <Setter Property="Transitions">
+                <Transitions>
+                    <BrushTransition Property="Background" Duration="0:0:0.083" Easing="0.05,0.75,0.10,1.00"/>
+                </Transitions>
+            </Setter>
+        </Style>
+        <Style Selector="ListBoxItem.category-item:pointerover /template/ ContentPresenter#PART_ContentPresenter">
+            <Setter Property="Background" Value="{DynamicResource SubtleFillColorSecondaryBrush}"/>
+        </Style>
+        <Style Selector="ListBoxItem.category-item:selected /template/ ContentPresenter#PART_ContentPresenter">
+            <Setter Property="Background" Value="{DynamicResource AdaptiveNavItemSelectedBackgroundBrush}"/>
+        </Style>
+        <Style Selector="ListBoxItem.category-item:pressed /template/ ContentPresenter#PART_ContentPresenter">
+            <Setter Property="Background" Value="{DynamicResource SubtleFillColorTertiaryBrush}"/>
+        </Style>
+
+        <!-- 分类项图标和文字 -->
+        <Style Selector="ListBoxItem.category-item fi|FluentIcon.category-icon">
+            <Setter Property="Foreground" Value="{DynamicResource AdaptiveTextPrimaryBrush}"/>
+        </Style>
+        <Style Selector="ListBoxItem.category-item:selected fi|FluentIcon.category-icon">
+            <Setter Property="Foreground" Value="{DynamicResource AdaptiveTextPrimaryBrush}"/>
+        </Style>
+
+        <Style Selector="ListBoxItem.category-item TextBlock.category-text">
+            <Setter Property="Foreground" Value="{DynamicResource AdaptiveTextPrimaryBrush}"/>
+        </Style>
+        <Style Selector="ListBoxItem.category-item:selected TextBlock.category-text">
+            <Setter Property="Foreground" Value="{DynamicResource AdaptiveTextPrimaryBrush}"/>
+            <Setter Property="FontWeight" Value="SemiBold"/>
+        </Style>
+    </UserControl.Styles>
+
+    <Grid ColumnDefinitions="Auto,*"
+          ColumnSpacing="0"
           Margin="0">
-        <!-- 分类列表 (左侧) -->
-        <Border Classes="surface-translucent-panel"
-                CornerRadius="{DynamicResource DesignCornerRadiusLg}"
-                Padding="10">
-            <Grid RowDefinitions="Auto,*">
-                <TextBox x:Name="SearchBox"
-                         Watermark="搜索组件..."
-                         Margin="0,0,0,12"
-                         Classes="clear"
-                         Background="{DynamicResource AdaptiveSurfaceLowBrush}"
-                         CornerRadius="12"
-                         Padding="12,8">
-                    <TextBox.InnerLeftContent>
-                        <fi:SymbolIcon Symbol="Search" FontSize="16" Margin="10,0,0,0" Opacity="0.5" />
-                    </TextBox.InnerLeftContent>
-                </TextBox>
-                
+        <!-- 左侧导航列 - 分类列表 + 底部"查找更多组件" -->
+        <Border Width="280"
+                Background="Transparent">
+            <Grid RowDefinitions="*,Auto">
+                <!-- 分类列表 -->
                 <ListBox x:Name="CategoryListBox"
-                         Grid.Row="1"
+                         Grid.Row="0"
                          Background="Transparent"
                          BorderThickness="0"
+                         Margin="8,8,4,0"
                          SelectionChanged="OnCategorySelectionChanged"
                          ItemsSource="{Binding Categories}">
                     <ListBox.ItemTemplate>
                         <DataTemplate x:DataType="vm:ComponentLibraryCategoryViewModel">
-                            <Border Padding="10"
-                                    Margin="0,0,0,6"
-                                    CornerRadius="{DynamicResource DesignCornerRadiusSm}"
-                                    Background="{DynamicResource AdaptiveNavItemBackgroundBrush}">
-                                <Grid ColumnDefinitions="Auto,*"
-                                      ColumnSpacing="8">
-                                    <fi:SymbolIcon Symbol="{Binding Icon}"
-                                                   IconVariant="Regular"
-                                                   FontSize="16" />
-                                    <TextBlock Grid.Column="1"
-                                               VerticalAlignment="Center"
-                                               FontWeight="SemiBold"
-                                               Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
-                                               Text="{Binding Title}" />
-                                </Grid>
-                            </Border>
+                            <Grid ColumnDefinitions="Auto,*"
+                                  ColumnSpacing="12"
+                                  Margin="12,10">
+                                <fi:FluentIcon Icon="{Binding Icon}"
+                                               IconVariant="Regular"
+                                               FontSize="18"
+                                               Classes="category-icon"/>
+                                <TextBlock Grid.Column="1"
+                                           VerticalAlignment="Center"
+                                           FontSize="14"
+                                           Classes="category-text"
+                                           Text="{Binding Title}"/>
+                            </Grid>
                         </DataTemplate>
                     </ListBox.ItemTemplate>
                 </ListBox>
+
+                <!-- 底部"查找更多组件" - 在左侧导航列底部 -->
+                <StackPanel Grid.Row="1"
+                            Margin="12,8,8,12">
+                    <Border Height="1"
+                            Background="{DynamicResource AdaptiveGlassPanelBorderBrush}"
+                            Opacity="0.4"
+                            Margin="0,0,0,8"/>
+                    <Button Classes="hyperlink"
+                            HorizontalAlignment="Left"
+                            Click="OnFindMoreComponentsClick">
+                        <StackPanel Orientation="Horizontal" Spacing="6">
+                            <fi:FluentIcon Icon="Globe" IconVariant="Regular" FontSize="14"/>
+                            <TextBlock Text="查找更多组件"/>
+                        </StackPanel>
+                    </Button>
+                </StackPanel>
             </Grid>
         </Border>
 
-        <!-- 组件网格 (右侧) -->
+        <!-- 右侧内容区与左侧的分隔线 -->
         <Border Grid.Column="1"
-                Classes="surface-translucent-strong"
-                CornerRadius="{DynamicResource DesignCornerRadiusLg}"
-                Padding="10">
-            <ScrollViewer VerticalScrollBarVisibility="Auto"
-                          HorizontalScrollBarVisibility="Disabled">
-                <ItemsControl x:Name="ComponentItemsControl"
-                              ItemsSource="{Binding Components}">
-                    <ItemsControl.ItemsPanel>
-                        <ItemsPanelTemplate>
-                            <WrapPanel Orientation="Horizontal" />
-                        </ItemsPanelTemplate>
-                    </ItemsControl.ItemsPanel>
+                Width="1"
+                HorizontalAlignment="Left"
+                Background="{DynamicResource AdaptiveGlassPanelBorderBrush}"
+                Opacity="0.5"/>
 
-                    <ItemsControl.ItemTemplate>
-                        <DataTemplate x:DataType="vm:ComponentLibraryItemViewModel">
-                            <Border Width="240"
-                                    Height="220"
-                                    Margin="6"
-                                    CornerRadius="{DynamicResource DesignCornerRadiusComponent}"
-                                    Padding="10"
-                                    Background="{DynamicResource AdaptiveSurfaceRaisedBrush}"
-                                    BorderBrush="{DynamicResource AdaptiveButtonBorderBrush}"
-                                    BorderThickness="1">
-                                <Grid RowDefinitions="*,Auto,Auto"
-                                      RowSpacing="8">
-                                    <!-- 预览区域 -->
-                                    <Border CornerRadius="{DynamicResource DesignCornerRadiusSm}"
-                                            Background="{DynamicResource AdaptiveGlassPanelBackgroundBrush}"
-                                            BorderThickness="1"
-                                            BorderBrush="{DynamicResource AdaptiveGlassPanelBorderBrush}"
-                                            Padding="8">
-                                        <Grid>
-                                            <Image Source="{Binding PreviewBitmap}"
-                                                   Stretch="Uniform"
-                                                   HorizontalAlignment="Stretch"
-                                                   VerticalAlignment="Stretch"
-                                                   RenderOptions.BitmapInterpolationMode="HighQuality"
-                                                   IsVisible="{Binding IsPreviewReady}" />
+        <!-- 组件预览区 (右侧) -->
+        <ScrollViewer Grid.Column="1"
+                      VerticalScrollBarVisibility="Auto"
+                      HorizontalScrollBarVisibility="Disabled">
+            <StackPanel Margin="16,8,12,8"
+                        Spacing="0">
 
-                                            <!-- 加载中状态 -->
-                                            <Border IsVisible="{Binding IsPreviewPending}"
-                                                    Background="{DynamicResource AdaptiveSurfaceBaseBrush}">
-                                                <StackPanel HorizontalAlignment="Center"
-                                                            VerticalAlignment="Center"
-                                                            Spacing="8">
-                                                    <ProgressBar Width="96"
-                                                                 IsIndeterminate="True" />
-                                                    <TextBlock HorizontalAlignment="Center"
-                                                               TextAlignment="Center"
-                                                               FontSize="12"
-                                                               Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
-                                                               Text="{Binding PreviewStatusText}" />
-                                                </StackPanel>
-                                            </Border>
+                <!-- 有选中组件时的显示 -->
+                <Panel IsVisible="{Binding SelectedComponent, Converter={x:Static converters:ObjectConverters.IsNotNull}}">
 
-                                            <!-- 失败状态 -->
-                                            <Border IsVisible="{Binding IsPreviewFailed}"
-                                                    Background="{DynamicResource AdaptiveSurfaceBaseBrush}">
-                                                <StackPanel HorizontalAlignment="Center"
-                                                            VerticalAlignment="Center"
-                                                            Spacing="8">
-                                                    <TextBlock HorizontalAlignment="Center"
-                                                               TextAlignment="Center"
-                                                               FontWeight="SemiBold"
-                                                               Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
-                                                               Text="{Binding PreviewStatusText}" />
-                                                    <TextBlock HorizontalAlignment="Center"
-                                                               TextAlignment="Center"
-                                                               FontSize="12"
-                                                               TextWrapping="Wrap"
-                                                               Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
-                                                               Text="{Binding PreviewErrorMessage}" />
-                                                </StackPanel>
-                                            </Border>
-                                        </Grid>
+                    <!-- 组件展示面板 - 有独立背景色，与窗口背景形成层级分界 -->
+                    <Border Classes="surface-translucent-panel"
+                            CornerRadius="{DynamicResource DesignCornerRadiusLg}"
+                            Padding="20">
+                        <StackPanel Spacing="16">
+                            <!-- 组件标题 -->
+                            <TextBlock FontSize="28"
+                                       FontWeight="SemiBold"
+                                       Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                                       Text="{Binding SelectedComponent.DisplayName}"/>
+
+                            <!-- 固定大小的预览卡片 -->
+                            <Border CornerRadius="{DynamicResource DesignCornerRadiusSm}"
+                                    Background="{DynamicResource AdaptiveSurfaceBaseBrush}"
+                                    BorderBrush="{DynamicResource AdaptiveGlassPanelBorderBrush}"
+                                    BorderThickness="1"
+                                    Width="420"
+                                    Height="300"
+                                    HorizontalAlignment="Center">
+                                <Grid Margin="16">
+                                    <!-- 预览图片 -->
+                                    <Image Source="{Binding SelectedComponent.PreviewBitmap}"
+                                           Stretch="Uniform"
+                                           HorizontalAlignment="Center"
+                                           VerticalAlignment="Center"
+                                           RenderOptions.BitmapInterpolationMode="HighQuality"
+                                           IsVisible="{Binding SelectedComponent.IsPreviewReady}"/>
+
+                                    <!-- 加载中状态 -->
+                                    <Border IsVisible="{Binding SelectedComponent.IsPreviewPending}"
+                                            Background="{DynamicResource AdaptiveSurfaceBaseBrush}">
+                                        <StackPanel HorizontalAlignment="Center"
+                                                    VerticalAlignment="Center"
+                                                    Spacing="12">
+                                            <ProgressBar Width="120"
+                                                         IsIndeterminate="True"/>
+                                            <TextBlock HorizontalAlignment="Center"
+                                                       TextAlignment="Center"
+                                                       FontSize="14"
+                                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                                       Text="{Binding SelectedComponent.PreviewStatusText}"/>
+                                        </StackPanel>
                                     </Border>
 
-                                    <!-- 组件名称 -->
-                                    <TextBlock Grid.Row="1"
-                                               HorizontalAlignment="Center"
-                                               FontWeight="SemiBold"
-                                               Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
-                                               Text="{Binding DisplayName}" />
-
-                                    <!-- 添加按钮 -->
-                                    <Button Grid.Row="2"
-                                            HorizontalAlignment="Center"
-                                            Padding="12,6"
-                                            Tag="{Binding ComponentId}"
-                                            Click="OnAddComponentClick">
-                                        <TextBlock Text="添加到桌面" />
-                                    </Button>
+                                    <!-- 失败状态 -->
+                                    <Border IsVisible="{Binding SelectedComponent.IsPreviewFailed}"
+                                            Background="{DynamicResource AdaptiveSurfaceBaseBrush}">
+                                        <StackPanel HorizontalAlignment="Center"
+                                                    VerticalAlignment="Center"
+                                                    Spacing="8">
+                                            <fi:FluentIcon Icon="ImageOff"
+                                                           IconVariant="Regular"
+                                                           FontSize="48"
+                                                           Opacity="0.5"
+                                                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"/>
+                                            <TextBlock HorizontalAlignment="Center"
+                                                       TextAlignment="Center"
+                                                       FontWeight="SemiBold"
+                                                       Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                                                       Text="{Binding SelectedComponent.PreviewStatusText}"/>
+                                            <TextBlock HorizontalAlignment="Center"
+                                                       TextAlignment="Center"
+                                                       FontSize="12"
+                                                       TextWrapping="Wrap"
+                                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                                       Text="{Binding SelectedComponent.PreviewErrorMessage}"/>
+                                        </StackPanel>
+                                    </Border>
                                 </Grid>
                             </Border>
-                        </DataTemplate>
-                    </ItemsControl.ItemTemplate>
-                </ItemsControl>
-            </ScrollViewer>
-        </Border>
+
+                            <!-- "添加小组件"按钮 - 在面板内居中，使用主题强调色 -->
+                            <Button HorizontalAlignment="Center"
+                                    Classes="accent"
+                                    Padding="24,10"
+                                    Tag="{Binding SelectedComponent.ComponentId}"
+                                    Click="OnAddComponentClick">
+                                <StackPanel Orientation="Horizontal" Spacing="8">
+                                    <fi:FluentIcon Icon="Add" IconVariant="Regular" FontSize="16"/>
+                                    <TextBlock Text="添加小组件" FontWeight="SemiBold"/>
+                                </StackPanel>
+                            </Button>
+                        </StackPanel>
+                    </Border>
+                </Panel>
+
+                <!-- 空状态 -->
+                <Grid IsVisible="{Binding SelectedComponent, Converter={x:Static converters:ObjectConverters.IsNull}}"
+                      HorizontalAlignment="Center"
+                      VerticalAlignment="Center"
+                      MinHeight="400">
+                    <StackPanel Spacing="16" HorizontalAlignment="Center"
+                                VerticalAlignment="Center">
+                        <fi:FluentIcon Icon="Apps"
+                                       IconVariant="Regular"
+                                       FontSize="64"
+                                       Opacity="0.3"
+                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"/>
+                        <TextBlock HorizontalAlignment="Center"
+                                   FontSize="16"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="请从左侧选择一个组件"/>
+                    </StackPanel>
+                </Grid>
+            </StackPanel>
+        </ScrollViewer>
     </Grid>
 </UserControl>

LanMountainDesktop/Views/FusedDesktopComponentLibraryControl.axaml.cs

@@ -4,6 +4,7 @@ using System.Linq;
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
+using Avalonia.VisualTree;
 using FluentIcons.Common;
 using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Services;
@@ -29,6 +30,8 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
     private readonly IRecommendationInfoService _recommendationInfoService = new RecommendationDataService();
     private readonly ICalculatorDataService _calculatorDataService = new CalculatorDataService();
 
+    private static readonly LocalizationService _localizationService = new();
+
     public FusedDesktopComponentLibraryControl()
     {
         InitializeComponent();
@@ -39,7 +42,9 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
 
         LoadRegistry();
         LoadCategories();
-        SearchBox.KeyUp += (s, e) => FilterComponents();
+
+        // 为 ListBoxItem 添加 category-item 样式类
+        CategoryListBox.ContainerPrepared += OnCategoryListBoxContainerPrepared;
 
         // 默认选择第一个分类
         if (_viewModel.Categories.Count > 0)
@@ -48,6 +53,14 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
         }
     }
 
+    private void OnCategoryListBoxContainerPrepared(object? sender, ContainerPreparedEventArgs e)
+    {
+        if (e.Container is ListBoxItem listBoxItem)
+        {
+            listBoxItem.Classes.Add("category-item");
+        }
+    }
+
     private void LoadRegistry()
     {
         var pluginRuntimeService = (Application.Current as App)?.PluginRuntimeService;
@@ -65,28 +78,16 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
     private void LoadCategories()
     {
         _viewModel.Categories.Clear();
-        _viewModel.Components.Clear();
+
+        var languageCode = _settingsFacade.Region.Get().LanguageCode;
 
         // 添加"全部组件"分类
         _viewModel.Categories.Add(new ComponentLibraryCategoryViewModel(
             "all",
-            "全部组件",
+            L(languageCode, "component_category.all", "All"),
             Symbol.Apps,
             Array.Empty<ComponentLibraryItemViewModel>()));
 
-        var categoryMap = new Dictionary<string, (string Display, Symbol Icon)>
-        {
-            { "clock", ("时钟", Symbol.Clock) },
-            { "date", ("日历", Symbol.CalendarDate) },
-            { "weather", ("天气", Symbol.WeatherSunny) },
-            { "board", ("画板", Symbol.Edit) },
-            { "media", ("媒体", Symbol.Play) },
-            { "info", ("资讯", Symbol.News) },
-            { "calculator", ("工具", Symbol.Calculator) },
-            { "study", ("学习", Symbol.Hourglass) },
-            { "file", ("文件", Symbol.Folder) }
-        };
-
         var usedCategories = _allDefinitions
             .Select(d => d.Category)
             .Distinct()
@@ -94,23 +95,62 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
 
         foreach (var cat in usedCategories)
         {
-            if (categoryMap.TryGetValue(cat.ToLower(), out var info))
-            {
-                var categoryComponents = _allDefinitions
-                    .Where(d => string.Equals(d.Category, cat, StringComparison.OrdinalIgnoreCase))
-                    .OrderBy(d => d.DisplayName)
-                    .Select(d => CreateComponentItem(d))
-                    .ToArray();
+            var icon = ResolveCategoryIcon(cat);
+            var title = GetLocalizedCategoryTitle(languageCode, cat);
 
-                _viewModel.Categories.Add(new ComponentLibraryCategoryViewModel(
-                    cat,
-                    info.Display,
-                    info.Icon,
-                    categoryComponents));
-            }
+            var categoryComponents = _allDefinitions
+                .Where(d => string.Equals(d.Category, cat, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(d => d.DisplayName)
+                .Select(d => CreateComponentItem(d))
+                .ToArray();
+
+            _viewModel.Categories.Add(new ComponentLibraryCategoryViewModel(
+                cat,
+                title,
+                icon,
+                categoryComponents));
         }
     }
 
+    /// <summary>
+    /// 分类图标映射 - 与阑山桌面 Dock 栏组件库 (MainWindow.ComponentSystem) 保持一致
+    /// </summary>
+    private static Symbol ResolveCategoryIcon(string categoryId)
+    {
+        if (string.Equals(categoryId, "Clock", StringComparison.OrdinalIgnoreCase)) return Symbol.Clock;
+        if (string.Equals(categoryId, "Date", StringComparison.OrdinalIgnoreCase)) return Symbol.CalendarDate;
+        if (string.Equals(categoryId, "Weather", StringComparison.OrdinalIgnoreCase)) return Symbol.WeatherSunny;
+        if (string.Equals(categoryId, "Board", StringComparison.OrdinalIgnoreCase)) return Symbol.Edit;
+        if (string.Equals(categoryId, "Media", StringComparison.OrdinalIgnoreCase)) return Symbol.Play;
+        if (string.Equals(categoryId, "Info", StringComparison.OrdinalIgnoreCase)) return Symbol.Apps;
+        if (string.Equals(categoryId, "Calculator", StringComparison.OrdinalIgnoreCase)) return Symbol.Calculator;
+        if (string.Equals(categoryId, "Study", StringComparison.OrdinalIgnoreCase)) return Symbol.Hourglass;
+        if (string.Equals(categoryId, "File", StringComparison.OrdinalIgnoreCase)) return Symbol.Folder;
+        return Symbol.Apps;
+    }
+
+    /// <summary>
+    /// 分类本地化标题 - 与阑山桌面 Dock 栏组件库 (MainWindow.ComponentSystem) 保持一致
+    /// </summary>
+    private string GetLocalizedCategoryTitle(string languageCode, string categoryId)
+    {
+        if (string.Equals(categoryId, "Clock", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.clock", "Clock");
+        if (string.Equals(categoryId, "Date", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.date", "Calendar");
+        if (string.Equals(categoryId, "Weather", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.weather", "Weather");
+        if (string.Equals(categoryId, "Board", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.board", "Board");
+        if (string.Equals(categoryId, "Media", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.media", "Media");
+        if (string.Equals(categoryId, "Info", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.info", "Info");
+        if (string.Equals(categoryId, "Calculator", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.calculator", "Calculator");
+        if (string.Equals(categoryId, "Study", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.study", "Study");
+        if (string.Equals(categoryId, "File", StringComparison.OrdinalIgnoreCase)) return L(languageCode, "component_category.file", "File");
+        return categoryId;
+    }
+
+    private string L(string languageCode, string key, string fallback)
+    {
+        return _localizationService.GetString(languageCode, key, fallback);
+    }
+
     private ComponentLibraryItemViewModel CreateComponentItem(DesktopComponentDefinition definition)
     {
         var previewKey = ComponentPreviewKey.ForComponentType(
@@ -130,10 +170,11 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
             definition.Id,
             definition.DisplayName,
             previewKey,
+            description: null,
             "正在加载预览...",
             "预览不可用",
             previewEntry);
-            
+
         if (mainWindow is not null && (previewEntry is null || previewEntry.State == ComponentPreviewImageState.Pending))
         {
             mainWindow.RequestDetachedLibraryPreview(previewKey);
@@ -158,25 +199,49 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
 
     private void OnCategorySelectionChanged(object? sender, SelectionChangedEventArgs e)
     {
-        FilterComponents();
+        UpdateSelectedComponent();
     }
 
-    private void FilterComponents()
+    private void UpdateSelectedComponent()
     {
-        var selectedCategory = (CategoryListBox.SelectedItem as ComponentLibraryCategoryViewModel)?.Id;
-        var searchText = SearchBox.Text?.ToLower() ?? "";
-
-        var filtered = _allDefinitions.Where(d =>
+        var selectedCategory = CategoryListBox.SelectedItem as ComponentLibraryCategoryViewModel;
+        if (selectedCategory is null)
         {
-            var matchesCategory = selectedCategory == "all" || string.Equals(d.Category, selectedCategory, StringComparison.OrdinalIgnoreCase);
-            var matchesSearch = string.IsNullOrEmpty(searchText) || d.DisplayName.ToLower().Contains(searchText) || d.Id.ToLower().Contains(searchText);
-            return matchesCategory && matchesSearch;
-        });
+            _viewModel.SelectedComponent = null;
+            return;
+        }
 
-        _viewModel.Components.Clear();
-        foreach (var def in filtered)
+        // 获取该分类下的组件列表
+        IEnumerable<DesktopComponentDefinition> filtered;
+        if (selectedCategory.Id == "all")
         {
-            _viewModel.Components.Add(CreateComponentItem(def));
+            filtered = _allDefinitions.OrderBy(d => d.DisplayName);
+        }
+        else
+        {
+            filtered = _allDefinitions
+                .Where(d => string.Equals(d.Category, selectedCategory.Id, StringComparison.OrdinalIgnoreCase))
+                .OrderBy(d => d.DisplayName);
+        }
+
+        // 选择该分类下的第一个组件作为默认选中
+        var firstComponent = filtered.FirstOrDefault();
+        if (firstComponent is not null)
+        {
+            // 查找或创建对应的 ViewModel
+            var existingComponent = selectedCategory.Components.FirstOrDefault(c => c.ComponentId == firstComponent.Id);
+            if (existingComponent is not null)
+            {
+                _viewModel.SelectedComponent = existingComponent;
+            }
+            else
+            {
+                _viewModel.SelectedComponent = CreateComponentItem(firstComponent);
+            }
+        }
+        else
+        {
+            _viewModel.SelectedComponent = null;
         }
     }
 
@@ -187,4 +252,22 @@ public partial class FusedDesktopComponentLibraryControl : UserControl
             AddComponentRequested?.Invoke(this, componentId);
         }
     }
+
+    private void OnFindMoreComponentsClick(object? sender, RoutedEventArgs e)
+    {
+        // 打开设置窗口并导航到插件目录页面
+        if (Application.Current is App app && app.SettingsWindowService is { } settingsWindowService)
+        {
+            var mainWindow = (Application.Current?.ApplicationLifetime as IClassicDesktopStyleApplicationLifetime)?.MainWindow as MainWindow;
+            var request = new SettingsWindowOpenRequest(
+                Source: "FusedDesktopComponentLibrary",
+                Owner: mainWindow,
+                PageId: "plugin-catalog");
+            settingsWindowService.Open(request);
+        }
+
+        // 关闭所在窗口
+        var window = this.FindAncestorOfType<Window>();
+        window?.Close();
+    }
 }

LanMountainDesktop/Views/FusedDesktopComponentLibraryWindow.axaml

@@ -1,57 +1,73 @@
 <Window xmlns="https://github.com/avaloniaui"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:controls="using:LanMountainDesktop.Views"
-        xmlns:fi="using:FluentIcons.Avalonia"
+        xmlns:fi="using:FluentIcons.Avalonia.Fluent"
         x:Class="LanMountainDesktop.Views.FusedDesktopComponentLibraryWindow"
         Width="860" Height="620"
         MinWidth="600" MinHeight="500"
+        CanResize="True"
         WindowStartupLocation="CenterScreen"
-        SystemDecorations="Full"
+        SystemDecorations="BorderOnly"
         ExtendClientAreaToDecorationsHint="True"
         ExtendClientAreaChromeHints="NoChrome"
-        ExtendClientAreaTitleBarHeightHint="-1"
+        ExtendClientAreaTitleBarHeightHint="48"
         Background="Transparent"
-        TransparencyLevelHint="Mica"
-        Title="融合桌面组件库">
-    
-    <Panel>
-        <!-- 背景磨砂效果 -->
-        <Border Background="{DynamicResource AdaptiveSurfaceLowBrush}"
-                Opacity="0.85" />
-        
-        <Grid RowDefinitions="Auto,*">
-            <!-- 自定义标题栏 -->
-            <Border Background="Transparent"
-                    IsHitTestVisible="True"
-                    Padding="20,16">
-                <Grid ColumnDefinitions="*,Auto">
-                    <StackPanel Spacing="6" VerticalAlignment="Center">
-                        <TextBlock Text="融合桌面组件库"
-                                   FontWeight="SemiBold"
-                                   FontSize="20"
-                                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
-                        <TextBlock Text="将精美组件放置在您的系统桌面上（负一屏）"
-                                   Opacity="0.6"
-                                   FontSize="13"
-                                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
-                    </StackPanel>
-                    
-                    <Button Grid.Column="1"
-                            Classes="accent"
-                            Width="36" Height="36"
-                            Padding="0"
-                            CornerRadius="18"
-                            BorderThickness="0"
-                            Background="{DynamicResource AdaptiveButtonHoverBackgroundBrush}"
-                            Click="OnCloseClick">
-                        <fi:SymbolIcon Symbol="Dismiss" FontSize="18" />
-                    </Button>
-                </Grid>
-            </Border>
-            
-            <!-- 组件库控件 -->
-            <controls:FusedDesktopComponentLibraryControl x:Name="LibraryControl"
-                                                          Grid.Row="1" />
-        </Grid>
-    </Panel>
+        Title="添加小组件">
+
+    <Grid x:Name="RootGrid"
+          Classes="settings-scope"
+          Background="{DynamicResource AdaptiveSettingsWindowBackgroundBrush}"
+          RowDefinitions="Auto,*">
+        <!-- 自定义标题栏 - 与 SettingsWindow 风格一致 -->
+        <Border x:Name="WindowTitleBarHost"
+                Height="48"
+                Padding="12,0,12,0"
+                Background="{DynamicResource AdaptiveSettingsWindowBackgroundBrush}"
+                BorderBrush="{DynamicResource AdaptiveSettingsWindowBorderBrush}"
+                BorderThickness="0,0,0,1"
+                PointerPressed="OnWindowTitleBarPointerPressed">
+            <Grid ColumnDefinitions="Auto,Auto,*,Auto"
+                  ColumnSpacing="8"
+                  VerticalAlignment="Center">
+                <fi:FluentIcon x:Name="WindowBrandIcon"
+                               Icon="Apps"
+                               IconVariant="Filled"
+                               FontSize="16"
+                               IsHitTestVisible="False"
+                               VerticalAlignment="Center" />
+
+                <TextBlock x:Name="WindowTitleTextBlock"
+                           Grid.Column="1"
+                           FontSize="12"
+                           FontWeight="SemiBold"
+                           IsHitTestVisible="False"
+                           Text="添加小组件" />
+
+                <TextBlock Grid.Column="2"
+                           FontSize="12"
+                           Opacity="0.6"
+                           IsHitTestVisible="False"
+                           VerticalAlignment="Center"
+                           Text="将精美组件放置在您的系统桌面上（负一屏）" />
+
+                <Button x:Name="CloseWindowButton"
+                        Grid.Column="3"
+                        Width="40"
+                        Height="32"
+                        Padding="0"
+                        Background="Transparent"
+                        BorderThickness="0"
+                        Click="OnCloseClick">
+                    <fi:FluentIcon Icon="Dismiss"
+                                   IconVariant="Regular"
+                                   FontSize="16" />
+                </Button>
+            </Grid>
+        </Border>
+
+        <!-- 组件库控件 -->
+        <controls:FusedDesktopComponentLibraryControl x:Name="LibraryControl"
+                                                      Grid.Row="1"
+                                                      Margin="12,8,16,8" />
+    </Grid>
 </Window>