v0.15.3: ARCH-1 step 3 — extract DependencyProbe

[NathanNeurotic]

Summary

Third collaborator extracted from `TrayContext`. No user-visible changes. Rebased onto main after v0.15.2 (#43) merged (supersedes #44, which was stacked on the pre-squash branch).

• New `src/DependencyProbe.cs` owns the cached `RcloneAvailable` / `WinFspInstalled` booleans, their TTL stamp, and the slow synchronous probes (`File.Exists` + `rclone version` spawn + registry lookups). Constructor takes a `Func` rclone path provider + a log callback.
• `TrayContext.Setup.cs` delegates the cached-state and probe methods; the async refresh worker stays in `TrayContext` and calls `DependencyProbe.PublishProbeResults` when done.

Test plan

• `scripts/run-tests.ps1` — 53/53 green (rebased on current main)
• Real-world: dependency-status chip still updates correctly

🤖 Generated with Claude Code

[gemini-code-assist]

Code Review

This pull request extracts the cached dependency state and synchronous probe logic from the TrayContext partial into a new, dedicated DependencyProbe class, updating Pixelpipe.Setup.cs to delegate to this new class. The review feedback highlights two critical concurrency issues: first, the lazy initialization of the Deps property in Pixelpipe.Setup.cs lacks thread-safety guards, which can lead to race conditions; second, the volatile keyword cannot be applied to the DateTime struct in DependencyProbe, making the caching mechanism prone to thread-safety issues. Implementing thread-safe lazy initialization and a lock-based synchronization mechanism for the cached fields is highly recommended.

[gemini-code-assist]

The Deps property lazily initializes _depProbe without any thread-safety guards. Since Deps is accessed concurrently from both the UI thread (e.g., via RcloneAvailable()) and background threads (via ProbeRcloneAvailableSync() on a ThreadPool worker), there is a race condition where multiple instances of DependencyProbe could be created, or a thread could read a partially-constructed object.

To prevent this, we should use a lock or double-check locking to ensure thread-safe lazy initialization.

        private readonly object _depProbeLock = new object();
        private DependencyProbe _depProbe;
        private DependencyProbe Deps
        {
            get
            {
                if (_depProbe == null)
                {
                    lock (_depProbeLock)
                    {
                        if (_depProbe == null)
                        {
                            _depProbe = new DependencyProbe(
                                delegate { rclonePath = FindRclonePath(); return rclonePath; },
                                LogUiIssue);
                        }
                    }
                }
                return _depProbe;
            }
        }

[gemini-code-assist]

The _cachedStampUtc field is a 64-bit DateTime struct, and volatile cannot be applied to it in C#. Since IsStale and PublishProbeResults are accessed concurrently across the UI thread and background threads, there is a risk of memory reordering or stale reads.

To ensure complete thread safety, atomicity, and proper memory barriers without relying on complex volatile ordering, we can use a simple lock to protect the cached fields and properties. Since these are read infrequently (on UI refresh ticks) and written even less frequently (every 30 seconds), lock contention will be virtually zero.

        private readonly object _lock = new object();
        private bool _cachedRcloneAvailable;
        private bool _cachedWinfspInstalled;
        private DateTime _cachedStampUtc = DateTime.MinValue;

        public DependencyProbe(Func<string> rclonePathProvider, Action<string, Exception> logIssue)
        {
            _rclonePathProvider = rclonePathProvider;
            _logIssue = logIssue;
        }

        public bool RcloneAvailable { get { lock (_lock) return _cachedRcloneAvailable; } }
        public bool WinFspInstalled { get { lock (_lock) return _cachedWinfspInstalled; } }
        public DateTime LastProbeUtc { get { lock (_lock) return _cachedStampUtc; } }
        public bool IsStale
        {
            get
            {
                lock (_lock)
                {
                    return (DateTime.UtcNow - _cachedStampUtc).TotalSeconds >= CacheTtlSeconds;
                }
            }
        }

        // Called by the async refresh worker after the slow probes complete.
        public void PublishProbeResults(bool rcloneAvailable, bool winfspInstalled)
        {
            lock (_lock)
            {
                _cachedRcloneAvailable = rcloneAvailable;
                _cachedWinfspInstalled = winfspInstalled;
                _cachedStampUtc = DateTime.UtcNow;
            }
        }