fix: capture Windows host default colors at startup (#4710)

refs #1530
refs #4369

7 files changed, 430 insertions, 37 deletions

diff --git a/src/client/input.rs b/src/client/input.rs
index 1e308d54..ab46e788 100644
--- a/src/client/input.rs
+++ b/src/client/input.rs
@@ -51,14 +51,13 @@ pub fn stdin_reader_loop(
     #[cfg(windows)]
     {
         let _ = (
-            host_color_query_sent,
             host_theme_query_pending,
             host_cell_size_query_sent,
             host_mouse_capture_active,
             host_sgr_pixels_active,
         );
         let _ = (host_escape_disambiguation_active, initial_host_input);
-        windows_stdin_reader_loop(event_tx, should_quit);
+        windows_stdin_reader_loop(event_tx, should_quit, host_color_query_sent);
     }
 
     #[cfg(unix)]
@@ -397,6 +396,7 @@ fn idle_flush_timeout_ms(
 fn windows_stdin_reader_loop(
     event_tx: mpsc::Sender<ClientLoopEvent>,
     should_quit: &Arc<AtomicBool>,
+    host_color_query_sent: bool,
 ) {
     if !super::windows_vti_input_backend_enabled() {
         windows_vti::trace_input_transport("reader=crossterm");
@@ -405,7 +405,12 @@ fn windows_stdin_reader_loop(
         match windows_vti::console_input_handle() {
             Ok(handle) => {
                 windows_vti::trace_input_transport("reader=windows-console");
-                windows_vti::raw_console_reader_loop(handle, event_tx, should_quit);
+                windows_vti::raw_console_reader_loop(
+                    handle,
+                    event_tx,
+                    should_quit,
+                    host_color_query_sent,
+                );
             }
             _ => {
                 windows_vti::trace_input_transport("reader=crossterm-fallback");
@@ -650,8 +655,20 @@ fn windows_client_input_event_from_raw(
         crate::raw_input::RawInputEvent::OuterFocusLost => {
             Some(crate::protocol::ClientInputEvent::FocusLost)
         }
-        crate::raw_input::RawInputEvent::HostDefaultColor { .. }
-        | crate::raw_input::RawInputEvent::HostPaletteColors { .. }
+        crate::raw_input::RawInputEvent::HostDefaultColor { kind, color } => {
+            Some(crate::protocol::ClientInputEvent::HostDefaultColor {
+                kind: match kind {
+                    crate::terminal_theme::DefaultColorKind::Foreground => {
+                        crate::protocol::ClientHostDefaultColorKind::Foreground
+                    }
+                    crate::terminal_theme::DefaultColorKind::Background => {
+                        crate::protocol::ClientHostDefaultColorKind::Background
+                    }
+                },
+                color: color.into(),
+            })
+        }
+        crate::raw_input::RawInputEvent::HostPaletteColors { .. }
         | crate::raw_input::RawInputEvent::HostColorSchemeChanged(_)
         | crate::raw_input::RawInputEvent::HostCellSizeReport { .. }
         | crate::raw_input::RawInputEvent::Unsupported => None,
diff --git a/src/client/input/windows_vti.rs b/src/client/input/windows_vti.rs
index 0deb3185..c4642885 100644
--- a/src/client/input/windows_vti.rs
+++ b/src/client/input/windows_vti.rs
@@ -20,9 +20,16 @@ pub(super) fn raw_console_reader_loop(
     handle: windows_sys::Win32::Foundation::HANDLE,
     event_tx: mpsc::Sender<ClientLoopEvent>,
     should_quit: &Arc<AtomicBool>,
+    host_color_query_sent: bool,
 ) {
     let mut mapper = WindowsInputMapper::default();
     let mut pump = WindowsInputPump::default();
+    if host_color_query_sent {
+        // Native records distinguish physical Escape from scan-code-zero host replies.
+        pump.framer
+            .host_default_color_query_sent(std::time::Duration::from_secs(1));
+        super::super::query_host_terminal_theme();
+    }
     let mut handoff = WindowsInputHandoff::default();
 
     while !should_quit.load(Ordering::Acquire) {
@@ -325,10 +332,12 @@ struct WindowsInputMapper {
     pending_paste_high_surrogate: Option<u16>,
     mouse_buttons: WindowsMouseButtons,
     win32_input: WindowsWin32InputModeFramer,
+    pending_escape_origin: Option<EscapeOrigin>,
 }
 
 struct WindowsInputPump {
     framer: crate::raw_input::RawInputFramer,
+    pending_escape_origin: Option<EscapeOrigin>,
     paste_from_win32_key_records: bool,
     pending_physical_escape: Option<(crate::protocol::ClientInputEvent, bool)>,
     default_mouse_candidate: DefaultMouseCandidate,
@@ -346,6 +355,7 @@ impl Default for WindowsInputPump {
     fn default() -> Self {
         Self {
             framer: crate::raw_input::RawInputFramer::for_host_input(),
+            pending_escape_origin: None,
             paste_from_win32_key_records: false,
             pending_physical_escape: None,
             default_mouse_candidate: DefaultMouseCandidate::default(),
@@ -357,6 +367,7 @@ impl Default for WindowsInputPump {
 #[derive(Clone, Debug, PartialEq, Eq)]
 enum PlatformInputItem {
     Bytes(Vec<u8>),
+    Escape(EscapeOrigin),
     Semantic(crate::protocol::ClientInputEvent),
     PasteAwareBytes {
         paste_bytes: Vec<u8>,
@@ -372,6 +383,12 @@ enum PlatformInputItem {
     },
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum EscapeOrigin {
+    HostReply,
+    Keyboard,
+}
+
 #[derive(Default)]
 struct WindowsWin32InputModeFramer {
     buffer: Vec<u8>,
@@ -386,6 +403,17 @@ enum WindowsWin32InputModeItem {
 }
 
 impl WindowsInputPump {
+    fn flush_before_semantic(&mut self) -> Vec<crate::raw_input::RawInputEvent> {
+        // A scan-code-zero reply prefix can outlive an unrelated keyboard record.
+        if self.pending_escape_origin == Some(EscapeOrigin::HostReply)
+            && self.framer.holds_host_default_color_escape()
+        {
+            return Vec::new();
+        }
+        self.pending_escape_origin = None;
+        self.framer.flush_interrupted()
+    }
+
     fn process(&mut self, item: PlatformInputItem) -> Vec<crate::protocol::ClientInputEvent> {
         let mut events = Vec::new();
         if let Some((escape, open_bracket)) = self.pending_physical_escape.take() {
@@ -412,7 +440,7 @@ impl WindowsInputPump {
         }
         if let Some(escape) = item.physical_escape_press() {
             if !self.framer.has_pending_bracketed_paste() {
-                let raw_events = self.framer.flush_interrupted();
+                let raw_events = self.flush_before_semantic();
                 events.extend(self.process_raw_events(raw_events));
                 self.pending_physical_escape = Some((escape, false));
                 return events;
@@ -421,11 +449,17 @@ impl WindowsInputPump {
 
         let mut next = match item {
             PlatformInputItem::Bytes(bytes) => {
+                self.pending_escape_origin = None;
                 let raw_events = self.framer.push(&bytes);
                 self.process_raw_events(raw_events)
             }
+            PlatformInputItem::Escape(origin) => {
+                self.pending_escape_origin = Some(origin);
+                let raw_events = self.framer.push(b"\x1b");
+                self.process_raw_events(raw_events)
+            }
             PlatformInputItem::Semantic(event) => {
-                let raw_events = self.framer.flush_interrupted();
+                let raw_events = self.flush_before_semantic();
                 let mut events = self.process_raw_events(raw_events);
                 events.push(event);
                 events
@@ -444,6 +478,11 @@ impl WindowsInputPump {
                         self.stage_default_mouse_record(nested_record, &raw_bytes);
                     }
                     let decode_win32_record = self.paste_from_win32_key_records || !pending_paste;
+                    self.pending_escape_origin = if decode_win32_record && !pending_paste {
+                        WindowsInputMapper::raw_escape_origin(nested_record)
+                    } else {
+                        None
+                    };
                     let raw_events = if decode_win32_record {
                         if pending_paste {
                             self.framer.push(&win32_paste_bytes)
@@ -487,7 +526,7 @@ impl WindowsInputPump {
                     let raw_events = if events.is_empty() {
                         self.framer.flush_timeout()
                     } else {
-                        self.framer.flush_interrupted()
+                        self.flush_before_semantic()
                     };
                     let mut output = self.process_raw_events(raw_events);
                     output.extend(events);
@@ -508,7 +547,12 @@ impl WindowsInputPump {
                 events.extend(self.process_raw_events(raw_events));
             }
         }
-        let raw_events = self.framer.flush_timeout();
+        let raw_events = if self.pending_escape_origin == Some(EscapeOrigin::Keyboard) {
+            self.pending_escape_origin = None;
+            self.framer.flush_keyboard_escape()
+        } else {
+            self.framer.flush_timeout()
+        };
         events.extend(self.process_raw_events(raw_events));
         events
     }
@@ -606,6 +650,7 @@ fn remove_matching_key(keys: &mut Vec<WindowsKeyRecord>, record: WindowsKeyRecor
 impl PlatformInputItem {
     fn raw_bytes(&self) -> Option<&[u8]> {
         match self {
+            Self::Escape(_) => Some(b"\x1b"),
             Self::Bytes(bytes)
             | Self::PasteAwareBytes {
                 raw_bytes: bytes, ..
@@ -684,10 +729,18 @@ impl WindowsInputMapper {
         self.win32_input
             .flush_timeout()
             .into_iter()
-            .map(PlatformInputItem::Bytes)
+            .map(|bytes| self.raw_byte_item(bytes))
             .collect()
     }
 
+    fn raw_byte_item(&mut self, bytes: Vec<u8>) -> PlatformInputItem {
+        let origin = self.pending_escape_origin.take();
+        match origin {
+            Some(origin) if bytes.as_slice() == b"\x1b" => PlatformInputItem::Escape(origin),
+            _ => PlatformInputItem::Bytes(bytes),
+        }
+    }
+
     fn translate(&mut self, record: WindowsInputRecord) -> Vec<PlatformInputItem> {
         match record {
             WindowsInputRecord::Key(key) => self.translate_key(key),
@@ -714,7 +767,10 @@ impl WindowsInputMapper {
             return Vec::new();
         }
 
-        if self.key_record_is_raw_escape(key) {
+        if let Some(origin) = Self::raw_escape_origin(key) {
+            if self.win32_input.buffer.is_empty() {
+                self.pending_escape_origin = Some(origin);
+            }
             return self.translate_win32_input_mode_bytes(&[0x1b]);
         }
 
@@ -760,13 +816,13 @@ impl WindowsInputMapper {
         self.with_pending_win32_flush(items)
     }
 
-    fn key_record_is_raw_escape(&self, key: WindowsKeyRecord) -> bool {
+    fn raw_escape_origin(key: WindowsKeyRecord) -> Option<EscapeOrigin> {
         let modifiers = windows_key_modifiers(key.control_key_state);
         if !key.key_down
             || key.repeat_count.max(1) != 1
             || modifiers.contains(crossterm::event::KeyModifiers::ALT)
         {
-            return false;
+            return None;
         }
 
         // Physical Escape carries a scan code. Scan-code-zero Escape can
@@ -778,17 +834,22 @@ impl WindowsInputMapper {
             && key.unicode == 0x1b
             && modifiers == crossterm::event::KeyModifiers::CONTROL;
 
-        bare_escape || ctrl_bracket
+        if bare_escape && key.virtual_scan_code == 0 {
+            Some(EscapeOrigin::HostReply)
+        } else if bare_escape || ctrl_bracket {
+            Some(EscapeOrigin::Keyboard)
+        } else {
+            None
+        }
     }
 
     fn translate_win32_input_mode_bytes(&mut self, bytes: &[u8]) -> Vec<PlatformInputItem> {
         let mut items = Vec::new();
         for item in self.win32_input.push(bytes) {
             match item {
-                WindowsWin32InputModeItem::Bytes(bytes) => {
-                    items.push(PlatformInputItem::Bytes(bytes))
-                }
+                WindowsWin32InputModeItem::Bytes(bytes) => items.push(self.raw_byte_item(bytes)),
                 WindowsWin32InputModeItem::Key { bytes, record } => {
+                    self.pending_escape_origin = None;
                     trace_input_transport("transport=win32-serialized");
                     let win32_paste_bytes =
                         self.paste_payload_bytes_for_key(record).unwrap_or_default();
@@ -818,7 +879,7 @@ impl WindowsInputMapper {
         &mut self,
         record: WindowsKeyRecord,
     ) -> Option<Vec<u8>> {
-        if self.key_record_is_raw_escape(record) {
+        if Self::raw_escape_origin(record).is_some() {
             return Some(vec![0x1b]);
         }
 
@@ -1389,6 +1450,217 @@ fn windows_input_trace_enabled() -> bool {
 mod tests {
     use super::*;
 
+    #[cfg(windows)]
+    #[test]
+    fn host_default_color_replies_reach_shell_without_pane_input() {
+        use crate::protocol::{
+            ClientHostColor, ClientHostDefaultColorKind, ClientHostThemeUpdate, ClientMessage,
+        };
+
+        let mut translator = WindowsInputTranslator::default();
+        translator
+            .pump
+            .framer
+            .host_default_color_query_sent(std::time::Duration::from_secs(1));
+        assert!(translator.translate(key_char('\x1b')).is_empty());
+        for _ in 0..3 {
+            assert!(translator.idle().is_empty());
+        }
+        assert!(matches!(
+            translator
+                .translate(key_vk_with_unicode(0x41, 'a', 0))
+                .as_slice(),
+            [crate::protocol::ClientInputEvent::Key {
+                code: crate::protocol::ClientKeyCode::Char('a'),
+                ..
+            }]
+        ));
+
+        let events = "]10;rgb:aaaa/bbbb/cccc\x1b\\\x1b]11;rgb:1111/2222/3333\x1b\\"
+            .chars()
+            .map(key_char)
+            .flat_map(|record| translator.translate(record))
+            .collect::<Vec<_>>();
+        let mut shell = crate::client::shell::ClientShellState::new(
+            crate::client::shell::ClientShellConfig::from_config(&crate::config::Config::default()),
+        );
+        let outcome = shell.handle_client_events(&events);
+        assert_eq!(
+            outcome.requests,
+            vec![
+                ClientMessage::ClientShellHostTheme {
+                    update: ClientHostThemeUpdate::DefaultColor {
+                        kind: ClientHostDefaultColorKind::Foreground,
+                        color: ClientHostColor {
+                            r: 0xaa,
+                            g: 0xbb,
+                            b: 0xcc,
+                        },
+                    },
+                },
+                ClientMessage::ClientShellHostTheme {
+                    update: ClientHostThemeUpdate::DefaultColor {
+                        kind: ClientHostDefaultColorKind::Background,
+                        color: ClientHostColor {
+                            r: 0x11,
+                            g: 0x22,
+                            b: 0x33,
+                        },
+                    },
+                },
+            ]
+        );
+        assert!(outcome.actions.is_empty());
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn ctrl_bracket_precedes_next_key_while_host_color_reply_is_pending() {
+        let mut translator = WindowsInputTranslator::default();
+        translator
+            .pump
+            .framer
+            .host_default_color_query_sent(std::time::Duration::from_secs(1));
+        assert!(translator
+            .translate(key_vk_with_utf16_mods(0xdb, 0x1b, 0x0008))
+            .is_empty());
+        let events = translator.translate(key_vk_with_unicode(0x0d, '\r', 0));
+        assert!(matches!(
+            events.as_slice(),
+            [
+                crate::protocol::ClientInputEvent::Key {
+                    code: crate::protocol::ClientKeyCode::Esc,
+                    ..
+                },
+                crate::protocol::ClientInputEvent::Key {
+                    code: crate::protocol::ClientKeyCode::Enter,
+                    ..
+                }
+            ]
+        ));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn ctrl_bracket_idle_does_not_cancel_later_host_color_reply() {
+        let mut translator = WindowsInputTranslator::default();
+        translator
+            .pump
+            .framer
+            .host_default_color_query_sent(std::time::Duration::from_secs(1));
+        assert!(translator
+            .translate(key_vk_with_utf16_mods(0xdb, 0x1b, 0x0008))
+            .is_empty());
+        assert!(matches!(
+            translator.idle().as_slice(),
+            [crate::protocol::ClientInputEvent::Key {
+                code: crate::protocol::ClientKeyCode::Esc,
+                ..
+            }]
+        ));
+        assert!(translator.translate(key_char('\x1b')).is_empty());
+        assert!(translator.idle().is_empty());
+        let events = "]10;rgb:aaaa/bbbb/cccc\x1b\\"
+            .chars()
+            .map(key_char)
+            .flat_map(|record| translator.translate(record))
+            .collect::<Vec<_>>();
+        assert!(matches!(
+            events.as_slice(),
+            [crate::protocol::ClientInputEvent::HostDefaultColor {
+                kind: crate::protocol::ClientHostDefaultColorKind::Foreground,
+                ..
+            }]
+        ));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn serialized_host_reply_escape_survives_intervening_key() {
+        let mut translator = WindowsInputTranslator::default();
+        translator
+            .pump
+            .framer
+            .host_default_color_query_sent(std::time::Duration::from_secs(1));
+        for record in win32_input_mode_encoded_raw_bytes(b"\x1b") {
+            assert!(translator.translate(record).is_empty());
+        }
+        let key_events = translator.translate(key_vk_with_unicode(0x0d, '\r', 0));
+        assert!(matches!(
+            key_events.as_slice(),
+            [crate::protocol::ClientInputEvent::Key {
+                code: crate::protocol::ClientKeyCode::Enter,
+                ..
+            }]
+        ));
+        let events = "]10;rgb:aaaa/bbbb/cccc\x1b\\"
+            .chars()
+            .map(key_char)
+            .flat_map(|record| translator.translate(record))
+            .collect::<Vec<_>>();
+        assert!(matches!(
+            events.as_slice(),
+            [crate::protocol::ClientInputEvent::HostDefaultColor {
+                kind: crate::protocol::ClientHostDefaultColorKind::Foreground,
+                ..
+            }]
+        ));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn expired_host_color_reply_tail_does_not_swallow_semantic_key() {
+        let mut translator = WindowsInputTranslator::default();
+        translator
+            .pump
+            .framer
+            .host_default_color_query_sent(std::time::Duration::ZERO);
+        for record in "\x1b]11;rgb:1111/".chars().map(key_char) {
+            assert!(translator.translate(record).is_empty());
+        }
+        assert!(translator.idle().is_empty());
+        assert!(matches!(
+            translator
+                .translate(key_vk_with_unicode(0x0d, '\r', 0))
+                .as_slice(),
+            [crate::protocol::ClientInputEvent::Key {
+                code: crate::protocol::ClientKeyCode::Enter,
+                ..
+            }]
+        ));
+        for record in "2222/3333\x1b\\".chars().map(key_char) {
+            assert!(translator.translate(record).is_empty());
+        }
+        assert!(matches!(
+            translator
+                .translate(key_vk_with_unicode(0x41, 'a', 0))
+                .as_slice(),
+            [crate::protocol::ClientInputEvent::Key {
+                code: crate::protocol::ClientKeyCode::Char('a'),
+                ..
+            }]
+        ));
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn unanswered_host_color_query_stops_holding_escape() {
+        let mut translator = WindowsInputTranslator::default();
+        translator
+            .pump
+            .framer
+            .host_default_color_query_sent(std::time::Duration::from_millis(1));
+        std::thread::sleep(std::time::Duration::from_millis(10));
+        assert!(translator.translate(key_char('\x1b')).is_empty());
+        assert!(matches!(
+            translator.idle().as_slice(),
+            [crate::protocol::ClientInputEvent::Key {
+                code: crate::protocol::ClientKeyCode::Esc,
+                ..
+            }]
+        ));
+    }
+
     fn key_char(ch: char) -> WindowsInputRecord {
         WindowsInputRecord::Key(WindowsKeyRecord {
             key_down: true,
@@ -2083,6 +2355,11 @@ mod tests {
             },
         ] {
             let mut translator = WindowsInputTranslator::default();
+            #[cfg(windows)]
+            translator
+                .pump
+                .framer
+                .host_default_color_query_sent(std::time::Duration::from_secs(1));
             assert!(translator
                 .translate(WindowsInputRecord::Key(record))
                 .is_empty());
diff --git a/src/client/mod.rs b/src/client/mod.rs
index b78517ac..d55e4c48 100644
--- a/src/client/mod.rs
+++ b/src/client/mod.rs
@@ -70,7 +70,7 @@ use terminal_geometry::{
 };
 use terminal_geometry::{
     host_cell_size_query_required, initial_terminal_geometry, query_host_cell_size,
-    query_host_terminal_theme, resize_poll_loop, should_query_host_terminal_theme,
+    query_host_terminal_theme, resize_poll_loop,
 };
 #[cfg(unix)]
 use terminal_geometry::{reported_cell_size_from_events, store_reported_cell_size};
@@ -517,8 +517,7 @@ async fn run_client_loop(
     let mut endpoint_commands = endpoint_commands::EndpointCommands::default();
 
     // Spawn the stdin reader thread.
-    let will_query_host_terminal_theme =
-        state.attach_escape.is_none() && should_query_host_terminal_theme();
+    let will_query_host_terminal_theme = state.attach_escape.is_none();
     let host_theme_query_pending = Arc::new(AtomicU32::new(0));
     let stdin_host_theme_query_pending = host_theme_query_pending.clone();
     // Terminals behind ConPTY report no pixel size through the ioctl, so ask the
@@ -555,9 +554,9 @@ async fn run_client_loop(
         );
     });
 
+    #[cfg(unix)]
     if will_query_host_terminal_theme {
         query_host_terminal_theme();
-        #[cfg(not(windows))]
         if state.shell.is_some() {
             query_host_terminal_appearance();
         }
@@ -1191,9 +1190,9 @@ async fn run_client_loop(
                 cell_height_px,
                 pixel_geometry_exact,
             ) => {
-                // Palette updates through OSC do not necessarily produce a color-scheme
-                // notification. Re-query on redraw, including SIGWINCH without a resize,
-                // so desktop theme switchers can refresh the existing panes in place.
+                // On Unix, palette changes may lack a color-scheme notification.
+                // Re-query on redraw, including SIGWINCH without a resize.
+                #[cfg(unix)]
                 if will_query_host_terminal_theme {
                     host_theme_query_pending.fetch_add(1, Ordering::AcqRel);
                     query_host_terminal_theme();
diff --git a/src/client/shell_runtime.rs b/src/client/shell_runtime.rs
index d0eafdf6..5e1da58c 100644
--- a/src/client/shell_runtime.rs
+++ b/src/client/shell_runtime.rs
@@ -751,6 +751,10 @@ pub(super) fn finish_client_shell_input(
                 }
                 continue;
             }
+            if endpoints.active_surface_available() {
+                write_to_server(endpoints, &request).map_err(ClientError::ConnectionLost)?;
+            }
+            continue;
         }
         // Host focus belongs to a pending target even when the source has gone offline or has
         // already had its surface revoked. Route it before the ordinary source-online gate.
@@ -791,3 +795,109 @@ pub(super) fn finish_client_shell_input(
     }
     Ok(false)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn host_color_reaches_server_before_first_snapshot() {
+        #[derive(Clone)]
+        struct Capture(std::sync::Arc<std::sync::Mutex<Vec<ClientMessage>>>);
+
+        impl endpoint::EndpointTransport for Capture {
+            fn send(&mut self, message: &ClientMessage) -> std::io::Result<()> {
+                self.0.lock().unwrap().push(message.clone());
+                Ok(())
+            }
+        }
+
+        let sent = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+        let mut endpoints = endpoint::EndpointRegistry::new(
+            Capture(sent.clone()),
+            1,
+            endpoint::EndpointNegotiation::new(Vec::new(), Vec::new()),
+        );
+        let mut state = ClientState::test_new();
+        assert!(!state
+            .shell
+            .as_ref()
+            .unwrap()
+            .endpoint_is_online(&endpoint::ClientEndpointId::Local));
+        let outcome = state.shell.as_mut().unwrap().handle_raw_events(vec![
+            crate::raw_input::RawInputEvent::HostDefaultColor {
+                kind: crate::terminal_theme::DefaultColorKind::Background,
+                color: crate::terminal_theme::RgbColor {
+                    r: 0x11,
+                    g: 0x22,
+                    b: 0x33,
+                },
+            },
+        ]);
+        let mut pending_activation = None;
+        let mut endpoint_commands = endpoint_commands::EndpointCommands::default();
+        let mut prefix_input_source = crate::platform::RealPrefixInputSource::default();
+        let mut scheduled_activation = None;
+        finish_client_shell_input(
+            &mut state,
+            outcome,
+            None,
+            &mut endpoints,
+            &mut pending_activation,
+            &mut endpoint_commands,
+            &mut prefix_input_source,
+            &mut scheduled_activation,
+        )
+        .unwrap();
+
+        assert_eq!(
+            *sent.lock().unwrap(),
+            vec![ClientMessage::ClientShellHostTheme {
+                update: crate::protocol::ClientHostThemeUpdate::DefaultColor {
+                    kind: crate::protocol::ClientHostDefaultColorKind::Background,
+                    color: crate::protocol::ClientHostColor {
+                        r: 0x11,
+                        g: 0x22,
+                        b: 0x33,
+                    },
+                },
+            }]
+        );
+
+        let local = endpoint::ClientEndpointId::Local;
+        assert!(endpoints.set_surface_active(&local, false));
+        let outcome = state.shell.as_mut().unwrap().handle_raw_events(vec![
+            crate::raw_input::RawInputEvent::HostDefaultColor {
+                kind: crate::terminal_theme::DefaultColorKind::Foreground,
+                color: crate::terminal_theme::RgbColor { r: 4, g: 5, b: 6 },
+            },
+        ]);
+        finish_client_shell_input(
+            &mut state,
+            outcome,
+            None,
+            &mut endpoints,
+            &mut pending_activation,
+            &mut endpoint_commands,
+            &mut prefix_input_source,
+            &mut scheduled_activation,
+        )
+        .unwrap();
+        assert_eq!(sent.lock().unwrap().len(), 1);
+
+        assert!(endpoints.set_surface_active(&local, true));
+        state.replay_host_theme(&mut endpoints, &local);
+        let messages = sent.lock().unwrap();
+        assert_eq!(messages.len(), 3);
+        assert_eq!(messages[1], messages[0]);
+        assert_eq!(
+            messages[2],
+            ClientMessage::ClientShellHostTheme {
+                update: crate::protocol::ClientHostThemeUpdate::DefaultColor {
+                    kind: crate::protocol::ClientHostDefaultColorKind::Foreground,
+                    color: crate::protocol::ClientHostColor { r: 4, g: 5, b: 6 },
+                },
+            }
+        );
+    }
+}
diff --git a/src/client/terminal_geometry.rs b/src/client/terminal_geometry.rs
index f15141bb..02d6d05a 100644
--- a/src/client/terminal_geometry.rs
+++ b/src/client/terminal_geometry.rs
@@ -192,10 +192,6 @@ pub(super) fn query_host_terminal_theme() {
     let _ = write_host_terminal_theme_query(io::stdout());
 }
 
-pub(super) fn should_query_host_terminal_theme() -> bool {
-    !cfg!(windows)
-}
-
 pub(super) fn write_host_terminal_theme_query(mut writer: impl io::Write) -> io::Result<()> {
     let query = crate::terminal_theme::host_terminal_theme_query_sequence(
         crate::platform::should_query_host_terminal_palette(),
diff --git a/src/client/terminal_setup.rs b/src/client/terminal_setup.rs
index 9c84985a..249e29ad 100644
--- a/src/client/terminal_setup.rs
+++ b/src/client/terminal_setup.rs
@@ -20,7 +20,6 @@ use crossterm::execute;
 use crossterm::terminal::{DisableLineWrap, EnableLineWrap};
 
 use super::frame_output::clear_received_kitty_graphics;
-use super::terminal_geometry::should_query_host_terminal_theme;
 
 // ---------------------------------------------------------------------------
 // Terminal setup / restore
@@ -86,7 +85,7 @@ pub(super) fn setup_terminal_with_capabilities(
         }
         (active, buffered_input)
     } else {
-        if should_query_host_terminal_theme() {
+        if should_enable_host_color_scheme_reports(true) {
             write_host_color_scheme_report_mode(&mut io::stdout(), false)?;
         }
         set_mouse_capture(mouse_capture, false)?;
@@ -128,7 +127,7 @@ pub(super) fn setup_terminal_with_capabilities(
 }
 
 pub(super) fn should_enable_host_color_scheme_reports(enable_client_protocols: bool) -> bool {
-    enable_client_protocols && should_query_host_terminal_theme()
+    enable_client_protocols && !cfg!(windows)
 }
 
 /// Guard that restores the terminal when dropped.
diff --git a/src/client/tests/mod.rs b/src/client/tests/mod.rs
index 2fcac6eb..035d00d3 100644
--- a/src/client/tests/mod.rs
+++ b/src/client/tests/mod.rs
@@ -439,11 +439,6 @@ fn color_scheme_change_event_requests_host_theme_query() {
 }
 
 #[test]
-fn host_terminal_theme_query_is_disabled_on_windows() {
-    assert_eq!(should_query_host_terminal_theme(), !cfg!(windows));
-}
-
-#[test]
 fn write_host_cell_size_query_emits_xtwinops_request() {
     let mut output = Vec::new();
     write_host_cell_size_query(&mut output).unwrap();