fix: delegate upgrade process launch to ClientStrategy in silent mode

OnProcessExit was manually resolving the updater path and calling
Process.Start, bypassing the configured OS strategy. This meant:
- Custom strategies registered via Strategy<T>() were ignored for path
  resolution
- The OnBeforeStartAppAsync lifecycle hook (e.g. UnixPermissionHooks for
  chmod +x) was never invoked in silent mode

Solution:
- AbstractStrategy: add internal StartProcess() that reuses ResolveAppPath
- ClientStrategy: add LaunchUpgradeProcessSync() that runs the pre-launch
  hook and delegates path resolution + process start to the OS strategy
- SilentPollOrchestrator: OnProcessExit now calls the strategy instead of
  hand-rolling path logic

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: JusterZhu

src/c#/GeneralUpdate.Core/Silent/SilentPollOrchestrator.cs

@@ -1,6 +1,4 @@
 using System;
-using System.Diagnostics;
-using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using GeneralUpdate.Core.Configuration;
@@ -142,7 +140,9 @@ private async Task PollLoopAsync(CancellationToken token)
     /// </summary>
     /// <remarks>
     /// The encrypted IPC file was already written by <see cref="ClientStrategy.SendProcessIpc"/>
-    /// during the last successful poll cycle. This handler only starts the upgrade executable.
+    /// during the last successful poll cycle. This handler delegates the actual process
+    /// launch to <see cref="ClientStrategy.LaunchUpgradeProcessSync"/>, which reuses the
+    /// configured OS strategy for path resolution and runs the pre-launch lifecycle hook.
     /// </remarks>
     private void OnProcessExit(object? sender, EventArgs e)
     {
@@ -159,21 +159,8 @@ private void OnProcessExit(object? sender, EventArgs e)
                 return;
             }
 
-            var updaterDir = !string.IsNullOrWhiteSpace(_configInfo.UpdatePath)
-                ? (Path.IsPathRooted(_configInfo.UpdatePath)
-                    ? _configInfo.UpdatePath
-                    : Path.Combine(_configInfo.InstallPath, _configInfo.UpdatePath))
-                : _configInfo.InstallPath;
-            var updaterPath = Path.Combine(updaterDir, _configInfo.UpdateAppName);
-
-            if (!File.Exists(updaterPath))
-            {
-                GeneralTracer.Warn($"SilentPollOrchestrator: updater not found at {updaterPath}, cannot launch.");
-                return;
-            }
-
-            Process.Start(new ProcessStartInfo { UseShellExecute = true, FileName = updaterPath });
-            GeneralTracer.Info($"SilentPollOrchestrator: launched updater {updaterPath}");
+            _strategy.LaunchUpgradeProcessSync();
+            GeneralTracer.Info("SilentPollOrchestrator: upgrade process launched via ClientStrategy.");
         }
         catch (Exception ex)
         {

src/c#/GeneralUpdate.Core/Strategy/AbstractStrategy.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -322,6 +323,23 @@ protected string ResolveAppPath(string name, bool preferUpdatePath = false)
             return CheckPath(_configinfo.InstallPath, name);
         }
 
+        /// <summary>
+        /// Resolves and starts the target executable using the strategy's platform-specific
+        /// path resolution logic. Does not perform any additional work (no hooks, no shutdown).
+        /// For use by callers that only need process launch, e.g. <see cref="Silent.SilentPollOrchestrator"/>.
+        /// </summary>
+        /// <param name="appName">The name of the executable to launch.</param>
+        /// <param name="preferUpdatePath">When <c>true</c>, checks <c>UpdatePath</c> first.</param>
+        /// <exception cref="FileNotFoundException">Thrown when the executable cannot be resolved.</exception>
+        internal void StartProcess(string appName, bool preferUpdatePath = false)
+        {
+            var appPath = ResolveAppPath(appName, preferUpdatePath);
+            if (string.IsNullOrEmpty(appPath))
+                throw new FileNotFoundException($"Can't find the app {appName}!");
+            GeneralTracer.Info($"AbstractStrategy.StartProcess: launching {appPath}");
+            Process.Start(appPath);
+        }
+
         /// <summary>
         /// Resolves the target application path for the update package. Determines whether to use the update path or install path
         /// based on the version's application type.

src/c#/GeneralUpdate.Core/Strategy/ClientStrategy.cs

@@ -674,6 +674,52 @@ private async Task LaunchUpgradeProcessAsync()
         await _osStrategy!.StartAppAsync();
     }
 
+    /// <summary>
+    /// Synchronously launches the upgrade process via the configured OS strategy
+    /// after running the pre-launch lifecycle hook. Designed for
+    /// <see cref="Silent.SilentPollOrchestrator"/> to call from
+    /// <see cref="AppDomain.ProcessExit"/>, where the process is already shutting
+    /// down and only path resolution + hook + process start are needed.
+    /// </summary>
+    /// <remarks>
+    /// Unlike <see cref="LaunchUpgradeProcessAsync"/>, this method does NOT call
+    /// <see cref="AbstractStrategy.StartAppAsync"/> — it only resolves the path
+    /// via the strategy's <see cref="AbstractStrategy.ResolveAppPath"/> and starts
+    /// the process, without the extra shutdown / Bowl / tracer-dispose work that
+    /// is only appropriate when the current process is about to exit voluntarily.
+    /// </remarks>
+    internal void LaunchUpgradeProcessSync()
+    {
+        // Run the pre-launch lifecycle hook (e.g. UnixPermissionHooks for chmod +x).
+        // In the standard flow this runs inside ExecuteStandardWorkflowAsync; in
+        // silent mode it was deferred and must run now, before the process starts.
+        var ctx = BuildUpdateContext();
+        SafeOnBeforeStartAppAsync(ctx).GetAwaiter().GetResult();
+
+        if (_osStrategy is AbstractStrategy abs)
+        {
+            abs.LaunchAppName = _configInfo!.UpdateAppName;
+            abs.LaunchBowl = false;
+            abs.UseUpdatePath = !string.IsNullOrWhiteSpace(_configInfo.UpdatePath);
+            abs.StartProcess(abs.LaunchAppName!, abs.UseUpdatePath);
+            return;
+        }
+
+        // Fallback: custom IStrategy (non-AbstractStrategy).
+        // For a custom strategy we can't use the platform path resolution, so we
+        // fall back to a simple InstallPath + UpdateAppName lookup.
+        var updaterDir = !string.IsNullOrWhiteSpace(_configInfo!.UpdatePath)
+            ? (Path.IsPathRooted(_configInfo.UpdatePath)
+                ? _configInfo.UpdatePath
+                : Path.Combine(_configInfo.InstallPath, _configInfo.UpdatePath))
+            : _configInfo.InstallPath;
+        var appPath = Path.Combine(updaterDir, _configInfo.UpdateAppName);
+        if (!File.Exists(appPath))
+            throw new FileNotFoundException($"Upgrade application not found: {appPath}");
+        GeneralTracer.Info($"ClientStrategy: launching upgrade process {appPath}");
+        Process.Start(appPath);
+    }
+
     #endregion
 
     #region Helpers