fix: hold _isProcessing when dependencies not met to prevent queue orphaning in Watch.ProcessChange

Author: TechieGuy12

src/Configuration/Watch.cs

@@ -207,13 +207,17 @@ public override void Run(ChangeInfo change, TriggerType trigger)
                 // Start processing on thread pool
                 _processingTask = Task.Run(() =>
                 {
+                    bool releaseProcessing = true;
                     try
                     {
-                        ProcessChange();
+                        releaseProcessing = ProcessChange();
                     }
                     finally
                     {
-                        Interlocked.Exchange(ref _isProcessing, 0);
+                        if (releaseProcessing)
+                        {
+                            Interlocked.Exchange(ref _isProcessing, 0);
+                        }
                     }
                 });
             }
@@ -413,20 +417,24 @@ private void CreateTimer()
         /// <summary>
         /// Process the changes in the queue.
         /// </summary>
-        public void ProcessChange()
+        /// <returns>
+        /// <c>true</c> if the <see cref="_isProcessing"/> flag should be released
+        /// by the caller; <c>false</c> if the flag must remain held because
+        /// processing is pending a dependency completing.
+        /// </returns>
+        public bool ProcessChange()
         {
             if (string.IsNullOrWhiteSpace(Path))
             {
-                return;
+                return true;
             }
 
             _queue ??= new ConcurrentQueue<ChangeInfo>();            
 
             if (_queue.IsEmpty)
             {
-                Initialize();
                 Thread.Sleep(EMPTY_QUEUE_SLEEP_MS);
-                return;
+                return true;
             }
 
             // Peek at first item for correlation ID instead of copying entire queue
@@ -470,7 +478,10 @@ public void ProcessChange()
                         $"{correlationPrefix}{IdLogString}: Watch blocked from running. Reason: {reason}. Queue will be processed when watch becomes available. (Watch.ProcessChange)",
                         LogLevel.DEBUG);
                 }
-                return;
+                // Return false to keep _isProcessing held. OnNeedsCompleted will call
+                // ProcessChange() directly once the dependency completes, at which point
+                // it will release _isProcessing itself.
+                return false;
             }
 
             var startTime = DateTime.Now;
@@ -543,6 +554,7 @@ public void ProcessChange()
                 ? $"[{firstCorrelationId.Value}] {IdLogString}: Tasks completed for watch."
                 : $"{IdLogString}: Tasks completed for watch.";
             OnCompleted(this, new TaskEventArgs(true, IdLogString, completionMessage));
+            return true;
         }
 
         /// <summary>
@@ -1076,7 +1088,17 @@ public override void OnNeedsCompleted(object? sender, TaskEventArgs e)
 
             base.OnNeedsCompleted(sender, e);
 
-            ProcessChange();
+            // _isProcessing is still held from the blocked Task.Run (ProcessChange
+            // returned false). Process the queued items now that the dependency has
+            // completed, then release the flag.
+            try
+            {
+                ProcessChange();
+            }
+            finally
+            {
+                Interlocked.Exchange(ref _isProcessing, 0);
+            }
         }   
 
     }