Add stress tests for two-way sync functionality

- Introduced a new plan for nuclear-grade stress tests and randomized fuzzing for two-way sync operations, focusing on rapid multi-cycle operations and race conditions.
- Created a comprehensive set of todos for implementing timing helpers, a deterministic PRNG, and various fuzz tests to validate the robustness of the two-way sync mechanism.
- Enhanced existing infrastructure in `two_way_sync.rs` to support new testing strategies, including the addition of a `FuzzState` tracker and `run_fuzz_iteration` helper for managing randomized operations.
- Updated `change_processor.rs` and `api.rs` to improve path handling and suppression logic, ensuring accurate event processing during stress tests.

src/change_processor.rs

@@ -236,16 +236,34 @@ impl JobThreadContext {
         }
 
         // Check if this event should be suppressed (one-shot, from API syncback).
+        // Try both the raw event path and its canonical form since suppress_path
+        // stores whichever form it could resolve at insertion time.
         let event_path = match &event {
             VfsEvent::Create(p) | VfsEvent::Write(p) | VfsEvent::Remove(p) => Some(p.clone()),
             _ => None,
         };
         if let Some(ref path) = event_path {
+            let canonical = std::fs::canonicalize(path).ok();
             let mut suppressed = self.suppressed_paths.lock().unwrap();
-            if let Some(count) = suppressed.get_mut(path) {
-                *count = count.saturating_sub(1);
-                if *count == 0 {
-                    suppressed.remove(path);
+            // Determine which key matches: try canonical first (most likely
+            // to match what suppress_path stored), then fall back to raw.
+            let matched_key = canonical
+                .as_ref()
+                .filter(|c| suppressed.contains_key(c.as_path()))
+                .cloned()
+                .or_else(|| {
+                    if suppressed.contains_key(path) {
+                        Some(path.clone())
+                    } else {
+                        None
+                    }
+                });
+            if let Some(key) = matched_key {
+                if let Some(count) = suppressed.get_mut(&key) {
+                    *count = count.saturating_sub(1);
+                    if *count == 0 {
+                        suppressed.remove(&key);
+                    }
                 }
                 drop(suppressed);
                 // Still commit so VFS stays consistent, but skip patching.

src/web/api.rs

@@ -221,23 +221,29 @@ impl ApiService {
     /// Register a path in the suppression map so that the ChangeProcessor
     /// ignores the next VFS event for it (counter-based echo suppression).
     /// Each call increments the counter; each suppressed VFS event decrements it.
+    ///
+    /// Inserts exactly ONE entry per call — canonical form preferred, raw as
+    /// fallback — to avoid leaking the unmatched variant.
     fn suppress_path(&self, path: &Path) {
         let mut suppressed = self.suppressed_paths.lock().unwrap();
         // Try to canonicalize (adds \\?\ prefix on Windows, resolves symlinks).
         // For files that don't exist yet, canonicalize the parent and join.
-        if let Ok(canonical) = std::fs::canonicalize(path) {
-            *suppressed.entry(canonical).or_insert(0) += 1;
+        let key = if let Ok(canonical) = std::fs::canonicalize(path) {
+            canonical
         } else if let Some(parent) = path.parent() {
             if let Ok(canonical_parent) = std::fs::canonicalize(parent) {
                 if let Some(file_name) = path.file_name() {
-                    *suppressed
-                        .entry(canonical_parent.join(file_name))
-                        .or_insert(0) += 1;
+                    canonical_parent.join(file_name)
+                } else {
+                    path.to_path_buf()
                 }
+            } else {
+                path.to_path_buf()
             }
-        }
-        // Also increment the raw path as fallback.
-        *suppressed.entry(path.to_path_buf()).or_insert(0) += 1;
+        } else {
+            path.to_path_buf()
+        };
+        *suppressed.entry(key).or_insert(0) += 1;
     }
 
     /// Get a summary of information about the server