perf: reduce sidebar git polling overhead

refs #353

1 files changed, 22 insertions, 22 deletions

diff --git a/tests/detach_reattach.rs b/tests/detach_reattach.rs
index 1e90d94b..18b0e6fc 100644
--- a/tests/detach_reattach.rs
+++ b/tests/detach_reattach.rs
@@ -276,8 +276,8 @@ fn navigate_q_detaches_client_and_server_persists() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect to client socket");
     let (version, error) =
-        client_handshake(&mut stream, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frames.
@@ -338,8 +338,8 @@ fn explicit_detach_message_causes_clean_disconnect() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect");
     let (version, error) =
-        client_handshake(&mut stream, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frames.
@@ -397,8 +397,8 @@ fn reattach_after_detach_shows_current_state() {
     // --- Client A ---
     let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect");
     let (version, error) =
-        client_handshake(&mut stream_a, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream_a, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frames.
@@ -436,8 +436,8 @@ fn reattach_after_detach_shows_current_state() {
     // --- Client B (reattach) ---
     let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect");
     let (version, error) =
-        client_handshake(&mut stream_b, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream_b, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(
         error.is_none(),
         "reattach handshake should succeed: {:?}",
@@ -516,8 +516,8 @@ fn processes_survive_during_and_after_detach() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect");
     let (version, error) =
-        client_handshake(&mut stream, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frames.
@@ -555,8 +555,8 @@ fn processes_survive_during_and_after_detach() {
     // Reattach — verify we can connect and receive a frame.
     let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach");
     let (version, error) =
-        client_handshake(&mut stream_b, 11, 80, 24).expect("reattach handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream_b, 12, 80, 24).expect("reattach handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Verify the reattached client receives a frame.
@@ -604,8 +604,8 @@ fn server_persists_after_client_connection_drop() {
     // Connect and handshake.
     let mut stream = UnixStream::connect(&client_socket).expect("should connect");
     let (version, error) =
-        client_handshake(&mut stream, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Drain initial frames.
@@ -631,8 +631,8 @@ fn server_persists_after_client_connection_drop() {
     // Reattach — verify we can connect and handshake again.
     let mut stream_b = UnixStream::connect(&client_socket).expect("should reattach");
     let (version, error) =
-        client_handshake(&mut stream_b, 11, 80, 24).expect("reattach handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream_b, 12, 80, 24).expect("reattach handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "reattach should succeed: {:?}", error);
 
     cleanup_spawned_herdr(spawned, base);
@@ -653,8 +653,8 @@ fn detached_output_preserves_last_attached_pty_size() {
 
     let mut stream = UnixStream::connect(&client_socket).expect("client should connect");
     let (version, error) =
-        client_handshake(&mut stream, 11, 120, 40).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream, 12, 120, 40).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
     drain_messages(&mut stream);
 
@@ -722,8 +722,8 @@ fn output_accumulated_while_detached_visible_on_reattach() {
     // Connect and handshake client A.
     let mut stream_a = UnixStream::connect(&client_socket).expect("client A should connect");
     let (version, error) =
-        client_handshake(&mut stream_a, 11, 80, 24).expect("handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream_a, 12, 80, 24).expect("handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Detach client A immediately.
@@ -780,8 +780,8 @@ fn output_accumulated_while_detached_visible_on_reattach() {
     // --- Client B (reattach) ---
     let mut stream_b = UnixStream::connect(&client_socket).expect("client B should connect");
     let (version, error) =
-        client_handshake(&mut stream_b, 11, 80, 24).expect("reattach handshake should succeed");
-    assert_eq!(version, 11);
+        client_handshake(&mut stream_b, 12, 80, 24).expect("reattach handshake should succeed");
+    assert_eq!(version, 12);
     assert!(error.is_none(), "{:?}", error);
 
     // Client B should receive a frame with the current state.