fix: second review pass on the tray app and install

- a failed optimize start no longer switches the watchdog off; after a
  run, watch only a result that was saved
- tray and window apply/revert refuse while gao --optimize runs
- install checks both sources first and moves aside only a copy in use
- a clean exit or logoff within the 2-minute grace clears the strike
- emergency resets use the process-lifetime GpuControl, not the worker's
- gao --reset notifies the tray before it writes, closing a race with
  a watchdog tick

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

Author: Rovey

README.md

@@ -44,7 +44,7 @@ That builds two programs in `.\build\Release\`: `GpuAutoOptimizer.exe`, the wind
 
 Start `GpuAutoOptimizer.exe`. The window shows the GPU, live telemetry, the saved tune and what is applied right now; pick a preset and press **Optimize** (it offers to restart as administrator first, because tuning writes clocks and power limits). The run screen shows temperature, power and every probe as it happens; **Abort** restores stock. The results screen compares before and after and can turn on **apply at every logon**.
 
-With apply-at-logon on, Windows starts the app in the tray at every logon. It applies the saved tune and then keeps it applied: every 30 seconds it reads back what the driver reports. If the tune was reset (a driver reset or TDR), it applies it again; if that happens four times within an hour it stops and tells you the tune is probably not stable; if another program such as MSI Afterburner changed the settings, it leaves them alone and tells you; after a driver update it does not apply the old tune and tells you to optimize again. While it keeps a tune applied (or a run is in progress), closing the window keeps it in the tray and **Exit** in the tray menu quits; otherwise closing the window quits. **Revert to stock** in the tray menu, or `gao --reset` from a shell, puts the card at stock and the watchdog leaves it there until you apply the tune again. Only one optimize runs at a time, from the window or the command line.
+With apply-at-logon on, Windows starts the app in the tray at every logon. It applies the saved tune and then keeps it applied: every 30 seconds it reads back what the driver reports. If the tune was reset (a driver reset or TDR), it applies it again; if that happens four times within an hour it stops and tells you the tune is probably not stable; if another program such as MSI Afterburner changed the settings, it leaves them alone and tells you; after a driver update it does not apply the old tune and tells you to optimize again. While it keeps a tune applied (or a run is in progress), closing the window keeps it in the tray and **Exit** in the tray menu quits; otherwise closing the window quits. **Revert to stock** in the tray menu, or `gao --reset` from a shell, puts the card at stock and the watchdog leaves it there until you apply the tune again from the window or the tray menu (`gao --apply` applies it but does not switch the watchdog back on). Only one optimize runs at a time, from the window or the command line.
 
 ### The command line
 

src/app/common.cpp

@@ -223,7 +223,7 @@ bool enable_boot(std::string* message) {
     const DWORD n = GetModuleFileNameW(nullptr, self, MAX_PATH);
     if (n == 0 || n >= MAX_PATH) return say("could not find this program's own path", false);
     if (!install_app(std::filesystem::path(self).parent_path(), &why))
-        return say(why + " (if the tray app is running from Program Files, exit it and retry)", false);
+        return say(why, false);
     // The logon task starts the tray app, which applies the tune and stays
     // resident to keep it applied: no time limit.
     const auto exe = installed_tray_path();

src/app/gui/main_gui.cpp

@@ -76,6 +76,7 @@ struct App {
     gao::Watchdog watchdog;
     bool watch = false;   // keep the saved tune applied (off after a revert or a reset by choice)
     bool worker_was_running = false;
+    bool strike_pending = false;   // a logon apply whose 2-minute grace has not passed yet
 
     // Crash dumps are written by a thread created up front (a crashing thread
     // may have no stack or heap left to do it itself).
@@ -113,8 +114,9 @@ LONG WINAPI on_crash(EXCEPTION_POINTERS* ep) {
     g.crash_thread = GetCurrentThreadId();
     SetEvent(g.dump_request);
     WaitForSingleObject(g.dump_done, 15000);
-    if (g.worker && g.worker->active_gpu() && g.worker->active_gpu()->reset_to_stock)
-        g.worker->active_gpu()->reset_to_stock();   // never leave a candidate applied
+    // Never leave a candidate applied. Through our own GpuControl, which lives
+    // as long as the process; the worker's may be mid-teardown.
+    if (g.worker && g.worker->running() && g.gpu.reset_to_stock) g.gpu.reset_to_stock();
     return EXCEPTION_EXECUTE_HANDLER;
 }
 
@@ -220,7 +222,7 @@ void show_window() {
 }
 
 void tray_menu(int x, int y) {
-    const bool busy = g.worker->running();
+    const bool busy = g.worker->running() || gao::app::tuning_in_progress();
     HMENU menu = CreatePopupMenu();
     AppendMenuW(menu, MF_STRING, kMenuOpen, L"Open");
     if (g.ui.elevated) {
@@ -259,8 +261,7 @@ void refresh_status(bool with_task) {
 
 void act_optimize(gao::Preset preset) {
     g.ui.message.clear();
-    g.watch = false;   // the search owns the GPU until it is done
-    g.worker->start(preset);
+    g.worker->start(preset);   // the watchdog skips while it runs
 }
 
 void act_abort() { g.worker->abort(); }
@@ -285,8 +286,15 @@ void act_restart_elevated() {
     }
 }
 
+bool refuse_while_tuning() {
+    if (g.worker->running()) return true;
+    if (!gao::app::tuning_in_progress()) return false;
+    g.ui.message = "An optimize is running on the command line; wait for it to finish.";
+    return true;
+}
+
 void act_apply() {
-    if (g.worker->running()) return;
+    if (refuse_while_tuning()) return;
     std::string why;
     if (!gao::app::prepare_state(&why)) { g.ui.message = why; return; }
     gao::Config cfg = gao::app::load_config();
@@ -302,7 +310,7 @@ void act_apply() {
 }
 
 void act_revert() {
-    if (g.worker->running()) return;
+    if (refuse_while_tuning()) return;
     const bool ok = g.gpu.reset_to_stock && g.gpu.reset_to_stock();
     g.watch = false;   // stock by choice: the watchdog must not undo it
     g.ui.message = ok ? "Back at stock. The saved tune is not re-applied until you apply it again."
@@ -356,8 +364,12 @@ void on_telemetry() {
     const bool running = g.worker->running();
     if (g.worker_was_running && !running) {
         const auto snap = g.worker->snapshot();
-        g.watch = snap.outcome && snap.outcome->ran && snap.outcome->result.ok;
-        g.watchdog = gao::Watchdog();
+        // A run that never started left the GPU alone: keep watching as before.
+        // One that ran ends either at its saved result or at stock.
+        if (snap.outcome && snap.outcome->ran) {
+            g.watch = snap.outcome->result.ok && snap.outcome->saved;
+            g.watchdog = gao::Watchdog();
+        }
         refresh_status(false);
     }
     g.worker_was_running = running;
@@ -403,6 +415,15 @@ void on_watchdog() {
 
 // ---------------------------------------------------------------- window
 
+// The strike counts crashes during the first 2 minutes after a logon apply.
+// A clean exit or logoff in that time is not a crash: clear it then too.
+void clear_strike() {
+    if (!g.strike_pending) return;
+    g.strike_pending = false;
+    KillTimer(g.hwnd, kTimerStrike);
+    gao::app::clear_boot_strike();
+}
+
 LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
     if (ImGui_ImplWin32_WndProcHandler(hwnd, msg, wp, lp)) return 1;
     if (msg == g.taskbar_created && g.taskbar_created) {   // Explorer restarted: the icon is gone
@@ -448,7 +469,7 @@ LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
         case WM_TIMER:
             if (wp == kTimerTelemetry) on_telemetry();
             else if (wp == kTimerWatchdog) on_watchdog();
-            else if (wp == kTimerStrike) { KillTimer(hwnd, kTimerStrike); gao::app::clear_boot_strike(); refresh_status(false); }
+            else if (wp == kTimerStrike) { clear_strike(); refresh_status(false); }
             return 0;
         case WM_APP_WAKE:
             g.input_frames = std::max(g.input_frames, 1);
@@ -481,7 +502,8 @@ LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
             return TRUE;
         case WM_ENDSESSION:
             if (wp) {   // the session really ends: stock now, the run cannot finish
-                if (const gao::GpuControl* gpu = g.worker->active_gpu(); gpu && gpu->reset_to_stock) gpu->reset_to_stock();
+                clear_strike();
+                if (g.worker->running() && g.gpu.reset_to_stock) g.gpu.reset_to_stock();
             }
             return 0;
         case WM_DESTROY:
@@ -573,6 +595,7 @@ int WINAPI wWinMain(HINSTANCE inst, HINSTANCE, PWSTR cmdline, int) {
             const auto logon = gao::app::apply_at_logon();
             if (logon.applied) {
                 g.watch = true;
+                g.strike_pending = true;
                 SetTimer(g.hwnd, kTimerStrike, 2 * 60 * 1000, nullptr);
             } else if (logon.decision != gao::BootDecision::NoProfile) {
                 notify(logon.message);
@@ -600,6 +623,7 @@ int WINAPI wWinMain(HINSTANCE inst, HINSTANCE, PWSTR cmdline, int) {
         }
         if (quit) break;
         if (g.exit_requested && !g.worker->running()) {
+            clear_strike();
             DestroyWindow(g.hwnd);
             continue;
         }

src/app/gui/worker.cpp

@@ -26,14 +26,12 @@ bool OptimizeWorker::start(Preset preset) {
             }
             wake_();
         };
-        hooks.active_gpu = [this](const GpuControl* gpu) { active_gpu_ = gpu; };
         app::OptimizeOutcome outcome;
         try {
             outcome = app::run_optimize(preset, hooks);
         } catch (const std::exception& e) {   // a thrown exception would otherwise end the process
             outcome.error = std::string("unexpected error: ") + e.what();
         }
-        active_gpu_ = nullptr;
         {
             std::lock_guard lock(mu_);
             outcome_ = std::move(outcome);

src/app/gui/worker.hpp

@@ -28,8 +28,6 @@ class OptimizeWorker {
     void abort() { abort_ = true; }     // the run restores stock before it ends
     bool running() const { return running_; }
     Snapshot snapshot() const;
-    // The GPU being tuned right now (nullptr otherwise), for an emergency reset.
-    const GpuControl* active_gpu() const { return active_gpu_; }
 
 private:
     std::function<void()> wake_;
@@ -38,7 +36,6 @@ class OptimizeWorker {
     std::optional<app::OptimizeOutcome> outcome_;
     std::atomic<bool> running_{false};
     std::atomic<bool> abort_{false};
-    std::atomic<const GpuControl*> active_gpu_{nullptr};
     std::jthread thread_;
 };
 

src/app/main.cpp

@@ -95,6 +95,9 @@ static int set_offset(const char* label, int mhz, bool core) {
 }
 
 static int reset() {
+    // Stock by choice: tell a running tray app first, or a watchdog tick
+    // between the writes and the notice would take it for a TDR and re-apply.
+    gao::app::tell_tray_stock_by_choice();
     gao::Nvapi nvapi;
     if (!nvapi.Init()) { std::printf("NVAPI init failed: %s\n", nvapi.Error().c_str()); return 1; }
     bool ok = nvapi.ResetOffsets(kGpu);
@@ -113,8 +116,6 @@ static int reset() {
         std::printf("power limit: default %s\n", power_ok ? "restored" : nvml.Error().c_str());
         ok = ok && power_ok;
     }
-    // A stock card by choice: a running tray app must not re-apply the tune.
-    if (ok) gao::app::tell_tray_stock_by_choice();
     std::printf("%s\n", ok ? "OK" : "MISMATCH");
     return ok ? 0 : 1;
 }

src/hw/boot_task.cpp

@@ -58,11 +58,20 @@ bool install_app(const std::filesystem::path& from_dir, std::string* why) {
     if (dst.empty()) { if (why) *why = "the Program Files folder could not be resolved"; return false; }
     std::error_code ec;
     if (std::filesystem::equivalent(from_dir, dst, ec)) return true;   // running the installed copy already
+    for (const wchar_t* name : kAppExes) {   // all or nothing: never a half-installed pair
+        if (!std::filesystem::is_regular_file(from_dir / name, ec)) {
+            if (why) *why = (from_dir / name).string() + " is missing; both executables must be in the same folder";
+            return false;
+        }
+    }
     std::filesystem::create_directories(dst, ec);
     for (const wchar_t* name : kAppExes) {
         const auto src = from_dir / name;
         const auto to = dst / name;
-        if (!CopyFileW(src.c_str(), to.c_str(), FALSE) && !(move_aside(to) && CopyFileW(src.c_str(), to.c_str(), FALSE))) {
+        bool copied = CopyFileW(src.c_str(), to.c_str(), FALSE);
+        if (!copied && (GetLastError() == ERROR_SHARING_VIOLATION || GetLastError() == ERROR_ACCESS_DENIED))
+            copied = move_aside(to) && CopyFileW(src.c_str(), to.c_str(), FALSE);   // a running copy
+        if (!copied) {
             if (why) *why = "could not copy " + src.string() + " to " + dst.string() + " (error " + std::to_string(GetLastError()) + ")";
             return false;
         }