diff --git a/Cargo.lock b/Cargo.lock
index 6594bcb6dc..c05d760ba3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -699,6 +699,7 @@ dependencies = [
  "tracing-subscriber",
  "unicode-width",
  "widestring",
+ "windows",
  "windows-sys",
  "wmi",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 02edde19b8..180fbc039c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -54,6 +54,12 @@ portable-pty = { path = "vendor/portable-pty" }
 # UTF-16 SDDL input for interprocess security descriptors.
 widestring = "1.2"
 wmi = { version = "0.18.4", default-features = false }
+windows = { version = "0.62.2", features = [
+    "Win32_System_Com",
+    "Win32_System_Ole",
+    "Win32_System_TaskScheduler",
+    "Win32_System_Variant",
+] }
 windows-sys = { version = "0.61.2", features = [
     "Wdk_System_Threading",
     "Win32_Foundation",
@@ -69,6 +75,7 @@ windows-sys = { version = "0.61.2", features = [
     "Win32_System_Memory",
     "Win32_System_Ole",
     "Win32_System_Pipes",
+    "Win32_System_RemoteDesktop",
     "Win32_System_Threading",
     "Win32_UI_Input_Ime",
     "Win32_UI_Input_KeyboardAndMouse",
diff --git a/docs/next/website/src/content/docs/persistence-remote.mdx b/docs/next/website/src/content/docs/persistence-remote.mdx
index e876445778..05eca35988 100644
--- a/docs/next/website/src/content/docs/persistence-remote.mdx
+++ b/docs/next/website/src/content/docs/persistence-remote.mdx
@@ -42,6 +42,7 @@ Save repeat targets to work across several machines from one Herdr client:
 ```bash
 herdr machine add workbox --label "Build machine" --remote-session agents
 herdr machine add ssh://you@server:2222 --label "Production" --remote-session operations
+herdr machine add windows-workbox --label "Desktop agents" --remote-desktop
 herdr machine list
 ```
 
@@ -68,7 +69,7 @@ herdr machine remove <profile-id>
 
 Renaming updates the label without reconnecting. Removing or disabling a machine disconnects only that machine from the client; its remote sessions keep running, even if the machine is unreachable. If you remove or disable the machine you are viewing, the client returns to Local. If Local is unavailable, it shows that and reconnects rather than selecting another remote. An unreadable or invalid saved-machine file leaves current connections unchanged and shows a notice; the client retries reading it automatically.
 
-Saved profiles contain only the opaque ID, label, SSH target, explicit remote session, and enabled state. Passwords, private keys, agent tickets, and SSH control sockets are never stored in the machine catalog.
+Saved profiles contain only the opaque ID, label, SSH target, explicit remote session, enabled state, and whether Windows desktop hosting is required. Passwords, private keys, agent tickets, and SSH control sockets are never stored in the machine catalog.
 
 The client uses local keybindings by default. Custom commands advertised by the selected machine still execute on that machine. Herdr does not copy local command plugins, configuration, executables, or secrets to SSH hosts; a missing remote command or plugin fails visibly.
 
@@ -83,6 +84,14 @@ herdr --remote ssh://you@server:2222
 
 In this mode, your local Herdr is a thin client. It connects over SSH, starts or attaches to the remote Herdr server, and streams the UI back to your local terminal. Because the client runs locally, Herdr can bridge local desktop features such as image clipboard paste into the remote session by copying the image to a remote temp file and pasting that path.
 
+Windows SSH normally starts processes outside the signed-in desktop. To let agents on a Windows target interact with desktop apps, opt in explicitly:
+
+```bash
+herdr --remote windows-workbox --remote-desktop
+```
+
+To start a desktop server, Herdr requires exactly one active desktop login for the SSH account. It asks for confirmation, creates a one-time Windows task to launch the server in that login, and removes the task after the server is ready. Automatic reconnects only attach; they do not create tasks or start a server. A server with the same Herdr session name in Windows Session 0 or another login is left running and reported as a conflict. Use a different `--session` or stop that server explicitly. This option does not sign in, unlock Windows, or move existing panes between Windows sessions.
+
 By default, `herdr --remote` uses your local Herdr keybindings for that attach. This keeps local muscle memory even when the remote server has different config. The local keybindings are a snapshot from attach time; detach and reattach after editing local keybindings. Use `--remote-keybindings server` when you want the remote server config instead. Local custom command keybindings are not sent, because those commands would run on the remote host.
 
 For repeat targets, use your SSH config:
@@ -100,7 +109,7 @@ Then attach with:
 herdr --remote workbox
 ```
 
-Remote attach supports Linux, macOS, and Windows local clients connecting to Linux or macOS hosts on x86_64 and aarch64. Herdr checks the remote platform, prefers a compatible `herdr` already on the remote `PATH`, then checks common direct, Homebrew, mise, and Nix profile install paths. Local and remote versions do not need to match once both support the stable endpoint generation. If no compatible binary exists, interactive runs prompt to install one to `~/.local/bin/herdr`; non-interactive runs fail instead of modifying the host. If `~/.local/bin` is not on the remote `PATH`, Herdr warns after install. Windows is not supported as the remote host.
+Remote attach and saved SSH machines support Linux, macOS, and Windows local clients connecting to Linux or macOS hosts on x86_64 and aarch64, or Windows hosts on x86_64. Local and remote versions do not need to match once both support the stable endpoint generation. On Linux and macOS hosts, Herdr prefers a compatible `herdr` already on the remote `PATH`, then checks common direct, Homebrew, mise, and Nix profile install paths. On Windows hosts, Herdr checks `PATH` and the active managed release. If no compatible binary exists, interactive runs prompt to install or update one; non-interactive runs fail instead of modifying the host. Linux and macOS installs use `~/.local/bin/herdr`; Windows installs use the complete Windows package and its app-local ConPTY runtime. If `~/.local/bin` is not on the remote `PATH`, Herdr warns after install.
 
 By default, `herdr --remote` runs remote setup and the bridge through a temporary SSH config that includes your SSH config first, then adds fallback keepalive settings. Existing user keepalive settings win. Linux and macOS clients also use a private per-attach control socket for connection reuse; Windows OpenSSH does not. Set `[remote].manage_ssh_config = false` to use plain `ssh` without Herdr's generated config or control socket.
 
@@ -121,9 +130,9 @@ herdr --remote workbox --handoff
 
 If you SSH into the server first and run `herdr` there, Herdr runs entirely on the server and cannot access your local desktop clipboard beyond normal terminal text paste.
 
-When your local and remote platforms match, Herdr can copy the current local binary for direct installs. For Homebrew, mise, and Nix installs, or when the platforms differ, it downloads the matching release asset for the current client version from `https://herdr.dev/latest.json`.
+For Linux and macOS hosts, Herdr can copy the current local binary when the platforms match. For Homebrew, mise, and Nix installs, when the platforms differ, or for Windows hosts, it downloads the matching release asset for the current client version from `https://herdr.dev/latest.json`.
 
-For local builds or custom binaries, set `HERDR_REMOTE_BINARY` to a local file path before running remote attach.
+For local builds or custom packages, set `HERDR_REMOTE_BINARY` to a local file path before running remote attach. Use a bare Herdr executable for Linux or macOS targets and a complete `herdr-windows-x86_64.zip` package for Windows targets.
 
 ```bash
 HERDR_REMOTE_BINARY=target/release/herdr herdr --remote workbox
diff --git a/docs/next/website/src/content/docs/windows-beta.mdx b/docs/next/website/src/content/docs/windows-beta.mdx
index 255727a20e..15ff1fb745 100644
--- a/docs/next/website/src/content/docs/windows-beta.mdx
+++ b/docs/next/website/src/content/docs/windows-beta.mdx
@@ -32,7 +32,8 @@ For internal testing, `HERDR_MANIFEST_URL` can point the installer at a custom m
 | Local persistent sessions | supported |
 | Native panes through ConPTY | supported |
 | Windows Terminal / PowerShell app attach | supported |
-| `herdr --remote` to Linux/macOS hosts | supported |
+| `herdr --remote` and saved SSH machines to Linux/macOS/Windows hosts | supported; interactive attach and saved-machine setup can install or update Windows packages after confirmation; background reconnect only discovers installed packages |
+| Remote agents in the signed-in Windows desktop | supported with `--remote-desktop` |
 | Remote clipboard images and image-file drops | supported |
 | `cmd.exe` panes | supported |
 | Native keyboard and mouse input | supported |
@@ -49,6 +50,8 @@ For internal testing, `HERDR_MANIFEST_URL` can point the installer at a custom m
 
 Local persistent sessions continue running after the client detaches or its terminal window closes. Servers and pane processes launched through Windows OpenSSH also survive logout; run `herdr` again to reconnect.
 
+Windows OpenSSH starts its normal server in Windows Session 0. Add `--remote-desktop` to a direct remote attach or `machine add` command when agents must interact with apps in the SSH account's active desktop login. Herdr asks before it uses a one-time Windows task for the initial start, removes the task after readiness, and leaves an existing server in another Windows session untouched.
+
 Windows agent process detection scans descendants of the pane shell and recognizes direct agents plus common command wrappers, including npm/Node and Git Bash process chains. It follows Git Bash-launched agents across emulated `exec` boundaries, but it is not the same as Unix foreground process-group detection.
 
 Windows integration installation currently supports Pi, OMP, Claude Code, Codex, GitHub Copilot CLI, Devin CLI, OpenCode, Kilo Code CLI, Droid, Kimi Code CLI, Qoder CLI, and Antigravity CLI. Availability is narrower than on Unix; Herdr hides or rejects integrations whose install format is not supported on Windows.
@@ -80,7 +83,7 @@ switch_ascii_input_source_in_prefix = true
 
 Other Windows IMEs are not supported by this option yet. See [Configuration](/docs/configuration/#prefix-input-source-switching).
 
-Some Windows agents can receive `ctrl+v` and read clipboard images directly. Herdr's own clipboard-image reader is not wired into local native Windows panes, so agent-native image paste remains dependent on the terminal and agent. Agent image-paste shortcuts such as `alt+v` do not add a Herdr-managed local clipboard bridge. Remote clipboard image bridging is supported separately through `herdr --remote` to Linux and macOS hosts.
+Some Windows agents can receive `ctrl+v` and read clipboard images directly. Herdr's own clipboard-image reader is not wired into local native Windows panes, so agent-native image paste remains dependent on the terminal and agent. Agent image-paste shortcuts such as `alt+v` do not add a Herdr-managed local clipboard bridge. Remote clipboard image bridging is supported separately through `herdr --remote` to Linux, macOS, and Windows hosts.
 
 Kitty graphics is enabled by default and depends on the outer terminal. Herdr emits Kitty graphics protocol output on Windows as it does on other platforms. This path has been exercised with Windows WezTerm hosting Herdr through WSL, but native Windows terminal and ConPTY combinations are not all verified. Windows Terminal does not expose the Kitty graphics path Herdr uses. Set `[terminal].kitty_graphics = false` if the outer terminal mishandles graphics output.
 
@@ -118,7 +121,6 @@ For text paste, use `ctrl+shift+v` in Windows Terminal. Multiline text paste is
 | Capability | Status |
 | --- | --- |
 | Direct terminal attach (`herdr terminal attach`) | unsupported |
-| Windows as a `herdr --remote` target host | unsupported |
 | Live server handoff | unsupported |
 | Unix file-descriptor handoff | unsupported |
 | Unix foreground process groups | unsupported |
@@ -131,7 +133,7 @@ From Windows Terminal, use the same remote command as Linux and macOS:
 herdr --remote workbox
 ```
 
-The target host must run Linux or macOS. Herdr uses the installed Windows OpenSSH client and your SSH configuration. Windows OpenSSH does not use Herdr's Unix control-socket reuse, so key authentication through Windows `ssh-agent` is recommended to avoid repeated prompts during remote setup.
+The target host can run Linux, macOS, or Windows. On Windows hosts, remote attach reuses a compatible package from `PATH` or the active managed release. Interactive direct attach and saved-machine setup prompt before installing or updating the complete package when needed. Background saved reconnect only discovers installed packages and cannot prompt for installation or updates. Herdr uses the installed Windows OpenSSH client and your SSH configuration. Windows OpenSSH does not use Herdr's Unix control-socket reuse, so key authentication through Windows `ssh-agent` is recommended to avoid repeated prompts during remote setup.
 
 Windows updates run through the Windows installer and update the active versioned release path. New terminals and reconnected SSH sessions receive that path; start Herdr there to use the updated client. Compatible running servers keep their panes alive. Restart a server later only when you need server-side changes from the release. Live handoff is Unix-only.
 
diff --git a/nix/package.nix b/nix/package.nix
index 87bf39f096..bc23c0602f 100644
--- a/nix/package.nix
+++ b/nix/package.nix
@@ -40,6 +40,7 @@ rustPlatform.buildRustPackage {
     fileset = lib.fileset.intersection (lib.fileset.fromSource (lib.sources.cleanSource ./..)) (
       lib.fileset.unions [
         ../assets
+        ../distribution/install.ps1
         ../docs/next/api/herdr-api.schema.json
         ../src
         ../vendor/libghostty-vt
diff --git a/src/checksum.rs b/src/checksum.rs
index 4f61a33cb2..ed84169b07 100644
--- a/src/checksum.rs
+++ b/src/checksum.rs
@@ -25,7 +25,7 @@ pub(crate) fn verify_sha256(path: &Path, expected: &str) -> io::Result<()> {
     Ok(())
 }
 
-fn file_sha256(path: &Path) -> io::Result<String> {
+pub(crate) fn file_sha256(path: &Path) -> io::Result<String> {
     let mut file = File::open(path)?;
     let mut hasher = Sha256::new();
     let mut buffer = [0u8; 64 * 1024];
diff --git a/src/cli/machine.rs b/src/cli/machine.rs
index a55e4611a7..b74e22583f 100644
--- a/src/cli/machine.rs
+++ b/src/cli/machine.rs
@@ -4,7 +4,7 @@ use crate::client::endpoint::{EndpointCatalog, ProfileId};
 
 const HELP: &str = "Usage:
   herdr machine list [--json]
-  herdr machine add <ssh-target> --label <label> [--remote-session <name>]
+  herdr machine add <ssh-target> --label <label> [--remote-session <name>] [--remote-desktop]
   herdr machine rename <profile-id> --label <label>
   herdr machine remove <profile-id>
   herdr machine enable <profile-id>
@@ -14,7 +14,7 @@ Add prepares the remote Herdr installation and starts its server before saving.
 Missing or incompatible installations require approval in an interactive terminal.
 Changes apply automatically to open local Herdr clients.
 Removing or disabling a machine leaves its remote sessions running.
-Saved machines contain only a label, SSH target, explicit Herdr session, and enabled state.
+Saved machines contain a label, SSH target, explicit Herdr session, enabled state, and desktop hosting choice.
 SSH credentials and key material remain owned by OpenSSH.";
 
 #[derive(Serialize)]
@@ -25,6 +25,7 @@ struct MachineListRow<'a> {
     session: &'a str,
     enabled: bool,
     selected: bool,
+    windows_desktop: bool,
 }
 
 pub(super) fn run_machine_command(args: &[String]) -> std::io::Result<i32> {
@@ -66,6 +67,7 @@ fn list(args: &[String]) -> std::io::Result<i32> {
             session: &profile.session,
             enabled: profile.enabled,
             selected: catalog.selected_profile.as_ref() == Some(&profile.id),
+            windows_desktop: profile.windows_desktop,
         })
         .collect::<Vec<_>>();
     if json {
@@ -93,12 +95,13 @@ fn add(args: &[String]) -> std::io::Result<i32> {
     let args = super::expand_equals_args(args, &["--label", "--remote-session"]);
     let Some(target) = args.first().filter(|value| !value.starts_with('-')) else {
         eprintln!(
-            "usage: herdr machine add <ssh-target> --label <label> [--remote-session <name>]"
+            "usage: herdr machine add <ssh-target> --label <label> [--remote-session <name>] [--remote-desktop]"
         );
         return Ok(2);
     };
     let mut label = None;
     let mut session = None;
+    let mut windows_desktop = false;
     let mut index = 1;
     while index < args.len() {
         let (name, value) = match args[index].as_str() {
@@ -110,6 +113,15 @@ fn add(args: &[String]) -> std::io::Result<i32> {
                 index += 2;
                 (args[index - 2].as_str(), value.clone())
             }
+            "--remote-desktop" if !windows_desktop => {
+                windows_desktop = true;
+                index += 1;
+                continue;
+            }
+            "--remote-desktop" => {
+                eprintln!("--remote-desktop can only be specified once");
+                return Ok(2);
+            }
             unknown => {
                 eprintln!("unknown machine add option: {unknown}");
                 return Ok(2);
@@ -135,14 +147,14 @@ fn add(args: &[String]) -> std::io::Result<i32> {
     };
     let session = session.unwrap_or_else(|| crate::session::DEFAULT_SESSION_NAME.to_owned());
     let mut catalog = load_catalog()?;
-    match catalog.add_ssh(label.clone(), target, session.clone()) {
+    match catalog.add_ssh_with_desktop(label.clone(), target, session.clone(), windows_desktop) {
         Ok(_) => {}
         Err(error) => {
             eprintln!("error: {error}");
             return Ok(2);
         }
     }
-    if let Err(error) = crate::remote::prepare_saved_ssh(target, &session) {
+    if let Err(error) = crate::remote::prepare_saved_ssh(target, &session, windows_desktop) {
         eprintln!("error: {error}; machine was not saved");
         crate::remote::print_remote_error_hint(&error, target);
         return Ok(1);
@@ -153,7 +165,7 @@ fn add(args: &[String]) -> std::io::Result<i32> {
             "remote prepared, but machine was not saved: {error}"
         ))
     })?;
-    let id = match catalog.add_ssh(label, target, session) {
+    let id = match catalog.add_ssh_with_desktop(label, target, session, windows_desktop) {
         Ok(id) => id,
         Err(error) => {
             eprintln!("error: {error}");
@@ -287,6 +299,7 @@ mod tests {
             session: "agents",
             enabled: true,
             selected: false,
+            windows_desktop: false,
         })
         .unwrap();
         assert!(!encoded.contains("password"));
diff --git a/src/cli/status.rs b/src/cli/status.rs
index c6dda462a8..bb613eafec 100644
--- a/src/cli/status.rs
+++ b/src/cli/status.rs
@@ -256,6 +256,8 @@ struct ClientStatusJson {
     protocol: u32,
     endpoint_protocol_generation: u32,
     endpoint_capabilities: Vec<&'static str>,
+    remote_host_bridge: bool,
+    remote_desktop_host: bool,
     binary: String,
     session: Option<String>,
 }
@@ -301,6 +303,8 @@ fn client_status_json() -> ClientStatusJson {
             crate::protocol::endpoint::PRESENTATION_EFFECTS_FENCE_CAPABILITY,
             crate::protocol::endpoint::HEALTH_CHECK_CAPABILITY,
         ],
+        remote_host_bridge: true,
+        remote_desktop_host: cfg!(windows),
         binary: current_exe_label(),
         session: crate::session::active_name(),
     }
diff --git a/src/client/endpoint/activation_tests.rs b/src/client/endpoint/activation_tests.rs
index b66cb98b4f..847d64074c 100644
--- a/src/client/endpoint/activation_tests.rs
+++ b/src/client/endpoint/activation_tests.rs
@@ -92,6 +92,7 @@ fn shell_and_registry_with_source_failure(source_fail_after_write: bool) -> Test
         target: "dev@example.com".into(),
         session: "main".into(),
         enabled: true,
+        windows_desktop: false,
     };
     let target = ClientEndpointId::Ssh(profile.id.clone());
     shell.set_endpoint_catalog(&[profile]);
diff --git a/src/client/endpoint/catalog.rs b/src/client/endpoint/catalog.rs
index 23f26387f4..7b067e3828 100644
--- a/src/client/endpoint/catalog.rs
+++ b/src/client/endpoint/catalog.rs
@@ -23,6 +23,8 @@ pub(crate) struct SavedSshEndpoint {
     pub(crate) target: String,
     pub(crate) session: String,
     pub(crate) enabled: bool,
+    #[serde(default)]
+    pub(crate) windows_desktop: bool,
 }
 
 impl SavedSshEndpoint {
@@ -37,6 +39,7 @@ impl SavedSshEndpoint {
             target: target.into(),
             session: session.into(),
             enabled: true,
+            windows_desktop: false,
         };
         profile.validate()?;
         Ok(profile)
@@ -172,6 +175,20 @@ impl EndpointCatalog {
         Ok(id)
     }
 
+    pub(crate) fn add_ssh_with_desktop(
+        &mut self,
+        label: impl Into<String>,
+        target: impl Into<String>,
+        session: impl Into<String>,
+        windows_desktop: bool,
+    ) -> Result<ProfileId, String> {
+        let id = self.add_ssh(label, target, session)?;
+        if let Some(profile) = self.ssh.last_mut() {
+            profile.windows_desktop = windows_desktop;
+        }
+        Ok(id)
+    }
+
     pub(crate) fn rename_ssh(
         &mut self,
         id: &ProfileId,
@@ -397,7 +414,7 @@ mod tests {
         let _ = std::fs::remove_dir_all(path.parent().unwrap());
         let mut catalog = EndpointCatalog::default();
         let id = catalog
-            .add_ssh("Build", "ssh://dev@build.example:2222", "agents")
+            .add_ssh_with_desktop("Build", "ssh://dev@build.example:2222", "agents", true)
             .unwrap();
         assert!(catalog.select_ssh(&id));
         catalog.store_to_path(&path).unwrap();
@@ -409,9 +426,30 @@ mod tests {
         let loaded = EndpointCatalog::load_from_path(&path).unwrap();
         assert_eq!(loaded, catalog);
         assert_eq!(loaded.ssh[0].id, id);
+        assert!(loaded.ssh[0].windows_desktop);
         std::fs::remove_dir_all(path.parent().unwrap()).unwrap();
     }
 
+    #[test]
+    fn catalogs_from_before_desktop_hosting_default_to_normal_ssh() {
+        let catalog: EndpointCatalog = serde_json::from_str(
+            r#"{
+              "version": 1,
+              "ssh": [{
+                "id": "0123456789abcdef0123456789abcdef",
+                "label": "Build",
+                "target": "build",
+                "session": "default",
+                "enabled": true
+              }]
+            }"#,
+        )
+        .unwrap();
+
+        assert!(!catalog.ssh[0].windows_desktop);
+        catalog.validate().unwrap();
+    }
+
     #[test]
     fn duplicate_target_and_session_profiles_keep_distinct_opaque_ids() {
         let mut catalog = EndpointCatalog::default();
diff --git a/src/client/endpoint/supervisor.rs b/src/client/endpoint/supervisor.rs
index 458ce92740..ad0f70d5f0 100644
--- a/src/client/endpoint/supervisor.rs
+++ b/src/client/endpoint/supervisor.rs
@@ -114,6 +114,7 @@ impl EndpointSupervisors {
                     && profile.enabled
                     && profile.target == previous.target
                     && profile.session == previous.session
+                    && profile.windows_desktop == previous.windows_desktop
             });
             if !keep {
                 retired.push(endpoint_id.clone());
@@ -257,9 +258,9 @@ fn connect_once(
             (stream, Box::new(()))
         }
         ConnectTarget::Ssh(profile) => {
-            let connected = crate::remote::connect_saved_ssh(profile.id.as_str(), &profile.target, &profile.session).map_err(|error| {
+            let connected = crate::remote::connect_saved_ssh(profile.id.as_str(), &profile.target, &profile.session, profile.windows_desktop).map_err(|error| {
                 if failure_needs_attention(&error) {
-                    std::io::Error::new(error.kind(), format!("{error}. Run `{}` interactively to approve setup, then restart this client", crate::remote::saved_ssh_bootstrap_command(&profile.target, &profile.session)))
+                    std::io::Error::new(error.kind(), format!("{error}. Run `{}` interactively to approve setup, then restart this client", crate::remote::saved_ssh_bootstrap_command(&profile.target, &profile.session, profile.windows_desktop)))
                 } else { error }
             })?;
             (connected.stream, Box::new(connected.bridge))
@@ -352,6 +353,7 @@ mod tests {
             target: "build".into(),
             session: "agents".into(),
             enabled: true,
+            windows_desktop: false,
         }
     }
 
diff --git a/src/client/shell/tests/endpoints.rs b/src/client/shell/tests/endpoints.rs
index 52c71923a5..282fa11d36 100644
--- a/src/client/shell/tests/endpoints.rs
+++ b/src/client/shell/tests/endpoints.rs
@@ -11,6 +11,7 @@ fn remote_profile() -> SavedSshEndpoint {
         target: "dev@build.example".into(),
         session: "agents".into(),
         enabled: true,
+        windows_desktop: false,
     }
 }
 
diff --git a/src/client/shell/tests/mobile.rs b/src/client/shell/tests/mobile.rs
index b7cc2a4786..d9f65d5d17 100644
--- a/src/client/shell/tests/mobile.rs
+++ b/src/client/shell/tests/mobile.rs
@@ -78,6 +78,7 @@ fn mobile_switcher_can_activate_an_online_saved_machine() {
         target: "build".into(),
         session: "agents".into(),
         enabled: true,
+        windows_desktop: false,
     };
     let endpoint_id = ClientEndpointId::Ssh(profile.id.clone());
     state.set_endpoint_catalog(&[profile]);
diff --git a/src/main.rs b/src/main.rs
index cf7cf5b481..6f4ab51cb0 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -491,6 +491,13 @@ fn main() -> io::Result<()> {
             std::process::exit(2);
         }
     };
+    let raw_args = match remote::apply_desktop_bootstrap_args(&raw_args) {
+        Ok(args) => args,
+        Err(err) => {
+            eprintln!("error: {err}");
+            std::process::exit(2);
+        }
+    };
     let args = match session::configure_from_args(&raw_args) {
         Ok(args) => args,
         Err(err) => {
@@ -539,7 +546,21 @@ fn main() -> io::Result<()> {
 
     // Subcommands and flags (no TUI, no logging needed)
     if args.get(1).map(|s| s.as_str()) == Some("remote-client-bridge") {
-        return remote::run_remote_client_bridge();
+        let require_desktop = match &args[2..] {
+            [] => false,
+            [flag] if flag == "--require-desktop" => true,
+            _ => {
+                return Err(io::Error::new(
+                    io::ErrorKind::InvalidInput,
+                    "usage: herdr remote-client-bridge [--require-desktop]",
+                ));
+            }
+        };
+        return remote::run_remote_client_bridge(require_desktop);
+    }
+
+    if args.get(1).map(|s| s.as_str()) == Some("remote-desktop") {
+        return remote::run_remote_desktop_command(&args[2..]);
     }
 
     if args.get(1).map(|s| s.as_str()) == Some("server") {
@@ -679,6 +700,7 @@ fn main() -> io::Result<()> {
         println!("Options:");
         println!("  --session <name>    Use or create a named persistent session");
         println!("  --remote <target>   Attach through SSH to a remote Herdr server");
+        println!("  --remote-desktop    Start a Windows remote server in the signed-in desktop");
         println!("  --remote-keybindings <local|server>");
         println!("                      Keybindings for --remote app attach (default: local)");
         println!("  --handoff           Opt into live handoff for update or remote attach");
@@ -719,6 +741,7 @@ fn main() -> io::Result<()> {
         "--session",
         "--remote",
         "--remote-keybindings",
+        "--remote-desktop",
         "--version",
         "-V",
         "--default-config",
@@ -738,6 +761,7 @@ fn main() -> io::Result<()> {
                 "server",
                 "client",
                 "remote-client-bridge",
+                "remote-desktop",
                 "update",
                 "status",
                 "config",
diff --git a/src/platform/fallback.rs b/src/platform/fallback.rs
index 09d82c6ceb..a533796fce 100644
--- a/src/platform/fallback.rs
+++ b/src/platform/fallback.rs
@@ -13,6 +13,19 @@ pub(crate) fn set_default_plugin_pane_pwd(
 ) {
 }
 
+pub(crate) fn forward_remote_bridge_stdio(stream: crate::ipc::LocalStream) -> std::io::Result<()> {
+    use interprocess::TryClone as _;
+
+    let mut stdout = std::io::stdout().lock();
+    let mut socket_to_stdout = stream.try_clone()?;
+    let mut stdin_to_socket = stream;
+    let _upload = std::thread::spawn(move || {
+        let mut stdin = std::io::stdin();
+        let _ = std::io::copy(&mut stdin, &mut stdin_to_socket);
+    });
+    std::io::copy(&mut socket_to_stdout, &mut stdout).map(|_| ())
+}
+
 #[cfg(not(unix))]
 pub(super) fn read_terminal_grid_size() -> std::io::Result<(u16, u16)> {
     crossterm::terminal::size()
diff --git a/src/platform/mod.rs b/src/platform/mod.rs
index d48ad4fa5d..4f3453c98e 100644
--- a/src/platform/mod.rs
+++ b/src/platform/mod.rs
@@ -99,6 +99,21 @@ pub(crate) fn configure_background_command(command: &mut std::process::Command)
     configure_background_command_platform(command);
 }
 
+#[cfg(not(windows))]
+pub(crate) fn verify_remote_desktop_stream(
+    _stream: &crate::ipc::LocalStream,
+) -> std::io::Result<()> {
+    Err(std::io::Error::new(
+        std::io::ErrorKind::Unsupported,
+        "Windows desktop hosting is unavailable on this platform",
+    ))
+}
+
+#[cfg(not(windows))]
+pub(crate) fn detach_remote_desktop_console() -> std::io::Result<()> {
+    Ok(())
+}
+
 #[cfg(not(windows))]
 fn configure_background_command_platform(_command: &mut std::process::Command) {}
 
@@ -264,7 +279,7 @@ pub(crate) struct RemoteSshConfigPaths {
 #[cfg(unix)]
 mod unix_common;
 #[cfg(unix)]
-pub(crate) use unix_common::{begin_cli_output, end_cli_output};
+pub(crate) use unix_common::{begin_cli_output, end_cli_output, forward_remote_bridge_stdio};
 
 mod client_state;
 pub(crate) use client_state::{create_private_state_file, replace_file, sync_parent_directory};
@@ -359,6 +374,35 @@ pub(crate) fn quote_powershell_arg(value: &str) -> String {
     format!("'{}'", value.replace('\'', "''"))
 }
 
+pub(crate) fn quote_windows_command_line_arg(value: &str) -> String {
+    if !value.is_empty()
+        && !value
+            .chars()
+            .any(|ch| matches!(ch, ' ' | '\t' | '\n' | '\x0b' | '"'))
+    {
+        return value.to_string();
+    }
+
+    let mut quoted = String::from("\"");
+    let mut backslashes = 0;
+    for ch in value.chars() {
+        if ch == '\\' {
+            backslashes += 1;
+            continue;
+        }
+        if ch == '"' {
+            quoted.push_str(&"\\".repeat(backslashes * 2 + 1));
+        } else {
+            quoted.push_str(&"\\".repeat(backslashes));
+        }
+        backslashes = 0;
+        quoted.push(ch);
+    }
+    quoted.push_str(&"\\".repeat(backslashes * 2));
+    quoted.push('"');
+    quoted
+}
+
 pub(crate) fn is_pane_shell_process_name(name: &str) -> bool {
     let normalized = normalized_process_name(name);
     matches!(
diff --git a/src/platform/unix_common.rs b/src/platform/unix_common.rs
index 104f6b69d4..6005f0d5bd 100644
--- a/src/platform/unix_common.rs
+++ b/src/platform/unix_common.rs
@@ -27,6 +27,38 @@ pub(crate) fn wait_client_stream_readable(stream: &crate::ipc::LocalStream) -> s
     Ok(())
 }
 
+pub(crate) fn forward_remote_bridge_stdio(stream: crate::ipc::LocalStream) -> std::io::Result<()> {
+    use interprocess::TryClone as _;
+
+    let mut stdout = std::io::stdout().lock();
+    let mut socket_to_stdout = stream.try_clone()?;
+    let mut stdin_to_socket = stream;
+    let _upload = std::thread::spawn(move || {
+        let mut stdin = std::io::stdin();
+        let _ = copy_flush(&mut stdin, &mut stdin_to_socket);
+        let crate::ipc::LocalStream::UdSocket(stream) = stdin_to_socket;
+        let _ = stream.inner().shutdown(std::net::Shutdown::Write);
+    });
+    copy_flush(&mut socket_to_stdout, &mut stdout)
+}
+
+fn copy_flush<R: std::io::Read, W: std::io::Write>(
+    reader: &mut R,
+    writer: &mut W,
+) -> std::io::Result<()> {
+    let mut buffer = [0_u8; 16 * 1024];
+    loop {
+        let read = match reader.read(&mut buffer) {
+            Ok(0) => return Ok(()),
+            Ok(read) => read,
+            Err(err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
+            Err(err) => return Err(err),
+        };
+        writer.write_all(&buffer[..read])?;
+        writer.flush()?;
+    }
+}
+
 pub(super) fn read_terminal_grid_size() -> std::io::Result<(u16, u16)> {
     crossterm::terminal::window_size().map(|size| (size.columns, size.rows))
 }
diff --git a/src/platform/windows.rs b/src/platform/windows.rs
index 4deb18641b..9d30050f10 100644
--- a/src/platform/windows.rs
+++ b/src/platform/windows.rs
@@ -14,6 +14,8 @@ use std::{
 };
 
 mod clipboard_image;
+mod desktop_host;
+pub(crate) use desktop_host::*;
 
 pub(crate) fn classify_child_exit(status: &portable_pty::ExitStatus) -> super::ChildExitReason {
     // STATUS_CONTROL_C_EXIT is reported without a Unix signal by portable-pty.
@@ -33,6 +35,54 @@ pub(crate) fn wait_client_stream_readable(
     Ok(())
 }
 
+pub(crate) fn forward_remote_bridge_stdio(stream: crate::ipc::LocalStream) -> std::io::Result<()> {
+    use interprocess::TryClone as _;
+    use std::sync::atomic::{AtomicBool, Ordering};
+
+    let mut stdout = std::io::stdout().lock();
+    let mut socket_to_stdout = stream.try_clone()?;
+    let mut stdin_to_socket = stream;
+    let upload_done = Arc::new(AtomicBool::new(false));
+    let upload_done_worker = Arc::clone(&upload_done);
+    let _upload = std::thread::spawn(move || {
+        let mut stdin = std::io::stdin();
+        let _ = copy_flush(&mut stdin, &mut stdin_to_socket);
+        upload_done_worker.store(true, Ordering::Release);
+    });
+
+    let mut buffer = [0_u8; 16 * 1024];
+    while !upload_done.load(Ordering::Acquire) {
+        match crate::ipc::poll_local_stream_read_count(&mut socket_to_stdout, &mut buffer)? {
+            crate::ipc::LocalStreamReadCount::Data(read) => {
+                std::io::Write::write_all(&mut stdout, &buffer[..read])?;
+                std::io::Write::flush(&mut stdout)?;
+            }
+            crate::ipc::LocalStreamReadCount::Pending => {
+                std::thread::sleep(Duration::from_millis(1));
+            }
+            crate::ipc::LocalStreamReadCount::Closed => break,
+        }
+    }
+    Ok(())
+}
+
+fn copy_flush<R: std::io::Read, W: std::io::Write>(
+    reader: &mut R,
+    writer: &mut W,
+) -> std::io::Result<()> {
+    let mut buffer = [0_u8; 16 * 1024];
+    loop {
+        let read = match reader.read(&mut buffer) {
+            Ok(0) => return Ok(()),
+            Ok(read) => read,
+            Err(err) if err.kind() == std::io::ErrorKind::Interrupted => continue,
+            Err(err) => return Err(err),
+        };
+        writer.write_all(&buffer[..read])?;
+        writer.flush()?;
+    }
+}
+
 pub(super) fn read_terminal_grid_size() -> std::io::Result<(u16, u16)> {
     crossterm::terminal::size()
 }
@@ -650,7 +700,7 @@ fn powershell_agent_script(argv: &[String]) -> Option<String> {
         .join(" ");
     let command_line = args
         .iter()
-        .map(|arg| quote_windows_command_line_arg(arg))
+        .map(|arg| super::quote_windows_command_line_arg(arg))
         .collect::<Vec<_>>()
         .join(" ");
     Some(format!(
@@ -663,35 +713,6 @@ fn powershell_agent_script(argv: &[String]) -> Option<String> {
     ))
 }
 
-fn quote_windows_command_line_arg(value: &str) -> String {
-    if !value.is_empty()
-        && !value
-            .chars()
-            .any(|ch| matches!(ch, ' ' | '\t' | '\n' | '\x0b' | '"'))
-    {
-        return value.to_string();
-    }
-
-    let mut quoted = String::from("\"");
-    let mut backslashes = 0;
-    for ch in value.chars() {
-        if ch == '\\' {
-            backslashes += 1;
-            continue;
-        }
-        if ch == '"' {
-            quoted.push_str(&"\\".repeat(backslashes * 2 + 1));
-        } else {
-            quoted.push_str(&"\\".repeat(backslashes));
-        }
-        backslashes = 0;
-        quoted.push(ch);
-    }
-    quoted.push_str(&"\\".repeat(backslashes * 2));
-    quoted.push('"');
-    quoted
-}
-
 fn cmd_encoded_powershell_command(script: &str) -> String {
     use base64::Engine as _;
 
@@ -996,7 +1017,7 @@ fn windows_command_line(command: &std::process::Command) -> std::io::Result<Stri
         .chain(command.get_args())
         .map(|value| {
             unicode_windows_value(value, "server command argument")
-                .map(|value| quote_windows_command_line_arg(&value))
+                .map(|value| super::quote_windows_command_line_arg(&value))
         })
         .collect::<std::io::Result<Vec<_>>>()
         .map(|parts| parts.join(" "))
@@ -1099,7 +1120,7 @@ pub fn current_process_is_detached_server_daemon() -> bool {
         return false;
     }
 
-    matches!(current_process_is_in_job(), Ok(false))
+    matches!(current_job_kills_processes_on_close(), Ok(false))
 }
 
 pub fn foreground_job(child_pid: u32) -> Option<ForegroundJob> {
@@ -2992,10 +3013,11 @@ mod tests {
             fs::write(
                 capture,
                 format!(
-                    "{}\n{}\n{}",
+                    "{}\n{}\n{}\n{}",
                     cwd.display(),
                     unsafe { GetConsoleWindow() }.is_null(),
-                    !super::current_job_kills_processes_on_close().expect("inspect WMI daemon job")
+                    !super::current_job_kills_processes_on_close().expect("inspect WMI daemon job"),
+                    super::current_process_is_detached_server_daemon()
                 ),
             )
             .expect("write WMI daemon test capture");
@@ -3026,7 +3048,7 @@ mod tests {
             .expect("launch detached process through WMI");
         assert_ne!(pid, 0, "WMI returned an invalid process id");
 
-        let expected = format!("{}\ntrue\ntrue", base.display());
+        let expected = format!("{}\ntrue\ntrue\ntrue", base.display());
         let deadline = Instant::now() + Duration::from_secs(10);
         loop {
             if fs::read_to_string(&capture).is_ok_and(|captured| captured == expected) {
diff --git a/src/platform/windows/desktop_host.rs b/src/platform/windows/desktop_host.rs
new file mode 100644
index 0000000000..fc472a80bc
--- /dev/null
+++ b/src/platform/windows/desktop_host.rs
@@ -0,0 +1,564 @@
+use std::{
+    ffi::c_void,
+    io,
+    mem::size_of,
+    os::windows::{
+        ffi::OsStrExt,
+        io::{AsRawHandle as _, FromRawHandle as _, OwnedHandle},
+    },
+};
+
+use interprocess::local_socket::traits::StreamCommon as _;
+use windows::{
+    core::{Interface as _, BSTR},
+    Win32::{
+        Foundation::{VARIANT_FALSE, VARIANT_TRUE},
+        System::{
+            Com::{
+                CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_INPROC_SERVER,
+                COINIT_MULTITHREADED,
+            },
+            TaskScheduler::{
+                IExecAction, IRunningTask, ITaskFolder, ITaskService, TaskScheduler,
+                TASK_ACTION_EXEC, TASK_CREATE, TASK_LOGON_INTERACTIVE_TOKEN, TASK_RUNLEVEL_LUA,
+                TASK_RUN_USE_SESSION_ID,
+            },
+            Variant::VARIANT,
+        },
+    },
+};
+use windows_sys::Win32::{
+    Foundation::HANDLE,
+    Security::{
+        GetLengthSid, GetTokenInformation, LookupAccountNameW, TokenSessionId, TokenUser,
+        SID_NAME_USE, TOKEN_QUERY, TOKEN_USER,
+    },
+    System::{
+        Console::{FreeConsole, GetConsoleProcessList},
+        RemoteDesktop::{
+            WTSActive, WTSDomainName, WTSEnumerateSessionsW, WTSFreeMemory,
+            WTSQuerySessionInformationW, WTSUserName, WTS_CURRENT_SERVER_HANDLE, WTS_SESSION_INFOW,
+        },
+        Threading::{
+            GetCurrentProcess, OpenProcess, OpenProcessToken, PROCESS_QUERY_LIMITED_INFORMATION,
+        },
+    },
+};
+
+const DESKTOP_START_TIMEOUT: std::time::Duration = std::time::Duration::from_secs(15);
+const DESKTOP_START_POLL: std::time::Duration = std::time::Duration::from_millis(100);
+
+pub(crate) fn detach_remote_desktop_console() -> io::Result<()> {
+    let mut process_ids = [0_u32; 2];
+    let count =
+        unsafe { GetConsoleProcessList(process_ids.as_mut_ptr(), process_ids.len() as u32) };
+    if count == 0 {
+        return Ok(());
+    }
+    if count != 1 || process_ids[0] != std::process::id() {
+        return Err(io::Error::other(
+            "the Windows desktop launch inherited a shared console",
+        ));
+    }
+    if unsafe { FreeConsole() } == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(())
+}
+
+#[derive(Debug, PartialEq, Eq)]
+struct ProcessIdentity {
+    sid: Vec<u8>,
+    session_id: u32,
+}
+
+#[derive(Debug, serde::Serialize)]
+#[serde(tag = "state", rename_all = "snake_case")]
+pub(crate) enum RemoteDesktopInspection {
+    Ready { pid: u32, windows_session: u32 },
+    Start { windows_session: u32 },
+    Conflict { pid: u32, windows_session: u32 },
+    NoLogin,
+    MultipleLogins,
+}
+
+pub(crate) fn inspect_remote_desktop_host() -> io::Result<RemoteDesktopInspection> {
+    let current = current_process_identity()?;
+    let eligible = eligible_desktop_sessions(&current.sid)?;
+    if crate::server::autodetect::is_server_listening() {
+        let socket_path = crate::server::socket_paths::client_socket_path();
+        let stream = crate::ipc::connect_local_stream(&socket_path)?;
+        let (pid, peer) = peer_identity(&stream)?;
+        return Ok(
+            if peer.sid == current.sid && eligible.contains(&peer.session_id) {
+                RemoteDesktopInspection::Ready {
+                    pid,
+                    windows_session: peer.session_id,
+                }
+            } else {
+                RemoteDesktopInspection::Conflict {
+                    pid,
+                    windows_session: peer.session_id,
+                }
+            },
+        );
+    }
+    Ok(match eligible.as_slice() {
+        [] => RemoteDesktopInspection::NoLogin,
+        [windows_session] => RemoteDesktopInspection::Start {
+            windows_session: *windows_session,
+        },
+        _ => RemoteDesktopInspection::MultipleLogins,
+    })
+}
+
+pub(crate) fn verify_remote_desktop_stream(stream: &crate::ipc::LocalStream) -> io::Result<()> {
+    let (pid, peer) = peer_identity(stream)?;
+    let current = current_process_identity()?;
+    if peer.sid != current.sid {
+        return Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            format!("remote Herdr server process {pid} belongs to a different Windows account"),
+        ));
+    }
+    if !eligible_desktop_sessions(&current.sid)?.contains(&peer.session_id) {
+        return Err(io::Error::new(
+            io::ErrorKind::AlreadyExists,
+            format!(
+                "remote Herdr server process {pid} is not in an active desktop login for this Windows account; use another --session or stop it explicitly"
+            ),
+        ));
+    }
+    Ok(())
+}
+
+fn peer_identity(stream: &crate::ipc::LocalStream) -> io::Result<(u32, ProcessIdentity)> {
+    let pid = stream
+        .peer_creds()?
+        .pid()
+        .ok_or_else(|| io::Error::other("Windows named pipe did not report its server PID"))?;
+    Ok((pid, process_identity(pid)?))
+}
+
+fn eligible_desktop_sessions(current_sid: &[u8]) -> io::Result<Vec<u32>> {
+    let mut sessions = std::ptr::null_mut();
+    let mut count = 0_u32;
+    if unsafe { WTSEnumerateSessionsW(WTS_CURRENT_SERVER_HANDLE, 0, 1, &mut sessions, &mut count) }
+        == 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    let sessions = WtsMemory(sessions.cast::<c_void>());
+    let entries = unsafe {
+        std::slice::from_raw_parts(sessions.0.cast::<WTS_SESSION_INFOW>(), count as usize)
+    };
+    let mut eligible = Vec::new();
+    for entry in entries.iter().filter(|entry| entry.State == WTSActive) {
+        if session_account_sid(entry.SessionId)?.as_deref() == Some(current_sid) {
+            eligible.push(entry.SessionId);
+        }
+    }
+    eligible.sort_unstable();
+    eligible.dedup();
+    Ok(eligible)
+}
+
+fn session_account_sid(session_id: u32) -> io::Result<Option<Vec<u8>>> {
+    let user = wts_session_string(session_id, WTSUserName)?;
+    if user.is_empty() {
+        return Ok(None);
+    }
+    let domain = wts_session_string(session_id, WTSDomainName)?;
+    let account = if domain.is_empty() {
+        user
+    } else {
+        format!(r"{domain}\{user}")
+    };
+    lookup_account_sid(&account).map(Some)
+}
+
+fn wts_session_string(session_id: u32, class: i32) -> io::Result<String> {
+    let mut value = std::ptr::null_mut();
+    let mut bytes = 0_u32;
+    if unsafe {
+        WTSQuerySessionInformationW(
+            WTS_CURRENT_SERVER_HANDLE,
+            session_id,
+            class,
+            &mut value,
+            &mut bytes,
+        )
+    } == 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    let value = WtsMemory(value.cast::<c_void>());
+    let units = unsafe { std::slice::from_raw_parts(value.0.cast::<u16>(), bytes as usize / 2) };
+    let units = units
+        .iter()
+        .position(|unit| *unit == 0)
+        .map(|end| &units[..end])
+        .unwrap_or(units);
+    String::from_utf16(units).map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))
+}
+
+fn lookup_account_sid(account: &str) -> io::Result<Vec<u8>> {
+    let account = std::ffi::OsStr::new(account)
+        .encode_wide()
+        .chain(std::iter::once(0))
+        .collect::<Vec<_>>();
+    let mut sid_bytes = 0_u32;
+    let mut domain_units = 0_u32;
+    let mut sid_type: SID_NAME_USE = 0;
+    unsafe {
+        LookupAccountNameW(
+            std::ptr::null(),
+            account.as_ptr(),
+            std::ptr::null_mut(),
+            &mut sid_bytes,
+            std::ptr::null_mut(),
+            &mut domain_units,
+            &mut sid_type,
+        );
+    }
+    if sid_bytes == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let mut sid = vec![0_u8; sid_bytes as usize];
+    let mut domain = vec![0_u16; domain_units as usize];
+    if unsafe {
+        LookupAccountNameW(
+            std::ptr::null(),
+            account.as_ptr(),
+            sid.as_mut_ptr().cast(),
+            &mut sid_bytes,
+            domain.as_mut_ptr(),
+            &mut domain_units,
+            &mut sid_type,
+        )
+    } == 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    let sid_len = unsafe { GetLengthSid(sid.as_mut_ptr().cast()) } as usize;
+    sid.truncate(sid_len);
+    Ok(sid)
+}
+
+pub(crate) fn start_remote_desktop_server(windows_session: u32, bootstrap: &str) -> io::Result<()> {
+    if !selected_login_is_unique(windows_session)? {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "the selected Windows desktop login is no longer the only active login for this account",
+        ));
+    }
+    let windows_session_i32 = i32::try_from(windows_session).map_err(|_| {
+        io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "the selected Windows session identifier is too large",
+        )
+    })?;
+
+    let _com = ComApartment::initialize()?;
+    let service: ITaskService = unsafe {
+        CoCreateInstance(&TaskScheduler, None, CLSCTX_INPROC_SERVER)
+            .map_err(|error| task_error("create Task Scheduler service", error))?
+    };
+    let empty = VARIANT::default();
+    unsafe {
+        service
+            .Connect(&empty, &empty, &empty, &empty)
+            .map_err(|error| task_error("connect to Task Scheduler", error))?;
+    }
+    let root = unsafe {
+        service
+            .GetFolder(&BSTR::from(r"\"))
+            .map_err(|error| task_error("open the Task Scheduler root", error))?
+    };
+    let definition = unsafe {
+        service
+            .NewTask(0)
+            .map_err(|error| task_error("create a Task Scheduler definition", error))?
+    };
+    let user = unsafe {
+        service
+            .ConnectedUser()
+            .map_err(|error| task_error("read the Task Scheduler account", error))?
+    };
+    let principal = unsafe {
+        definition
+            .Principal()
+            .map_err(|error| task_error("configure the Task Scheduler principal", error))?
+    };
+    unsafe {
+        principal
+            .SetUserId(&user)
+            .and_then(|()| principal.SetLogonType(TASK_LOGON_INTERACTIVE_TOKEN))
+            .and_then(|()| principal.SetRunLevel(TASK_RUNLEVEL_LUA))
+            .map_err(|error| task_error("configure the desktop task account", error))?;
+    }
+
+    let settings = unsafe {
+        definition
+            .Settings()
+            .map_err(|error| task_error("configure desktop task settings", error))?
+    };
+    unsafe {
+        settings
+            .SetAllowDemandStart(VARIANT_TRUE)
+            .and_then(|()| settings.SetDisallowStartIfOnBatteries(VARIANT_FALSE))
+            .and_then(|()| settings.SetStopIfGoingOnBatteries(VARIANT_FALSE))
+            .and_then(|()| settings.SetExecutionTimeLimit(&BSTR::from("PT0S")))
+            .and_then(|()| settings.SetHidden(VARIANT_TRUE))
+            .map_err(|error| task_error("configure desktop task settings", error))?;
+    }
+
+    let executable = std::env::current_exe()?;
+    let executable = executable
+        .to_str()
+        .ok_or_else(|| io::Error::other("Herdr executable path is not valid Unicode"))?;
+    let working_directory = std::env::current_dir()?;
+    let working_directory = working_directory
+        .to_str()
+        .ok_or_else(|| io::Error::other("SSH working directory is not valid Unicode"))?;
+    let arguments = crate::remote::desktop_server_args(bootstrap)
+        .iter()
+        .map(|arg| crate::platform::quote_windows_command_line_arg(arg))
+        .collect::<Vec<_>>()
+        .join(" ");
+    let actions = unsafe {
+        definition
+            .Actions()
+            .map_err(|error| task_error("configure the desktop task action", error))?
+    };
+    let action: IExecAction = unsafe {
+        actions
+            .Create(TASK_ACTION_EXEC)
+            .and_then(|action| action.cast())
+            .map_err(|error| task_error("create the desktop task action", error))?
+    };
+    unsafe {
+        action
+            .SetPath(&BSTR::from(executable))
+            .and_then(|()| action.SetArguments(&BSTR::from(arguments)))
+            .and_then(|()| action.SetWorkingDirectory(&BSTR::from(working_directory)))
+            .map_err(|error| task_error("configure the desktop task executable", error))?;
+    }
+
+    let task_name = BSTR::from(format!(
+        "Herdr Desktop Launch {}-{}",
+        std::process::id(),
+        std::time::SystemTime::now()
+            .duration_since(std::time::UNIX_EPOCH)
+            .unwrap_or_default()
+            .as_nanos()
+    ));
+    let registered = unsafe {
+        root.RegisterTaskDefinition(
+            &task_name,
+            &definition,
+            TASK_CREATE.0,
+            &empty,
+            &empty,
+            TASK_LOGON_INTERACTIVE_TOKEN,
+            &empty,
+        )
+        .map_err(|error| task_error("register the one-time desktop task", error))?
+    };
+
+    // Recheck after registration, immediately before selecting the RunEx session.
+    let recheck = selected_login_is_unique(windows_session);
+    if !matches!(recheck, Ok(true)) {
+        unsafe { root.DeleteTask(&task_name, 0) }
+            .map_err(|error| task_error("remove the one-time desktop task", error))?;
+        return match recheck {
+            Ok(false) => Err(io::Error::new(
+                io::ErrorKind::NotFound,
+                "the selected Windows desktop login changed before Herdr could start",
+            )),
+            Err(error) => Err(error),
+            Ok(true) => unreachable!("handled above"),
+        };
+    }
+    let running = match unsafe {
+        registered.RunEx(
+            &empty,
+            TASK_RUN_USE_SESSION_ID.0,
+            windows_session_i32,
+            &BSTR::default(),
+        )
+    } {
+        Ok(running) => running,
+        Err(error) => {
+            unsafe { root.DeleteTask(&task_name, 0) }
+                .map_err(|cleanup| task_error("remove the one-time desktop task", cleanup))?;
+            return Err(task_error("run the one-time desktop task", error));
+        }
+    };
+    let mut cleanup = TaskLaunchCleanup {
+        root,
+        task_name,
+        running,
+        stop_owned_process: true,
+        task_deleted: false,
+    };
+    let deadline = std::time::Instant::now() + DESKTOP_START_TIMEOUT;
+    loop {
+        let _ = unsafe { cleanup.running.Refresh() };
+        let owned_pid = unsafe { cleanup.running.EnginePID() }.unwrap_or(0);
+        match inspect_remote_desktop_host() {
+            Ok(RemoteDesktopInspection::Ready {
+                pid,
+                windows_session: actual,
+            }) if actual == windows_session && owned_pid != 0 => {
+                cleanup.stop_owned_process = pid != owned_pid;
+                unsafe { cleanup.root.DeleteTask(&cleanup.task_name, 0) }
+                    .map_err(|error| task_error("remove the one-time desktop task", error))?;
+                cleanup.task_deleted = true;
+                return Ok(());
+            }
+            Ok(RemoteDesktopInspection::Conflict { pid, .. }) if pid == owned_pid => {
+                return Err(io::Error::other(
+                    "the launched Herdr server did not enter the selected Windows desktop",
+                ));
+            }
+            Ok(_) | Err(_) if std::time::Instant::now() < deadline => {
+                std::thread::sleep(DESKTOP_START_POLL);
+            }
+            Ok(_) => {
+                return Err(io::Error::new(
+                    io::ErrorKind::TimedOut,
+                    "the Windows desktop Herdr server did not become ready",
+                ));
+            }
+            Err(error) => return Err(error),
+        }
+    }
+}
+
+fn selected_login_is_unique(windows_session: u32) -> io::Result<bool> {
+    Ok(
+        eligible_desktop_sessions(&current_process_identity()?.sid)?.as_slice()
+            == [windows_session],
+    )
+}
+
+fn task_error(context: &str, error: windows::core::Error) -> io::Error {
+    io::Error::other(format!("failed to {context}: {error}"))
+}
+
+struct ComApartment;
+
+impl ComApartment {
+    fn initialize() -> io::Result<Self> {
+        unsafe { CoInitializeEx(None, COINIT_MULTITHREADED) }
+            .ok()
+            .map_err(|error| task_error("initialize COM", error))?;
+        Ok(Self)
+    }
+}
+
+impl Drop for ComApartment {
+    fn drop(&mut self) {
+        unsafe { CoUninitialize() };
+    }
+}
+
+struct TaskLaunchCleanup {
+    root: ITaskFolder,
+    task_name: BSTR,
+    running: IRunningTask,
+    stop_owned_process: bool,
+    task_deleted: bool,
+}
+
+impl Drop for TaskLaunchCleanup {
+    fn drop(&mut self) {
+        unsafe {
+            if self.stop_owned_process {
+                let _ = self.running.Stop();
+            }
+            if !self.task_deleted {
+                let _ = self.root.DeleteTask(&self.task_name, 0);
+            }
+        }
+    }
+}
+
+fn current_process_identity() -> io::Result<ProcessIdentity> {
+    let mut token = std::ptr::null_mut();
+    if unsafe { OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &mut token) } == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let token = unsafe { OwnedHandle::from_raw_handle(token) };
+    token_identity(token.as_raw_handle())
+}
+
+fn process_identity(pid: u32) -> io::Result<ProcessIdentity> {
+    let process = unsafe { OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, 0, pid) };
+    if process.is_null() {
+        return Err(io::Error::last_os_error());
+    }
+    let process = unsafe { OwnedHandle::from_raw_handle(process) };
+    let mut token = std::ptr::null_mut();
+    if unsafe { OpenProcessToken(process.as_raw_handle(), TOKEN_QUERY, &mut token) } == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let token = unsafe { OwnedHandle::from_raw_handle(token) };
+    token_identity(token.as_raw_handle())
+}
+
+fn token_identity(token: HANDLE) -> io::Result<ProcessIdentity> {
+    let mut required = 0;
+    unsafe {
+        GetTokenInformation(token, TokenUser, std::ptr::null_mut(), 0, &mut required);
+    }
+    if required == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let mut user = vec![0_u8; required as usize];
+    if unsafe {
+        GetTokenInformation(
+            token,
+            TokenUser,
+            user.as_mut_ptr().cast(),
+            required,
+            &mut required,
+        )
+    } == 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    let sid_ptr = unsafe { (*(user.as_ptr().cast::<TOKEN_USER>())).User.Sid };
+    let sid_len = unsafe { GetLengthSid(sid_ptr) } as usize;
+    if sid_len == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    let sid = unsafe { std::slice::from_raw_parts(sid_ptr.cast::<u8>(), sid_len) }.to_vec();
+
+    let mut session_id = 0_u32;
+    let mut returned = 0_u32;
+    if unsafe {
+        GetTokenInformation(
+            token,
+            TokenSessionId,
+            (&mut session_id as *mut u32).cast(),
+            size_of::<u32>() as u32,
+            &mut returned,
+        )
+    } == 0
+    {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(ProcessIdentity { sid, session_id })
+}
+
+struct WtsMemory(*mut c_void);
+
+impl Drop for WtsMemory {
+    fn drop(&mut self) {
+        if !self.0.is_null() {
+            unsafe { WTSFreeMemory(self.0) };
+        }
+    }
+}
diff --git a/src/remote.rs b/src/remote.rs
index ba935ec479..fd5ffd229f 100644
--- a/src/remote.rs
+++ b/src/remote.rs
@@ -1,24 +1,17 @@
 mod args;
 mod attach;
-#[cfg(unix)]
-mod host_unix;
+mod desktop;
+mod host;
 mod process;
 mod restart_policy;
 mod saved;
 
 pub(crate) use args::*;
 pub(crate) use attach::*;
-#[cfg(unix)]
-pub(crate) use host_unix::run_remote_client_bridge;
+pub(crate) use desktop::*;
+pub(crate) use host::run_remote_client_bridge;
 pub(crate) use saved::*;
 
-#[cfg(windows)]
-pub(crate) fn run_remote_client_bridge() -> std::io::Result<()> {
-    Err(std::io::Error::other(
-        "remote Windows hosts are not supported yet",
-    ))
-}
-
 pub(crate) fn print_remote_error_hint(err: &std::io::Error, target: &str) {
     if is_remote_auth_error(err) {
         eprintln!(
diff --git a/src/remote/args.rs b/src/remote/args.rs
index 476acf702d..eb1cb66bb7 100644
--- a/src/remote/args.rs
+++ b/src/remote/args.rs
@@ -29,6 +29,7 @@ pub(crate) struct RemoteLaunch {
     pub(crate) target: String,
     pub(crate) keybindings: RemoteKeybindings,
     pub(crate) live_handoff: bool,
+    pub(crate) windows_desktop: bool,
 }
 
 pub(crate) fn extract_remote_args(
@@ -43,6 +44,7 @@ pub(crate) fn extract_remote_args(
     let mut keybindings = RemoteKeybindings::Local;
     let mut keybindings_seen = false;
     let mut live_handoff = false;
+    let mut windows_desktop = false;
     let mut index = 1;
     while index < args.len() {
         let arg = &args[index];
@@ -55,6 +57,14 @@ pub(crate) fn extract_remote_args(
             index += 1;
             continue;
         }
+        if arg == "--remote-desktop" {
+            if windows_desktop {
+                return Err("--remote-desktop can only be specified once".to_string());
+            }
+            windows_desktop = true;
+            index += 1;
+            continue;
+        }
         if arg == "--remote" {
             if remote_target.is_some() {
                 return Err("--remote can only be specified once".to_string());
@@ -104,6 +114,7 @@ pub(crate) fn extract_remote_args(
         target,
         keybindings,
         live_handoff,
+        windows_desktop,
     });
     if remote.is_none() && keybindings_seen {
         return Err("--remote-keybindings requires --remote".to_string());
@@ -111,6 +122,12 @@ pub(crate) fn extract_remote_args(
     if remote.is_none() && live_handoff {
         cleaned.push("--handoff".to_string());
     }
+    if remote.is_none() && windows_desktop {
+        if cleaned.get(1).map(String::as_str) != Some("machine") {
+            return Err("--remote-desktop requires --remote".to_string());
+        }
+        cleaned.push("--remote-desktop".to_string());
+    }
 
     Ok((cleaned, remote))
 }
diff --git a/src/remote/attach.rs b/src/remote/attach.rs
index 10db88a6a7..c8a417d4aa 100644
--- a/src/remote/attach.rs
+++ b/src/remote/attach.rs
@@ -1,13 +1,14 @@
 //! Remote thin-client launcher over SSH command stdio.
 
 use super::{args::*, process::wait_with_output_timeout, restart_policy::*, shell_quote};
+use base64::Engine as _;
 use std::collections::BTreeMap;
 use std::fs::{self, File};
 use std::io::{self, IsTerminal, Write as _};
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output, Stdio};
 
-use interprocess::local_socket::traits::{Listener as _, Stream as _};
+use interprocess::local_socket::traits::Listener as _;
 use interprocess::local_socket::ListenerNonblockingMode;
 use interprocess::TryClone as _;
 use serde::Deserialize;
@@ -28,6 +29,10 @@ const CURRENT_PROTOCOL: u32 = crate::protocol::PROTOCOL_VERSION;
 const STABLE_UPDATE_MANIFEST_URL: &str = "https://herdr.dev/latest.json";
 const PREVIEW_UPDATE_MANIFEST_URL: &str = "https://herdr.dev/preview.json";
 const REMOTE_BINARY_ENV_VAR: &str = "HERDR_REMOTE_BINARY";
+const REMOTE_OUTPUT_READY_MARKER: &str = "herdr-remote-output-ready:1";
+const WINDOWS_REMOTE_PATH_MARKER: &str = "herdr-remote-path:1:";
+const WINDOWS_REMOTE_INSTALL_DIR_MARKER: &str = "herdr-remote-install-dir:1:";
+const WINDOWS_REMOTE_INSTALL_RESULT_MARKER: &str = "herdr-remote-install-result:1:";
 const SSH_CONTROL_SOCKET_NAME: &str = "ctl";
 pub(crate) fn run_remote(remote: RemoteLaunch) -> io::Result<()> {
     let session_name = crate::session::active_name()
@@ -42,6 +47,7 @@ pub(crate) fn run_remote(remote: RemoteLaunch) -> io::Result<()> {
         &session_name,
         remote.keybindings,
         remote.live_handoff,
+        remote.windows_desktop,
     );
     let manage_ssh_config = crate::config::Config::load()
         .config
@@ -55,15 +61,26 @@ pub(crate) fn run_remote(remote: RemoteLaunch) -> io::Result<()> {
         manage_ssh_config,
         session_name.clone(),
     );
-    let prepared_remote =
-        prepare_remote_herdr(&remote_ssh, remote.live_handoff, require_surface_interest)?;
+    let prepared_remote = prepare_remote_herdr(
+        &remote_ssh,
+        remote.live_handoff,
+        require_surface_interest,
+        remote.windows_desktop,
+    )?;
+    if remote.windows_desktop {
+        inspect_desktop_placement(&remote_ssh, &prepared_remote.remote_herdr)?;
+    }
     ensure_remote_server_ready(
         &remote_ssh,
         &prepared_remote.remote_herdr,
         prepared_remote.stop_after_install_approved,
         remote.live_handoff,
         require_surface_interest,
+        remote.windows_desktop,
     )?;
+    if remote.windows_desktop {
+        ensure_desktop_server_ready(&remote_ssh, &prepared_remote.remote_herdr)?;
+    }
 
     let _bridge = SshStdioBridge::start(
         remote.target,
@@ -72,12 +89,17 @@ pub(crate) fn run_remote(remote: RemoteLaunch) -> io::Result<()> {
         session_name,
         remote_ssh.options(),
         false,
+        remote.windows_desktop,
     )?;
 
     run_client_process(&local_socket, &reattach_command, remote.keybindings)
 }
 
-pub(crate) fn prepare_saved_ssh(target: &str, session_name: &str) -> io::Result<()> {
+pub(crate) fn prepare_saved_ssh(
+    target: &str,
+    session_name: &str,
+    windows_desktop: bool,
+) -> io::Result<()> {
     super::validate_remote_target(target)
         .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
     crate::session::validate_name(session_name)
@@ -91,25 +113,33 @@ pub(crate) fn prepare_saved_ssh(target: &str, session_name: &str) -> io::Result<
         manage_ssh_config,
         session_name.to_owned(),
     );
-    let prepared = prepare_remote_herdr(&ssh, false, true)?;
+    let prepared = prepare_remote_herdr(&ssh, false, true, windows_desktop)?;
+    if windows_desktop {
+        inspect_desktop_placement(&ssh, &prepared.remote_herdr)?;
+    }
     ensure_remote_server_ready(
         &ssh,
         &prepared.remote_herdr,
         prepared.stop_after_install_approved,
         false,
         true,
+        windows_desktop,
     )?;
+    if windows_desktop {
+        ensure_desktop_server_ready(&ssh, &prepared.remote_herdr)?;
+    }
 
     // The bridge already owns daemon startup. EOF closes only this temporary attachment,
     // leaving the named server running even when no local TUI is open yet.
-    let output = ssh.sh_output(&format!(
-        "{} </dev/null",
-        remote_bridge_command(&prepared.remote_herdr, session_name)
-    ))?;
+    let command = prepared
+        .remote_herdr
+        .executable
+        .saved_bridge_command(session_name, windows_desktop);
+    let output = ssh.shell_output(&prepared.remote_herdr.platform, &command)?;
     if !output.status.success() {
         return Err(command_failed("remote server startup failed", &output));
     }
-    match remote_server_status(&ssh, &prepared.remote_herdr, true)? {
+    match remote_server_status(&ssh, &prepared.remote_herdr, true, windows_desktop)? {
         RemoteServerStatus::Running {
             endpoint_protocol_generation,
             surface_interest,
@@ -159,6 +189,8 @@ impl RemotePlatform {
             "linux"
         } else if cfg!(target_os = "macos") {
             "macos"
+        } else if cfg!(target_os = "windows") {
+            "windows"
         } else {
             "unknown"
         };
@@ -177,32 +209,225 @@ impl RemotePlatform {
     fn asset_key(&self) -> String {
         format!("{}-{}", self.os, self.arch)
     }
+
+    fn is_windows(&self) -> bool {
+        self.os == "windows"
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum RemoteExecutable {
+    PosixShellPath(String),
+    WindowsPath(String),
+}
+
+impl RemoteExecutable {
+    fn display(&self) -> &str {
+        match self {
+            Self::PosixShellPath(path) | Self::WindowsPath(path) => path,
+        }
+    }
+
+    fn command(&self, args: &[&str]) -> String {
+        match self {
+            Self::PosixShellPath(path) => {
+                let mut command = path.clone();
+                for arg in args {
+                    command.push(' ');
+                    command.push_str(&shell_quote(arg));
+                }
+                command
+            }
+            Self::WindowsPath(path) => windows_powershell_script_command(
+                &windows_powershell_application_script(path, args),
+            ),
+        }
+    }
+
+    fn session_command(&self, session_name: &str, args: &[&str]) -> String {
+        self.command(&Self::session_args(session_name, args))
+    }
+
+    fn session_args<'a>(session_name: &'a str, args: &[&'a str]) -> Vec<&'a str> {
+        let mut session_args = Vec::with_capacity(args.len() + 2);
+        if session_name != crate::session::DEFAULT_SESSION_NAME {
+            session_args.extend(["--session", session_name]);
+        }
+        session_args.extend_from_slice(args);
+        session_args
+    }
+
+    fn exists_command(&self) -> String {
+        match self {
+            Self::PosixShellPath(path) => format!("test -x {path}"),
+            Self::WindowsPath(path) => windows_powershell_script_command(&format!(
+                "if ($null -ne (Get-Command {} -CommandType Application -ErrorAction SilentlyContinue)) {{ exit 0 }}; exit 1",
+                crate::platform::quote_powershell_arg(path)
+            )),
+        }
+    }
+
+    fn status_client_command(&self) -> String {
+        match self {
+            Self::PosixShellPath(path) => format!(
+                "test -x {path} && {}",
+                self.command(&["status", "client", "--json"])
+            ),
+            Self::WindowsPath(_) => self.command(&["status", "client", "--json"]),
+        }
+    }
+
+    fn desktop_inspect_command(&self, session_name: &str) -> String {
+        self.session_command(session_name, &["remote-desktop", "inspect"])
+    }
+
+    fn desktop_start_command(&self, session_name: &str, windows_session: u32) -> String {
+        let windows_session = windows_session.to_string();
+        self.session_command(
+            session_name,
+            &[
+                "remote-desktop",
+                "start",
+                "--windows-session",
+                &windows_session,
+            ],
+        )
+    }
+
+    fn bridge_command(&self, session_name: &str, require_desktop: bool) -> String {
+        let bridge_args = if require_desktop {
+            &["remote-client-bridge", "--require-desktop"][..]
+        } else {
+            &["remote-client-bridge"][..]
+        };
+        let args = Self::session_args(session_name, bridge_args);
+        match self {
+            Self::PosixShellPath(_) => {
+                posix_remote_output_command(&format!("exec {}", self.command(&args)))
+            }
+            Self::WindowsPath(path) => {
+                windows_powershell_streaming_application_command(path, &args)
+            }
+        }
+    }
+
+    fn saved_bridge_command(&self, session_name: &str, require_desktop: bool) -> String {
+        let bridge_args = if require_desktop {
+            &["remote-client-bridge", "--require-desktop"][..]
+        } else {
+            &["remote-client-bridge"][..]
+        };
+        let args = Self::session_args(session_name, bridge_args);
+        match self {
+            Self::PosixShellPath(_) => format!("exec {} </dev/null", self.command(&args)),
+            Self::WindowsPath(path) => {
+                windows_powershell_streaming_application_command(path, &args)
+            }
+        }
+    }
+
+    fn live_handoff_command(&self, session_name: &str, protocol: u32, version: &str) -> String {
+        let protocol = protocol.to_string();
+        match self {
+            Self::PosixShellPath(path) => format!(
+                "{} --import-exe {path} --expected-protocol {} --expected-version {}",
+                self.session_command(session_name, &["server", "live-handoff"]),
+                shell_quote(&protocol),
+                shell_quote(version),
+            ),
+            Self::WindowsPath(path) => self.session_command(
+                session_name,
+                &[
+                    "server",
+                    "live-handoff",
+                    "--import-exe",
+                    path,
+                    "--expected-protocol",
+                    &protocol,
+                    "--expected-version",
+                    version,
+                ],
+            ),
+        }
+    }
 }
 
 #[derive(Debug, Clone)]
 pub(super) struct RemoteHerdr {
     install_suffix: String,
-    shell_path: String,
+    executable: RemoteExecutable,
     platform: RemotePlatform,
 }
 
 impl RemoteHerdr {
     fn for_platform(platform: RemotePlatform) -> Self {
-        let install_suffix = ".local/bin/herdr".to_string();
-        let shell_path = format!("\"$HOME/{install_suffix}\"");
+        let (install_suffix, executable) = if platform.is_windows() {
+            (
+                String::new(),
+                RemoteExecutable::WindowsPath("herdr.exe".to_string()),
+            )
+        } else {
+            let install_suffix = ".local/bin/herdr".to_string();
+            let shell_path = format!("\"$HOME/{install_suffix}\"");
+            (install_suffix, RemoteExecutable::PosixShellPath(shell_path))
+        };
         Self {
             install_suffix,
-            shell_path,
+            executable,
             platform,
         }
     }
 
     fn with_shell_path(mut self, shell_path: String) -> Self {
-        self.shell_path = shell_path;
+        self.executable = RemoteExecutable::PosixShellPath(shell_path);
+        self
+    }
+
+    fn with_windows_path(mut self, path: String) -> Self {
+        self.executable = RemoteExecutable::WindowsPath(path);
         self
     }
 }
 
+fn windows_powershell_application_script(path: &str, args: &[&str]) -> String {
+    let mut script = format!("& {}", crate::platform::quote_powershell_arg(path));
+    for arg in args {
+        script.push(' ');
+        script.push_str(&crate::platform::quote_powershell_arg(arg));
+    }
+    script.push_str("; exit $LASTEXITCODE");
+    script
+}
+
+fn windows_powershell_streaming_application_command(path: &str, args: &[&str]) -> String {
+    let command_line = args
+        .iter()
+        .map(|arg| crate::platform::quote_windows_command_line_arg(arg))
+        .collect::<Vec<_>>()
+        .join(" ");
+    windows_powershell_script_command(&format!(
+        "$process = Start-Process -FilePath {} -ArgumentList {} -NoNewWindow -Wait -PassThru -ErrorAction Stop; exit $process.ExitCode",
+        crate::platform::quote_powershell_arg(path),
+        crate::platform::quote_powershell_arg(&command_line),
+    ))
+}
+
+fn posix_remote_output_command(command: &str) -> String {
+    format!("printf '\n%s\n' '{REMOTE_OUTPUT_READY_MARKER}'\n{command}")
+}
+
+fn windows_powershell_script_command(script: &str) -> String {
+    let script = format!(
+        "[Console]::Out.WriteLine(); [Console]::Out.WriteLine('{REMOTE_OUTPUT_READY_MARKER}'); [Console]::Out.Flush(); {script}"
+    );
+    let utf16 = script
+        .encode_utf16()
+        .flat_map(u16::to_le_bytes)
+        .collect::<Vec<_>>();
+    let encoded = base64::engine::general_purpose::STANDARD.encode(utf16);
+    format!("powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand {encoded}")
+}
+
 #[derive(Debug, Clone, Deserialize)]
 #[serde(untagged)]
 enum RemoteAssetRef {
@@ -414,7 +639,14 @@ impl RemoteSsh {
         command
     }
 
+    fn scp_command(&self) -> Command {
+        let mut command = Command::new("scp");
+        apply_managed_scp_options(&mut command, self.options());
+        command
+    }
+
     fn sh_output(&self, script: &str) -> io::Result<Output> {
+        let script = posix_remote_output_command(script);
         let mut child = self
             .command()
             .arg("/bin/sh -s")
@@ -437,19 +669,35 @@ impl RemoteSsh {
             child.wait_with_output()?
         };
         write_result?;
-        Ok(output)
+        normalize_remote_output(output)
     }
 
-    fn user_shell_output(&self, remote_command: &str) -> io::Result<Output> {
+    fn framed_user_shell_output(&self, remote_command: &str) -> io::Result<Output> {
         let mut command = self.command();
         command
+            // Windows OpenSSH can still read the console with stdin redirected to NUL.
+            .arg("-n")
             .arg(remote_command)
+            .stdin(Stdio::null())
             .stdout(Stdio::piped())
             .stderr(Stdio::piped());
-        if self.noninteractive {
+        let output = if self.noninteractive {
             wait_with_output_timeout(command.spawn()?, NONINTERACTIVE_SSH_COMMAND_TIMEOUT)
         } else {
             command.output()
+        }?;
+        normalize_remote_output(output)
+    }
+
+    fn posix_user_shell_output(&self, remote_command: &str) -> io::Result<Output> {
+        self.framed_user_shell_output(&posix_remote_output_command(remote_command))
+    }
+
+    fn shell_output(&self, platform: &RemotePlatform, remote_command: &str) -> io::Result<Output> {
+        if platform.is_windows() {
+            self.framed_user_shell_output(remote_command)
+        } else {
+            self.sh_output(remote_command)
         }
     }
 
@@ -496,6 +744,104 @@ impl RemoteSsh {
             )))
         }
     }
+
+    fn copy_windows_file(&self, source_path: &Path, remote_path: &str) -> io::Result<()> {
+        let status = self
+            .scp_command()
+            .arg(source_path)
+            .arg(windows_scp_target(&self.target, remote_path))
+            .status()
+            .map_err(|err| io::Error::new(err.kind(), format!("failed to start scp: {err}")))?;
+        if status.success() {
+            Ok(())
+        } else {
+            Err(io::Error::other(format!("scp exited with {status}")))
+        }
+    }
+
+    fn install_windows_herdr(
+        &self,
+        remote_herdr: &RemoteHerdr,
+        source_path: &Path,
+        identity: &str,
+        sha256: &str,
+    ) -> io::Result<RemoteHerdr> {
+        let installer_dir = private_download_dir("windows-installer")?;
+        let local_installer_path = installer_dir.join("install.ps1");
+        if let Err(err) = fs::write(&local_installer_path, crate::update::WINDOWS_INSTALLER) {
+            let _ = fs::remove_dir_all(&installer_dir);
+            return Err(err);
+        }
+
+        let result = (|| {
+            let output = self.framed_user_shell_output(&windows_remote_install_prepare_command())?;
+            if !output.status.success() {
+                return Err(command_failed("remote install preparation failed", &output));
+            }
+            let remote_dir = parse_windows_remote_path(
+                &String::from_utf8_lossy(&output.stdout),
+                WINDOWS_REMOTE_INSTALL_DIR_MARKER,
+            )?;
+            let install_result = (|| {
+                self.copy_windows_file(
+                    &local_installer_path,
+                    &format!(r"{remote_dir}\install.ps1"),
+                )?;
+                self.copy_windows_file(
+                    source_path,
+                    &format!(r"{remote_dir}\herdr-windows-x86_64.zip"),
+                )?;
+
+                let output = self.framed_user_shell_output(&windows_remote_install_command(
+                    &remote_dir,
+                    identity,
+                    sha256,
+                ))?;
+                if !output.status.success() {
+                    return Err(command_failed("remote Windows install failed", &output));
+                }
+                parse_windows_remote_path(
+                    &String::from_utf8_lossy(&output.stdout),
+                    WINDOWS_REMOTE_INSTALL_RESULT_MARKER,
+                )
+                .map(|path| remote_herdr.clone().with_windows_path(path))
+            })();
+
+            let cleanup =
+                self.framed_user_shell_output(&windows_remote_install_cleanup_command(&remote_dir));
+            match install_result {
+                Err(err) => Err(err),
+                Ok(installed) => {
+                    let output = cleanup?;
+                    if output.status.success() {
+                        Ok(installed)
+                    } else {
+                        Err(command_failed("remote install cleanup failed", &output))
+                    }
+                }
+            }
+        })();
+        let _ = fs::remove_dir_all(installer_dir);
+        result
+    }
+}
+
+fn normalize_remote_output(mut output: Output) -> io::Result<Output> {
+    normalize_remote_stdout(&mut output.stdout, output.status.success())?;
+    Ok(output)
+}
+
+fn normalize_remote_stdout(stdout: &mut Vec<u8>, command_succeeded: bool) -> io::Result<()> {
+    let consumed = {
+        let mut reader = io::Cursor::new(stdout.as_slice());
+        match discard_remote_output_preamble(&mut reader) {
+            Ok(()) => reader.position() as usize,
+            Err(_) if !command_succeeded => return Ok(()),
+            Err(err) => return Err(err),
+        }
+    };
+    stdout.drain(..consumed);
+    Ok(())
 }
 
 fn remote_install_prepare_script(remote_herdr: &RemoteHerdr) -> String {
@@ -545,6 +891,72 @@ fn remote_install_commit_script(tmp_path: &str, dest_path: &str) -> String {
     )
 }
 
+fn windows_remote_install_prepare_command() -> String {
+    windows_powershell_script_command(&format!(
+        "$remoteInstallDir = Join-Path ([System.IO.Path]::GetTempPath()) ('herdr-remote-' + [System.Guid]::NewGuid().ToString('N')); [System.IO.Directory]::CreateDirectory($remoteInstallDir) | Out-Null; $encodedInstallDir = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($remoteInstallDir)); [Console]::Out.WriteLine('{WINDOWS_REMOTE_INSTALL_DIR_MARKER}' + $encodedInstallDir); exit 0"
+    ))
+}
+
+fn windows_scp_target(target: &str, remote_path: &str) -> String {
+    let remote_path = remote_path.replace('\\', "/");
+    match target.strip_prefix("ssh://") {
+        Some(authority) => {
+            let mut encoded = String::new();
+            for byte in remote_path.bytes() {
+                if byte.is_ascii_alphanumeric() || b"-_.~/:".contains(&byte) {
+                    encoded.push(char::from(byte));
+                } else {
+                    encoded.push_str(&format!("%{byte:02X}"));
+                }
+            }
+            format!("scp://{authority}/{encoded}")
+        }
+        None => format!("{target}:{remote_path}"),
+    }
+}
+
+fn windows_remote_install_command(remote_dir: &str, identity: &str, sha256: &str) -> String {
+    let installer = crate::platform::quote_powershell_arg(&format!(r"{remote_dir}\install.ps1"));
+    let package =
+        crate::platform::quote_powershell_arg(&format!(r"{remote_dir}\herdr-windows-x86_64.zip"));
+    windows_powershell_script_command(&format!(
+        r#"$herdrInstaller = {installer}; $herdrPackage = {package}; & powershell.exe -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -File $herdrInstaller -Channel {channel} -LocalPackagePath $herdrPackage -LocalPackageFormat zip -LocalPackageIdentity {identity} -LocalPackageSha256 {sha256}; if ($LASTEXITCODE -ne 0) {{ exit $LASTEXITCODE }}; $herdrHome = if ([string]::IsNullOrWhiteSpace($env:HERDR_HOME)) {{ Join-Path $env:USERPROFILE '.herdr' }} else {{ $env:HERDR_HOME }}; $activeJunction = Join-Path $herdrHome 'packages\standalone\current'; $activeTarget = [string](Get-Item -LiteralPath $activeJunction -Force -ErrorAction Stop).Target; if ([string]::IsNullOrWhiteSpace($activeTarget)) {{ throw 'Herdr installer did not activate a concrete release.' }}; $installedHerdr = Join-Path $activeTarget 'herdr.exe'; if (-not (Test-Path -LiteralPath $installedHerdr -PathType Leaf)) {{ throw 'Herdr installer result does not contain herdr.exe.' }}; $encodedResult = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes([System.IO.Path]::GetFullPath($installedHerdr))); [Console]::Out.WriteLine('{WINDOWS_REMOTE_INSTALL_RESULT_MARKER}' + $encodedResult); exit 0"#,
+        channel = crate::platform::quote_powershell_arg(current_channel()),
+        identity = crate::platform::quote_powershell_arg(identity),
+        sha256 = crate::platform::quote_powershell_arg(sha256),
+    ))
+}
+
+fn windows_remote_install_cleanup_command(remote_dir: &str) -> String {
+    windows_powershell_script_command(&format!(
+        "Remove-Item -LiteralPath {} -Recurse -Force -ErrorAction Stop; exit 0",
+        crate::platform::quote_powershell_arg(remote_dir)
+    ))
+}
+
+fn parse_windows_remote_path(stdout: &str, marker: &str) -> io::Result<String> {
+    let encoded = stdout
+        .lines()
+        .rev()
+        .find_map(|line| line.trim().strip_prefix(marker))
+        .ok_or_else(|| io::Error::other(format!("remote command did not return {marker}")))?;
+    decode_windows_remote_path(encoded)
+}
+
+fn decode_windows_remote_path(encoded: &str) -> io::Result<String> {
+    let bytes = base64::engine::general_purpose::STANDARD
+        .decode(encoded)
+        .map_err(|err| {
+            io::Error::other(format!("remote path result is not valid base64: {err}"))
+        })?;
+    let path = String::from_utf8(bytes)
+        .map_err(|err| io::Error::other(format!("remote path result is not valid UTF-8: {err}")))?;
+    if path.is_empty() {
+        return Err(io::Error::other("remote path result is empty"));
+    }
+    Ok(path)
+}
+
 impl Drop for RemoteSsh {
     fn drop(&mut self) {
         let Some(_options) = self
@@ -605,6 +1017,26 @@ fn apply_managed_ssh_options(command: &mut Command, options: Option<&ManagedSshO
     }
 }
 
+fn apply_managed_scp_options(command: &mut Command, options: Option<&ManagedSshOptions>) {
+    let Some(options) = options else {
+        return;
+    };
+
+    command.arg("-F").arg(&options.config_path);
+    if let Some(control_path) = &options.control_path {
+        command
+            .arg("-o")
+            .arg(format!(
+                "ControlPath={}",
+                ssh_config_quote(&control_path.to_string_lossy())
+            ))
+            .arg("-o")
+            .arg("ControlMaster=auto")
+            .arg("-o")
+            .arg("ControlPersist=yes");
+    }
+}
+
 impl InstallSource {
     fn persistent(path: PathBuf) -> Self {
         Self {
@@ -631,16 +1063,29 @@ pub(super) fn prepare_remote_herdr(
     ssh: &RemoteSsh,
     live_handoff_enabled: bool,
     require_surface_interest: bool,
+    require_desktop: bool,
 ) -> io::Result<PreparedRemoteHerdr> {
     let platform = detect_remote_platform(ssh)?;
+    if require_desktop && !platform.is_windows() {
+        return Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "--remote-desktop requires a Windows SSH target",
+        ));
+    }
     let remote_herdr = RemoteHerdr::for_platform(platform);
     let override_binary = remote_binary_override_path()?;
+    let custom_package = override_binary.is_some();
     let remote_binary_candidates = remote_binary_candidates(ssh, &remote_herdr)?;
 
     if override_binary.is_none() {
         for candidate in &remote_binary_candidates {
-            if remote_binary_supports_endpoint_requirement(ssh, candidate, require_surface_interest)
-                .unwrap_or(false)
+            if remote_binary_supports_endpoint_requirement(
+                ssh,
+                candidate,
+                require_surface_interest,
+                require_desktop,
+            )
+            .unwrap_or(false)
             {
                 return Ok(PreparedRemoteHerdr {
                     remote_herdr: candidate.clone(),
@@ -648,11 +1093,14 @@ pub(super) fn prepare_remote_herdr(
                 });
             }
         }
-        if remote_binary_supports_endpoint_requirement(
-            ssh,
-            &remote_herdr,
-            require_surface_interest,
-        )? {
+        if !remote_herdr.platform.is_windows()
+            && remote_binary_supports_endpoint_requirement(
+                ssh,
+                &remote_herdr,
+                require_surface_interest,
+                require_desktop,
+            )?
+        {
             return Ok(PreparedRemoteHerdr {
                 remote_herdr,
                 stop_after_install_approved: false,
@@ -661,17 +1109,20 @@ pub(super) fn prepare_remote_herdr(
     }
 
     let mut stop_after_install_approved = false;
-    if let Some(status_probe_herdr) = remote_binary_candidates.first().or_else(|| {
-        remote_binary_exists(ssh, &remote_herdr)
-            .ok()
-            .and_then(|exists| exists.then_some(&remote_herdr))
-    }) {
-        stop_after_install_approved = confirm_remote_install_with_running_server(
-            ssh,
-            status_probe_herdr,
-            live_handoff_enabled,
-            require_surface_interest,
-        )?;
+    if !require_desktop {
+        if let Some(status_probe_herdr) = remote_binary_candidates.first().or_else(|| {
+            (!remote_herdr.platform.is_windows())
+                .then(|| remote_binary_exists(ssh, &remote_herdr).ok())
+                .flatten()
+                .and_then(|exists| exists.then_some(&remote_herdr))
+        }) {
+            stop_after_install_approved = confirm_remote_install_with_running_server(
+                ssh,
+                status_probe_herdr,
+                live_handoff_enabled,
+                require_surface_interest,
+            )?;
+        }
     }
     if !stop_after_install_approved {
         confirm_remote_install(
@@ -681,17 +1132,37 @@ pub(super) fn prepare_remote_herdr(
         )?;
     }
     let source = resolve_install_source(&remote_herdr.platform, override_binary)?;
-    let install_result = ssh.install_herdr(&remote_herdr, &source.path);
+    let install_result = (|| {
+        if remote_herdr.platform.is_windows() {
+            let sha256 = crate::checksum::file_sha256(&source.path)?;
+            ssh.install_windows_herdr(
+                &remote_herdr,
+                &source.path,
+                &windows_package_identity(custom_package, &sha256),
+                &sha256,
+            )
+        } else {
+            ssh.install_herdr(&remote_herdr, &source.path)?;
+            Ok(remote_herdr.clone())
+        }
+    })();
     source.cleanup();
-    install_result?;
+    let remote_herdr = install_result?;
 
-    if !remote_binary_supports_endpoint_requirement(ssh, &remote_herdr, require_surface_interest)? {
+    if !remote_binary_supports_endpoint_requirement(
+        ssh,
+        &remote_herdr,
+        require_surface_interest,
+        require_desktop,
+    )? {
         return Err(io::Error::other(format!(
-            "installed remote herdr at {}, but it does not support saved SSH endpoint federation",
-            remote_herdr.shell_path
+            "installed remote herdr at {}, but it does not support the required remote hosting capabilities",
+            remote_herdr.executable.display()
         )));
     }
-    warn_if_remote_bin_not_on_path(ssh)?;
+    if !remote_herdr.platform.is_windows() {
+        warn_if_remote_bin_not_on_path(ssh)?;
+    }
 
     Ok(PreparedRemoteHerdr {
         remote_herdr,
@@ -699,12 +1170,15 @@ pub(super) fn prepare_remote_herdr(
     })
 }
 
-pub(super) fn find_installed_remote_herdr(ssh: &RemoteSsh) -> io::Result<RemoteHerdr> {
+pub(super) fn find_installed_remote_herdr(
+    ssh: &RemoteSsh,
+    require_desktop: bool,
+) -> io::Result<RemoteHerdr> {
     let platform = detect_remote_platform(ssh)?;
     let remote_herdr = RemoteHerdr::for_platform(platform);
     let candidates = remote_binary_candidates(ssh, &remote_herdr)?;
     for candidate in candidates {
-        if remote_binary_supports_endpoint_requirement(ssh, &candidate, true)? {
+        if remote_binary_supports_endpoint_requirement(ssh, &candidate, true, require_desktop)? {
             return Ok(candidate);
         }
     }
@@ -717,30 +1191,97 @@ pub(super) fn find_installed_remote_herdr(ssh: &RemoteSsh) -> io::Result<RemoteH
         ),
     ))
 }
-
 fn detect_remote_platform(ssh: &RemoteSsh) -> io::Result<RemotePlatform> {
     let output = ssh.sh_output("uname -s\nuname -m\n")?;
-    if !output.status.success() {
-        return Err(command_failed("remote platform detection failed", &output));
-    }
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let mut lines = stdout.lines();
-    let os = lines.next().unwrap_or_default();
-    let arch = lines.next().unwrap_or_default();
-    RemotePlatform::from_uname(os, arch).ok_or_else(|| {
+    let mut windows_uname_hint = false;
+    let posix_error = if output.status.success() {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let mut lines = stdout.lines();
+        let os = lines.next().unwrap_or_default();
+        let arch = lines.next().unwrap_or_default();
+        if let Some(platform) = RemotePlatform::from_uname(os, arch) {
+            return Ok(platform);
+        }
+        windows_uname_hint = looks_like_windows_uname(os);
         io::Error::other(format!(
             "unsupported remote platform: {} {}",
             os.trim(),
             arch.trim()
         ))
-    })
+    } else {
+        command_failed("remote platform detection failed", &output)
+    };
+
+    if !should_try_windows_probe(
+        output.status.success(),
+        output.status.code(),
+        windows_uname_hint,
+    ) {
+        return Err(posix_error);
+    }
+    let windows_output = match ssh.framed_user_shell_output(&windows_platform_probe_command()) {
+        Ok(output) if output.status.success() => output,
+        _ => return Err(posix_error),
+    };
+    match parse_windows_platform_probe(&String::from_utf8_lossy(&windows_output.stdout)) {
+        Ok(Some(platform)) => Ok(platform),
+        Ok(None) => Err(posix_error),
+        Err(message) => Err(io::Error::other(message)),
+    }
+}
+
+fn should_try_windows_probe(
+    success: bool,
+    exit_code: Option<i32>,
+    windows_uname_hint: bool,
+) -> bool {
+    (success && windows_uname_hint) || (!success && exit_code.is_some_and(|code| code != 255))
+}
+
+fn looks_like_windows_uname(os: &str) -> bool {
+    let os = os.trim().to_ascii_uppercase();
+    ["MINGW", "MSYS", "CYGWIN"]
+        .iter()
+        .any(|prefix| os.starts_with(prefix))
+}
+
+fn windows_platform_probe_command() -> String {
+    windows_powershell_script_command(
+        "$arch = if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }; [Console]::Out.WriteLine('herdr-windows:' + $arch); exit 0",
+    )
+}
+
+fn parse_windows_platform_probe(stdout: &str) -> Result<Option<RemotePlatform>, String> {
+    let Some(arch) = stdout
+        .lines()
+        .find_map(|line| line.trim().strip_prefix("herdr-windows:"))
+    else {
+        return Ok(None);
+    };
+    match arch.trim().to_ascii_uppercase().as_str() {
+        "AMD64" | "X86_64" => Ok(Some(RemotePlatform {
+            os: "windows",
+            arch: "x86_64",
+        })),
+        arch => Err(format!("unsupported remote platform: Windows {arch}")),
+    }
 }
 
 fn remote_binary_candidates(
     ssh: &RemoteSsh,
     remote_herdr: &RemoteHerdr,
 ) -> io::Result<Vec<RemoteHerdr>> {
+    if remote_herdr.platform.is_windows() {
+        let output = ssh.framed_user_shell_output(&windows_remote_binary_candidate_command())?;
+        if !output.status.success() {
+            return Err(command_failed("remote binary discovery failed", &output));
+        }
+        return Ok(windows_remote_binary_candidates(
+            remote_herdr,
+            &String::from_utf8_lossy(&output.stdout),
+        ));
+    }
+
     let mut candidates = Vec::new();
 
     if let Some(path_candidate) = remote_binary_on_path_any(ssh, remote_herdr)? {
@@ -761,10 +1302,31 @@ fn remote_binary_candidates(
     Ok(candidates)
 }
 
+fn windows_remote_binary_candidate_command() -> String {
+    windows_powershell_script_command(&format!(
+        r#"function Emit-HerdrPath([string]$CandidatePath) {{ if ([string]::IsNullOrWhiteSpace($CandidatePath) -or -not (Test-Path -LiteralPath $CandidatePath -PathType Leaf)) {{ return }}; $candidateFullPath = [System.IO.Path]::GetFullPath($CandidatePath); $encodedCandidate = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($candidateFullPath)); [Console]::Out.WriteLine('{WINDOWS_REMOTE_PATH_MARKER}' + $encodedCandidate) }}; $pathCommand = Get-Command herdr.exe -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1; if ($null -ne $pathCommand) {{ Emit-HerdrPath $pathCommand.Source }}; $herdrHome = if ([string]::IsNullOrWhiteSpace($env:HERDR_HOME)) {{ Join-Path $env:USERPROFILE '.herdr' }} else {{ $env:HERDR_HOME }}; $activeJunction = Get-Item -LiteralPath (Join-Path $herdrHome 'packages\standalone\current') -Force -ErrorAction SilentlyContinue; if ($null -ne $activeJunction -and -not [string]::IsNullOrWhiteSpace([string]$activeJunction.Target)) {{ Emit-HerdrPath (Join-Path ([string]$activeJunction.Target) 'herdr.exe') }}; exit 0"#
+    ))
+}
+
+fn windows_remote_binary_candidates(remote_herdr: &RemoteHerdr, stdout: &str) -> Vec<RemoteHerdr> {
+    let mut candidates = Vec::new();
+    for path in stdout.lines().filter_map(|line| {
+        line.trim()
+            .strip_prefix(WINDOWS_REMOTE_PATH_MARKER)
+            .and_then(|encoded| decode_windows_remote_path(encoded).ok())
+    }) {
+        push_if_new_remote_binary_candidate(
+            &mut candidates,
+            remote_herdr.clone().with_windows_path(path),
+        );
+    }
+    candidates
+}
+
 fn push_if_new_remote_binary_candidate(candidates: &mut Vec<RemoteHerdr>, candidate: RemoteHerdr) {
     if !candidates
         .iter()
-        .any(|existing| existing.shell_path == candidate.shell_path)
+        .any(|existing| existing.executable == candidate.executable)
     {
         candidates.push(candidate);
     }
@@ -824,7 +1386,7 @@ fn remote_binary_on_path_any(
     ssh: &RemoteSsh,
     remote_herdr: &RemoteHerdr,
 ) -> io::Result<Option<RemoteHerdr>> {
-    let output = ssh.user_shell_output("command -v herdr")?;
+    let output = ssh.posix_user_shell_output("command -v herdr")?;
     if output.status.success() {
         let stdout = String::from_utf8_lossy(&output.stdout);
         if let Some(candidate) = remote_herdr_from_path_discovery(remote_herdr, &stdout) {
@@ -878,11 +1440,8 @@ fn remote_client_status(
     ssh: &RemoteSsh,
     remote_herdr: &RemoteHerdr,
 ) -> io::Result<Option<RemoteClientStatusJson>> {
-    let command = format!(
-        "test -x {0} && {0} status client --json",
-        remote_herdr.shell_path
-    );
-    let output = ssh.sh_output(&command)?;
+    let command = remote_herdr.executable.status_client_command();
+    let output = ssh.shell_output(&remote_herdr.platform, &command)?;
     if !output.status.success() {
         if output.status.code() == Some(255) {
             return Err(command_failed("remote SSH connection failed", &output));
@@ -894,18 +1453,142 @@ fn remote_client_status(
     )))
 }
 
+#[derive(Debug, Deserialize, PartialEq, Eq)]
+#[serde(tag = "state", rename_all = "snake_case")]
+enum RemoteDesktopInspection {
+    Ready { pid: u32, windows_session: u32 },
+    Start { windows_session: u32 },
+    Conflict { pid: u32, windows_session: u32 },
+    NoLogin,
+    MultipleLogins,
+}
+
+fn remote_desktop_inspection(
+    ssh: &RemoteSsh,
+    remote_herdr: &RemoteHerdr,
+) -> io::Result<RemoteDesktopInspection> {
+    let command = remote_herdr
+        .executable
+        .desktop_inspect_command(&ssh.session_name);
+    let output = ssh.shell_output(&remote_herdr.platform, &command)?;
+    if !output.status.success() {
+        return Err(command_failed(
+            "remote Windows desktop inspection failed",
+            &output,
+        ));
+    }
+    String::from_utf8_lossy(&output.stdout)
+        .lines()
+        .filter_map(|line| serde_json::from_str(line).ok())
+        .next_back()
+        .ok_or_else(|| {
+            io::Error::new(
+                io::ErrorKind::InvalidData,
+                "remote Herdr did not report Windows desktop placement",
+            )
+        })
+}
+
+fn inspect_desktop_placement(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result<()> {
+    match remote_desktop_inspection(ssh, remote_herdr)? {
+        RemoteDesktopInspection::Ready { .. } | RemoteDesktopInspection::Start { .. } => Ok(()),
+        inspection => desktop_inspection_error(inspection),
+    }
+}
+
+fn ensure_desktop_server_ready(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result<()> {
+    let windows_session = match remote_desktop_inspection(ssh, remote_herdr)? {
+        RemoteDesktopInspection::Ready { .. } => return Ok(()),
+        RemoteDesktopInspection::Start { windows_session } => windows_session,
+        inspection => return desktop_inspection_error(inspection),
+    };
+    if !io::stdin().is_terminal() {
+        return Err(io::Error::new(
+            io::ErrorKind::PermissionDenied,
+            "starting Herdr in the signed-in Windows desktop requires approval in an interactive terminal",
+        ));
+    }
+    eprint!(
+        "Start Herdr in your signed-in Windows desktop? Agents can interact with desktop apps. A one-time Windows task will launch Herdr and be removed once it's ready. [y/N] "
+    );
+    io::stderr().flush()?;
+    if !read_remote_confirmation(&mut io::stdin().lock(), false)? {
+        return Err(io::Error::new(
+            io::ErrorKind::Interrupted,
+            "Windows desktop server start cancelled",
+        ));
+    }
+    let command = remote_herdr
+        .executable
+        .desktop_start_command(&ssh.session_name, windows_session);
+    let output = ssh.shell_output(&remote_herdr.platform, &command)?;
+    if !output.status.success() {
+        return Err(command_failed(
+            "remote Windows desktop start failed",
+            &output,
+        ));
+    }
+    match remote_desktop_inspection(ssh, remote_herdr)? {
+        RemoteDesktopInspection::Ready {
+            windows_session: actual,
+            ..
+        } if actual == windows_session => Ok(()),
+        inspection => desktop_inspection_error(inspection),
+    }
+}
+
+fn desktop_inspection_error(inspection: RemoteDesktopInspection) -> io::Result<()> {
+    match inspection {
+        RemoteDesktopInspection::Conflict {
+            pid,
+            windows_session,
+        } => Err(io::Error::new(
+            io::ErrorKind::AlreadyExists,
+            format!(
+                "remote Herdr server process {pid} is running in nonqualifying Windows session {windows_session}; use another --session or stop it explicitly"
+            ),
+        )),
+        RemoteDesktopInspection::NoLogin => Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "no active desktop login exists for this Windows account; sign in to Windows first",
+        )),
+        RemoteDesktopInspection::MultipleLogins => Err(io::Error::new(
+            io::ErrorKind::Unsupported,
+            "more than one active desktop login exists for this Windows account; disconnect the extra login before starting Herdr",
+        )),
+        RemoteDesktopInspection::Start { .. } => Err(io::Error::new(
+            io::ErrorKind::TimedOut,
+            "the Windows desktop Herdr server did not become ready",
+        )),
+        RemoteDesktopInspection::Ready { .. } => Err(io::Error::other(
+            "the Windows desktop Herdr server started in a different login",
+        )),
+    }
+}
+
 fn remote_binary_supports_endpoint_requirement(
     ssh: &RemoteSsh,
     remote_herdr: &RemoteHerdr,
     require_surface_interest: bool,
+    require_desktop: bool,
 ) -> io::Result<bool> {
-    Ok(remote_client_status(ssh, remote_herdr)?
-        .is_some_and(|status| status.supports_endpoint_requirement(require_surface_interest)))
+    Ok(
+        remote_client_status(ssh, remote_herdr)?.is_some_and(|status| {
+            status.supports_endpoint_requirement(
+                &remote_herdr.platform,
+                require_surface_interest,
+                require_desktop,
+            )
+        }),
+    )
 }
 
 fn remote_binary_exists(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result<bool> {
-    let command = format!("test -x {}", remote_herdr.shell_path);
-    Ok(ssh.sh_output(&command)?.status.success())
+    let command = remote_herdr.executable.exists_command();
+    Ok(ssh
+        .shell_output(&remote_herdr.platform, &command)?
+        .status
+        .success())
 }
 
 fn remote_binary_override_path() -> io::Result<Option<PathBuf>> {
@@ -979,7 +1662,7 @@ fn resolve_install_source(
         return Ok(InstallSource::persistent(path));
     }
 
-    if *platform == RemotePlatform::local() {
+    if !platform.is_windows() && *platform == RemotePlatform::local() {
         let path = std::env::current_exe()?;
         if !crate::update::is_package_manager_managed_exe_path(&path) {
             return Ok(InstallSource::persistent(path));
@@ -990,7 +1673,7 @@ fn resolve_install_source(
 }
 
 fn local_binary_can_seed_remote(platform: &RemotePlatform) -> bool {
-    if *platform != RemotePlatform::local() {
+    if platform.is_windows() || *platform != RemotePlatform::local() {
         return false;
     }
 
@@ -999,6 +1682,14 @@ fn local_binary_can_seed_remote(platform: &RemotePlatform) -> bool {
         .unwrap_or(false)
 }
 
+fn windows_package_identity(custom: bool, sha256: &str) -> String {
+    if custom {
+        format!("{}-custom.{sha256}", current_version())
+    } else {
+        current_version()
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum RemoteServerStatus {
     Running {
@@ -1036,8 +1727,10 @@ fn ensure_remote_server_ready(
     stop_after_install_approved: bool,
     live_handoff_enabled: bool,
     require_surface_interest: bool,
+    require_desktop: bool,
 ) -> io::Result<()> {
-    let status = remote_server_status(ssh, remote_herdr, require_surface_interest)?;
+    let status =
+        remote_server_status(ssh, remote_herdr, require_surface_interest, require_desktop)?;
     let RemoteServerStatus::Running {
         version,
         endpoint_protocol_generation,
@@ -1088,7 +1781,7 @@ fn confirm_remote_install_with_running_server(
     require_surface_interest: bool,
 ) -> io::Result<bool> {
     let target = ssh.destination();
-    let status = match remote_server_status(ssh, remote_herdr, require_surface_interest) {
+    let status = match remote_server_status(ssh, remote_herdr, require_surface_interest, false) {
         Ok(status) => status,
         Err(err) => {
             if !io::stdin().is_terminal() {
@@ -1200,9 +1893,12 @@ fn remote_server_status(
     ssh: &RemoteSsh,
     remote_herdr: &RemoteHerdr,
     require_surface_interest: bool,
+    require_desktop: bool,
 ) -> io::Result<RemoteServerStatus> {
-    let command = remote_session_command(remote_herdr, &ssh.session_name, "status server --json");
-    let output = ssh.sh_output(&command)?;
+    let command = remote_herdr
+        .executable
+        .session_command(&ssh.session_name, &["status", "server", "--json"]);
+    let output = ssh.shell_output(&remote_herdr.platform, &command)?;
     if !output.status.success() {
         return Err(command_failed("remote server status failed", &output));
     }
@@ -1224,7 +1920,7 @@ fn remote_server_status(
     {
         // Older status helpers omit newer capabilities. Ask the live endpoint rather than
         // assuming that the installed binary and the running daemon support the same features.
-        let negotiation = probe_remote_endpoint(ssh, remote_herdr)?;
+        let negotiation = probe_remote_endpoint(ssh, remote_herdr, require_desktop)?;
         return Ok(status.with_endpoint_negotiation(&negotiation));
     }
     Ok(status)
@@ -1233,6 +1929,7 @@ fn remote_server_status(
 fn probe_remote_endpoint(
     ssh: &RemoteSsh,
     remote_herdr: &RemoteHerdr,
+    require_desktop: bool,
 ) -> io::Result<crate::client::endpoint::EndpointNegotiation> {
     let path = local_forward_socket_path(ssh.target(), &ssh.session_name);
     let _bridge = SshStdioBridge::start(
@@ -1242,6 +1939,7 @@ fn probe_remote_endpoint(
         ssh.session_name.clone(),
         None,
         true,
+        require_desktop,
     )?;
     let mut stream = crate::ipc::connect_local_stream(&path)?;
     // Use the saved client's noninteractive path. This metadata-only attachment never
@@ -1259,12 +1957,23 @@ struct RemoteClientStatusJson {
     endpoint_protocol_generation: Option<u32>,
     #[serde(default)]
     endpoint_capabilities: Vec<String>,
+    #[serde(default)]
+    remote_host_bridge: bool,
+    #[serde(default)]
+    remote_desktop_host: bool,
 }
 
 impl RemoteClientStatusJson {
-    fn supports_endpoint_requirement(&self, require_surface_interest: bool) -> bool {
+    fn supports_endpoint_requirement(
+        &self,
+        platform: &RemotePlatform,
+        require_surface_interest: bool,
+        require_desktop: bool,
+    ) -> bool {
         self.endpoint_protocol_generation
             == Some(crate::protocol::endpoint::ENDPOINT_PROTOCOL_GENERATION)
+            && (!platform.is_windows() || self.remote_host_bridge)
+            && (!require_desktop || self.remote_desktop_host)
             && (!require_surface_interest
                 || [
                     crate::protocol::endpoint::SURFACE_INTEREST_CAPABILITY,
@@ -1420,22 +2129,6 @@ fn confirm_remote_server_stop(
     Ok(false)
 }
 
-fn remote_live_handoff_command(
-    remote_herdr: &RemoteHerdr,
-    session_name: &str,
-    protocol: u32,
-    version: &str,
-) -> String {
-    remote_session_command(
-        remote_herdr,
-        session_name,
-        &format!(
-            "server live-handoff --import-exe {} --expected-protocol {} --expected-version {}",
-            remote_herdr.shell_path, protocol, version
-        ),
-    )
-}
-
 fn live_handoff_remote_server(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result<()> {
     let status = remote_client_status(ssh, remote_herdr)?.ok_or_else(|| {
         io::Error::other("could not inspect the prepared remote herdr binary before live handoff")
@@ -1447,8 +2140,11 @@ fn live_handoff_remote_server(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io
         .version
         .filter(|version| !version.is_empty())
         .ok_or_else(|| io::Error::other("prepared remote herdr did not report its version"))?;
-    let command = remote_live_handoff_command(remote_herdr, &ssh.session_name, protocol, &version);
-    let output = ssh.sh_output(&command)?;
+    let command =
+        remote_herdr
+            .executable
+            .live_handoff_command(&ssh.session_name, protocol, &version);
+    let output = ssh.shell_output(&remote_herdr.platform, &command)?;
     if !output.status.success() {
         return Err(command_failed("remote server live handoff failed", &output));
     }
@@ -1461,8 +2157,10 @@ fn live_handoff_remote_server(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io
 }
 
 fn stop_remote_server(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result<()> {
-    let command = remote_session_command(remote_herdr, &ssh.session_name, "server stop");
-    let output = ssh.sh_output(&command)?;
+    let command = remote_herdr
+        .executable
+        .session_command(&ssh.session_name, &["server", "stop"]);
+    let output = ssh.shell_output(&remote_herdr.platform, &command)?;
     if !output.status.success() {
         return Err(command_failed("remote server stop failed", &output));
     }
@@ -1478,7 +2176,8 @@ fn stop_remote_server(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result
 fn wait_for_remote_server_shutdown(ssh: &RemoteSsh, remote_herdr: &RemoteHerdr) -> io::Result<()> {
     let deadline = Instant::now() + REMOTE_SERVER_SHUTDOWN_CONFIRM_TIMEOUT;
     loop {
-        if remote_server_status(ssh, remote_herdr, false)? == RemoteServerStatus::NotRunning {
+        if remote_server_status(ssh, remote_herdr, false, false)? == RemoteServerStatus::NotRunning
+        {
             return Ok(());
         }
         if Instant::now() >= deadline {
@@ -1500,7 +2199,7 @@ fn version_label(version: Option<&str>) -> &str {
 }
 
 fn warn_if_remote_bin_not_on_path(ssh: &RemoteSsh) -> io::Result<()> {
-    let output = ssh.user_shell_output("command -v herdr")?;
+    let output = ssh.posix_user_shell_output("command -v herdr")?;
     if output.status.success()
         && remote_shell_resolves_managed_install(&String::from_utf8_lossy(&output.stdout))
     {
@@ -1699,7 +2398,7 @@ fn confirm_remote_install(
         return Err(io::Error::other(format!(
             "matching remote herdr {} is not installed at {}; run from an interactive terminal to approve installation",
             current_version(),
-            remote_herdr.shell_path
+            remote_herdr.executable.display()
         )));
     }
 
@@ -1710,7 +2409,8 @@ fn confirm_remote_install(
     );
     eprint!(
         "Install {} to {}? [Y/n] ",
-        source_description, remote_herdr.shell_path
+        source_description,
+        remote_herdr.executable.display()
     );
     io::stderr().flush()?;
 
@@ -1724,30 +2424,13 @@ fn confirm_remote_install(
     Ok(())
 }
 
-fn remote_session_command(remote_herdr: &RemoteHerdr, session_name: &str, args: &str) -> String {
-    let mut command = remote_herdr.shell_path.clone();
-    if session_name != crate::session::DEFAULT_SESSION_NAME {
-        command.push_str(" --session ");
-        command.push_str(&shell_quote(session_name));
-    }
-    command.push(' ');
-    command.push_str(args);
-    command
-}
-
-fn remote_bridge_command(remote_herdr: &RemoteHerdr, session_name: &str) -> String {
-    format!(
-        "exec {}",
-        remote_session_command(remote_herdr, session_name, "remote-client-bridge")
-    )
-}
-
 fn reattach_command(
     program: &str,
     target: &str,
     session_name: &str,
     keybindings: RemoteKeybindings,
     live_handoff: bool,
+    windows_desktop: bool,
 ) -> String {
     let program = crate::platform::remote_reattach_program(program);
     let target = crate::platform::remote_reattach_argument(target);
@@ -1759,6 +2442,9 @@ fn reattach_command(
     if live_handoff {
         command.push_str(" --handoff");
     }
+    if windows_desktop {
+        command.push_str(" --remote-desktop");
+    }
     if session_name != crate::session::DEFAULT_SESSION_NAME {
         command.push_str(" --session ");
         command.push_str(&crate::platform::remote_reattach_argument(session_name));
@@ -1791,6 +2477,7 @@ impl SshStdioBridge {
         session_name: String,
         ssh_options: Option<&ManagedSshOptions>,
         noninteractive: bool,
+        require_desktop: bool,
     ) -> io::Result<Self> {
         crate::ipc::prepare_socket_path(&local_socket, |path| {
             format!("remote bridge is already listening at {}", path.display())
@@ -1832,6 +2519,7 @@ impl SshStdioBridge {
                             &session_name,
                             thread_ssh_options.as_ref(),
                             noninteractive,
+                            require_desktop,
                             &thread_stop,
                         ) {
                             if noninteractive {
@@ -1942,12 +2630,13 @@ fn write_managed_ssh_config() -> io::Result<ManagedSshConfig> {
 }
 
 fn bridge_connection(
-    stream: crate::ipc::LocalStream,
+    mut stream: crate::ipc::LocalStream,
     target: &str,
     remote_herdr: &RemoteHerdr,
     session_name: &str,
     ssh_options: Option<&ManagedSshOptions>,
     noninteractive: bool,
+    require_desktop: bool,
     bridge_stop: &Arc<AtomicBool>,
 ) -> io::Result<()> {
     let mut command = Command::new("ssh");
@@ -1958,7 +2647,11 @@ fn bridge_connection(
     command
         .arg("-T")
         .arg(target)
-        .arg(remote_bridge_command(remote_herdr, session_name))
+        .arg(
+            remote_herdr
+                .executable
+                .bridge_command(session_name, require_desktop),
+        )
         .stdin(Stdio::piped())
         .stdout(Stdio::piped())
         .stderr(if noninteractive {
@@ -1974,7 +2667,7 @@ fn bridge_connection(
         Some(stdin) => stdin,
         None => return terminate_bridge_child(child, "ssh bridge stdin missing"),
     };
-    let mut child_stdout = match child.stdout.take() {
+    let child_stdout = match child.stdout.take() {
         Some(stdout) => stdout,
         None => return terminate_bridge_child(child, "ssh bridge stdout missing"),
     };
@@ -1986,7 +2679,7 @@ fn bridge_connection(
             return Err(err);
         }
     };
-    if let Err(err) = stream.set_nonblocking(true) {
+    if let Err(err) = crate::ipc::set_local_stream_polling(&mut stream, true) {
         let _ = child.kill();
         let _ = child.wait();
         return Err(err);
@@ -2018,12 +2711,15 @@ fn bridge_connection(
     let download_done_worker = Arc::clone(&download_done);
     let download_upload_stop = Arc::clone(&upload_stop);
     let download = thread::spawn(move || {
-        let result = copy_reader_to_local_stream(
-            &mut child_stdout,
-            &mut child_to_stream,
-            &download_stop,
-            &download_bridge_stop,
-        );
+        let mut child_stdout = io::BufReader::new(child_stdout);
+        let result = discard_remote_output_preamble(&mut child_stdout).and_then(|()| {
+            copy_reader_to_local_stream(
+                &mut child_stdout,
+                &mut child_to_stream,
+                &download_stop,
+                &download_bridge_stop,
+            )
+        });
         download_done_worker.store(true, Ordering::Release);
         download_upload_stop.store(true, Ordering::Release);
         result
@@ -2098,6 +2794,49 @@ fn bridge_connection(
     }
 }
 
+fn discard_remote_output_preamble(reader: &mut impl io::BufRead) -> io::Result<()> {
+    let marker = REMOTE_OUTPUT_READY_MARKER.as_bytes();
+    let mut matched = 0;
+    let mut matching = true;
+    loop {
+        let (consumed, ready) = {
+            let buffer = reader.fill_buf()?;
+            if buffer.is_empty() {
+                if matching && matched == marker.len() {
+                    return Ok(());
+                }
+                return Err(io::Error::new(
+                    io::ErrorKind::UnexpectedEof,
+                    "remote command exited before producing its output marker",
+                ));
+            }
+
+            let mut consumed = 0;
+            let mut ready = false;
+            for &byte in buffer {
+                consumed += 1;
+                if byte == b'\n' {
+                    if matching && matched == marker.len() {
+                        ready = true;
+                        break;
+                    }
+                    matched = 0;
+                    matching = true;
+                } else if matching && matched < marker.len() && byte == marker[matched] {
+                    matched += 1;
+                } else if matching && (matched != marker.len() || byte != b'\r') {
+                    matching = false;
+                }
+            }
+            (consumed, ready)
+        };
+        reader.consume(consumed);
+        if ready {
+            return Ok(());
+        }
+    }
+}
+
 fn terminate_bridge_child(mut child: std::process::Child, message: &'static str) -> io::Result<()> {
     let _ = child.kill();
     let _ = child.wait();
@@ -2246,6 +2985,20 @@ fn sanitize_path_component(input: &str) -> String {
 mod tests {
     use super::*;
 
+    fn decode_windows_command(command: &str) -> String {
+        let encoded = command
+            .strip_prefix("powershell.exe -NoLogo -NoProfile -NonInteractive -EncodedCommand ")
+            .expect("encoded PowerShell command");
+        let bytes = base64::engine::general_purpose::STANDARD
+            .decode(encoded)
+            .expect("base64");
+        let utf16 = bytes
+            .chunks_exact(2)
+            .map(|pair| u16::from_le_bytes([pair[0], pair[1]]))
+            .collect::<Vec<_>>();
+        String::from_utf16(&utf16).expect("UTF-16LE")
+    }
+
     #[cfg(unix)]
     #[test]
     fn bridge_socket_is_user_only() {
@@ -2266,6 +3019,7 @@ mod tests {
             "default".to_string(),
             None,
             false,
+            false,
         )
         .expect("start bridge listener");
 
@@ -2312,6 +3066,67 @@ mod tests {
         let _ = std::fs::remove_file(socket);
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn bridge_stream_delivers_large_frame_before_delayed_reply() {
+        use std::io::Read as _;
+        use std::sync::mpsc;
+        use std::time::{SystemTime, UNIX_EPOCH};
+
+        fn read_frame(stream: &mut crate::ipc::LocalStream) -> Vec<u8> {
+            let mut length = [0; 4];
+            stream.read_exact(&mut length).expect("read frame length");
+            let length = usize::try_from(u32::from_le_bytes(length)).expect("frame length fits");
+            let mut body = vec![0; length];
+            stream.read_exact(&mut body).expect("read frame body");
+            body
+        }
+
+        fn write_frame(stream: &mut crate::ipc::LocalStream, body: &[u8]) {
+            let length = u32::try_from(body.len()).expect("frame length fits");
+            stream
+                .write_all(&length.to_le_bytes())
+                .expect("write frame length");
+            stream.write_all(body).expect("write frame body");
+        }
+
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system clock after epoch")
+            .as_nanos();
+        let socket = std::env::temp_dir().join(format!(
+            "herdr-bridge-large-frame-{}-{nonce}.sock",
+            std::process::id()
+        ));
+        let listener = crate::ipc::bind_private_local_listener(&socket).expect("bind listener");
+        let (large_received_tx, large_received_rx) = mpsc::channel();
+        let client_socket = socket.clone();
+        let client = thread::spawn(move || {
+            let mut stream =
+                crate::ipc::connect_local_stream(&client_socket).expect("connect client");
+            assert_eq!(read_frame(&mut stream), b"welcome");
+            assert_eq!(read_frame(&mut stream), vec![b'x'; 16 * 1024]);
+            large_received_tx.send(()).expect("signal large frame");
+            assert_eq!(read_frame(&mut stream), b"pong");
+        });
+        let mut server = prepare_remote_bridge_stream(listener.accept().expect("accept client"))
+            .expect("prepare bridge stream");
+
+        crate::ipc::set_local_stream_polling(&mut server, true)
+            .expect("enable bridge read polling");
+        write_frame(&mut server, b"welcome");
+        write_frame(&mut server, &vec![b'x'; 16 * 1024]);
+        large_received_rx
+            .recv_timeout(Duration::from_secs(2))
+            .expect("client received large frame");
+        write_frame(&mut server, b"pong");
+
+        client.join().expect("client thread");
+        drop(server);
+        drop(listener);
+        let _ = std::fs::remove_file(socket);
+    }
+
     #[test]
     fn bridge_drop_while_waiting_for_client_is_bounded() {
         let socket = local_forward_socket_path("drop-test", "default");
@@ -2326,6 +3141,7 @@ mod tests {
             "default".to_string(),
             None,
             false,
+            false,
         )
         .expect("start bridge listener");
         let started = Instant::now();
@@ -2412,7 +3228,8 @@ mod tests {
     #[cfg(unix)]
     #[test]
     fn remote_ssh_command_uses_managed_config_when_present() {
-        let managed_config = write_managed_ssh_config().expect("write managed config");
+        let mut managed_config = write_managed_ssh_config().expect("write managed config");
+        managed_config.options.control_path = Some(PathBuf::from("/tmp/herdr test/control"));
         let config_path = managed_config.options.config_path.clone();
         let control_path = managed_config
             .options
@@ -2447,6 +3264,25 @@ mod tests {
                 "example".to_string(),
             ]
         );
+
+        let scp_args = ssh
+            .scp_command()
+            .get_args()
+            .map(|arg| arg.to_string_lossy().into_owned())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            scp_args,
+            vec![
+                "-F".to_string(),
+                config_path.to_string_lossy().into_owned(),
+                "-o".to_string(),
+                format!("ControlPath=\"{}\"", control_path.to_string_lossy()),
+                "-o".to_string(),
+                "ControlMaster=auto".to_string(),
+                "-o".to_string(),
+                "ControlPersist=yes".to_string(),
+            ]
+        );
     }
 
     #[cfg(windows)]
@@ -2479,6 +3315,15 @@ mod tests {
                 "example".to_string(),
             ]
         );
+        let scp_args = ssh
+            .scp_command()
+            .get_args()
+            .map(|arg| arg.to_string_lossy().into_owned())
+            .collect::<Vec<_>>();
+        assert_eq!(
+            scp_args,
+            vec!["-F".to_string(), config_path.to_string_lossy().into_owned(),]
+        );
     }
 
     #[cfg(windows)]
@@ -2535,6 +3380,10 @@ mod tests {
 
     #[test]
     fn saved_machine_compatibility_uses_capabilities_not_release_or_private_protocol() {
+        let linux = RemotePlatform {
+            os: "linux",
+            arch: "x86_64",
+        };
         let mut status = RemoteClientStatusJson {
             version: Some("0.1.0".into()),
             protocol: Some(1),
@@ -2546,42 +3395,47 @@ mod tests {
                 crate::protocol::endpoint::PRESENTATION_EFFECTS_FENCE_CAPABILITY.into(),
                 crate::protocol::endpoint::HEALTH_CHECK_CAPABILITY.into(),
             ],
+            remote_host_bridge: false,
+            remote_desktop_host: false,
         };
-        assert!(status.supports_endpoint_requirement(true));
+        assert!(status.supports_endpoint_requirement(&linux, true, false));
         for index in 0..status.endpoint_capabilities.len() {
             let removed = status.endpoint_capabilities.remove(index);
-            assert!(!status.supports_endpoint_requirement(true));
-            assert!(status.supports_endpoint_requirement(false));
+            assert!(!status.supports_endpoint_requirement(&linux, true, false));
+            assert!(status.supports_endpoint_requirement(&linux, false, false));
             status.endpoint_capabilities.insert(index, removed);
         }
         status.endpoint_protocol_generation = None;
-        assert!(!status.supports_endpoint_requirement(true));
+        assert!(!status.supports_endpoint_requirement(&linux, true, false));
     }
 
     #[test]
     fn saved_machine_server_commands_are_scoped_to_the_explicit_session() {
         let herdr =
             RemoteHerdr::for_platform(RemotePlatform::from_uname("Linux", "x86_64").unwrap());
-        for command in [
-            "status server --json",
-            "server stop",
-            "remote-client-bridge",
+        for (args, command) in [
+            (&["status", "server", "--json"][..], "status server --json"),
+            (&["server", "stop"][..], "server stop"),
+            (&["remote-client-bridge"][..], "remote-client-bridge"),
         ] {
             assert_eq!(
-                remote_session_command(&herdr, "agents", command),
-                format!("{} --session agents {command}", herdr.shell_path)
+                herdr.executable.session_command("agents", args),
+                format!("{} --session agents {command}", herdr.executable.display())
             );
             assert_eq!(
-                remote_session_command(&herdr, crate::session::DEFAULT_SESSION_NAME, command),
-                format!("{} {command}", herdr.shell_path)
+                herdr
+                    .executable
+                    .session_command(crate::session::DEFAULT_SESSION_NAME, args),
+                format!("{} {command}", herdr.executable.display())
             );
         }
-        assert!(
-            remote_live_handoff_command(&herdr, "agents", 19, "0.7.9").starts_with(&format!(
+        assert!(herdr
+            .executable
+            .live_handoff_command("agents", 19, "0.7.9")
+            .starts_with(&format!(
                 "{} --session agents server live-handoff",
-                herdr.shell_path
-            ))
-        );
+                herdr.executable.display()
+            )));
     }
 
     #[test]
@@ -2600,6 +3454,7 @@ mod tests {
             .collect::<Vec<_>>();
 
         assert_eq!(args, vec!["-T".to_string(), "example".to_string()]);
+        assert!(ssh.scp_command().get_args().next().is_none());
     }
 
     #[test]
@@ -2704,6 +3559,47 @@ mod tests {
         assert!(remote.live_handoff);
     }
 
+    #[test]
+    fn extract_remote_args_preserves_desktop_intent_for_direct_and_machine_add() {
+        let direct = vec![
+            "herdr".into(),
+            "--remote=dev".into(),
+            "--remote-desktop".into(),
+        ];
+        let (cleaned, remote) = extract_remote_args(&direct).unwrap();
+        assert_eq!(cleaned, vec!["herdr"]);
+        assert!(remote.unwrap().windows_desktop);
+
+        let machine = vec![
+            "herdr".into(),
+            "machine".into(),
+            "add".into(),
+            "dev".into(),
+            "--remote-desktop".into(),
+        ];
+        let (cleaned, remote) = extract_remote_args(&machine).unwrap();
+        assert_eq!(cleaned, machine);
+        assert!(remote.is_none());
+    }
+
+    #[test]
+    fn extract_remote_args_rejects_unowned_or_duplicate_desktop_options() {
+        assert_eq!(
+            extract_remote_args(&["herdr".into(), "--remote-desktop".into()]).unwrap_err(),
+            "--remote-desktop requires --remote"
+        );
+        assert_eq!(
+            extract_remote_args(&[
+                "herdr".into(),
+                "--remote=dev".into(),
+                "--remote-desktop".into(),
+                "--remote-desktop".into(),
+            ])
+            .unwrap_err(),
+            "--remote-desktop can only be specified once"
+        );
+    }
+
     #[test]
     fn extract_remote_args_preserves_child_remote_options_after_separator() {
         let args = vec![
@@ -2808,6 +3704,213 @@ mod tests {
         assert!(RemotePlatform::from_uname("FreeBSD", "x86_64").is_none());
     }
 
+    #[test]
+    fn windows_platform_probe_accepts_only_x86_64() {
+        assert_eq!(
+            parse_windows_platform_probe("profile noise\r\nherdr-windows:AMD64\r\n").unwrap(),
+            Some(RemotePlatform {
+                os: "windows",
+                arch: "x86_64",
+            })
+        );
+        assert_eq!(parse_windows_platform_probe("other output").unwrap(), None);
+        assert_eq!(
+            parse_windows_platform_probe("herdr-windows:ARM64").unwrap_err(),
+            "unsupported remote platform: Windows ARM64"
+        );
+    }
+
+    #[test]
+    fn windows_probe_preserves_transport_and_unsupported_unix_failures() {
+        let cases = [
+            (true, Some(0), false, false),
+            (true, Some(0), true, true),
+            (false, Some(255), false, false),
+            (false, None, false, false),
+            (false, Some(1), false, true),
+        ];
+        for (success, exit_code, windows_uname_hint, expected) in cases {
+            assert_eq!(
+                should_try_windows_probe(success, exit_code, windows_uname_hint),
+                expected,
+                "success={success}, exit_code={exit_code:?}, windows_uname_hint={windows_uname_hint}"
+            );
+        }
+
+        for (os, expected) in [
+            ("MINGW64_NT-10.0-26100", true),
+            ("MSYS_NT-10.0", true),
+            ("CYGWIN_NT-10.0", true),
+            ("FreeBSD", false),
+        ] {
+            assert_eq!(looks_like_windows_uname(os), expected, "{os}");
+        }
+    }
+
+    #[test]
+    fn windows_remote_commands_use_one_encoded_powershell_grammar() {
+        let executable = RemoteExecutable::WindowsPath("herdr.exe".to_string());
+        let commands = [
+            (
+                "platform probe",
+                windows_platform_probe_command(),
+                "$arch = if ($env:PROCESSOR_ARCHITEW6432) { $env:PROCESSOR_ARCHITEW6432 } else { $env:PROCESSOR_ARCHITECTURE }; [Console]::Out.WriteLine('herdr-windows:' + $arch); exit 0",
+            ),
+            (
+                "PATH lookup",
+                executable.exists_command(),
+                "if ($null -ne (Get-Command herdr.exe -CommandType Application -ErrorAction SilentlyContinue)) { exit 0 }; exit 1",
+            ),
+            (
+                "client status",
+                executable.status_client_command(),
+                "& herdr.exe status client '--json'; exit $LASTEXITCODE",
+            ),
+            (
+                "named server status",
+                executable.session_command("agents", &["status", "server", "--json"]),
+                "& herdr.exe '--session' agents status server '--json'; exit $LASTEXITCODE",
+            ),
+            (
+                "server stop",
+                executable.session_command("agents", &["server", "stop"]),
+                "& herdr.exe '--session' agents server stop; exit $LASTEXITCODE",
+            ),
+            (
+                "direct bridge",
+                executable.bridge_command("agents", false),
+                "$process = Start-Process -FilePath herdr.exe -ArgumentList '--session agents remote-client-bridge' -NoNewWindow -Wait -PassThru -ErrorAction Stop; exit $process.ExitCode",
+            ),
+            (
+                "saved bridge with closed stdin",
+                executable.saved_bridge_command("agents", false),
+                "$process = Start-Process -FilePath herdr.exe -ArgumentList '--session agents remote-client-bridge' -NoNewWindow -Wait -PassThru -ErrorAction Stop; exit $process.ExitCode",
+            ),
+        ];
+
+        let preamble = format!(
+            "[Console]::Out.WriteLine(); [Console]::Out.WriteLine('{REMOTE_OUTPUT_READY_MARKER}'); [Console]::Out.Flush(); "
+        );
+        for (label, command, expected) in commands {
+            let script = decode_windows_command(&command);
+            let script = script
+                .strip_prefix(&preamble)
+                .unwrap_or_else(|| panic!("{label} lacks shared output marker: {script}"));
+            assert_eq!(script, expected, "{label}");
+        }
+    }
+
+    #[test]
+    fn windows_install_commands_copy_zip_and_return_concrete_path() {
+        assert_eq!(
+            windows_scp_target("ssh://user@example:2222", r"C:\Temp\A+B%20 C\ü\install.ps1"),
+            "scp://user@example:2222/C:/Temp/A%2BB%2520%20C/%C3%BC/install.ps1"
+        );
+        assert_eq!(
+            windows_scp_target("example", r"C:\Temp\A+B%20 C\install.ps1"),
+            "example:C:/Temp/A+B%20 C/install.ps1"
+        );
+        let remote_dir = r"C:\Temp\Herdr O'Brien\测试";
+        assert_eq!(
+            windows_scp_target(
+                "user@example",
+                &format!(r"{remote_dir}\herdr-windows-x86_64.zip")
+            ),
+            "user@example:C:/Temp/Herdr O'Brien/测试/herdr-windows-x86_64.zip"
+        );
+        assert_eq!(
+            windows_scp_target("ssh://user@example:2222", r"C:\Temp\install.ps1"),
+            "scp://user@example:2222/C:/Temp/install.ps1"
+        );
+
+        let command = decode_windows_command(&windows_remote_install_command(
+            remote_dir,
+            "0.9.0-custom.digest",
+            &"a".repeat(64),
+        ));
+        assert!(command.contains("-LocalPackageFormat zip"));
+        assert!(command.contains("-LocalPackageIdentity 0.9.0-custom.digest"));
+        assert!(command.contains(".Target"));
+        assert!(command.contains(WINDOWS_REMOTE_INSTALL_RESULT_MARKER));
+
+        let installed = r"C:\Users\test\测试\.herdr\packages\standalone\releases\0.9.0\herdr.exe";
+        let encoded = base64::engine::general_purpose::STANDARD.encode(installed);
+        assert_eq!(
+            parse_windows_remote_path(
+                &format!("installer chatter\n{WINDOWS_REMOTE_INSTALL_RESULT_MARKER}{encoded}\n"),
+                WINDOWS_REMOTE_INSTALL_RESULT_MARKER
+            )
+            .unwrap(),
+            installed
+        );
+        assert!(parse_windows_remote_path(
+            "installer chatter",
+            WINDOWS_REMOTE_INSTALL_RESULT_MARKER
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn windows_candidate_discovery_prefers_path_then_active_release() {
+        let remote_herdr = RemoteHerdr::for_platform(RemotePlatform {
+            os: "windows",
+            arch: "x86_64",
+        });
+        let path = r"C:\stale\herdr.exe";
+        let active = r"C:\Users\test\.herdr\packages\standalone\releases\current\herdr.exe";
+        let stdout = format!(
+            "{WINDOWS_REMOTE_PATH_MARKER}{}\nnoise\n{WINDOWS_REMOTE_PATH_MARKER}{}\n{WINDOWS_REMOTE_PATH_MARKER}{}\n",
+            base64::engine::general_purpose::STANDARD.encode(path),
+            base64::engine::general_purpose::STANDARD.encode(active),
+            base64::engine::general_purpose::STANDARD.encode(active),
+        );
+        let candidates = windows_remote_binary_candidates(&remote_herdr, &stdout);
+        assert_eq!(candidates.len(), 2);
+        assert_eq!(
+            candidates[0].executable,
+            RemoteExecutable::WindowsPath(path.to_string())
+        );
+        assert_eq!(
+            candidates[1].executable,
+            RemoteExecutable::WindowsPath(active.to_string())
+        );
+
+        let command = decode_windows_command(&windows_remote_binary_candidate_command());
+        assert!(command.contains("Get-Command herdr.exe"));
+        assert!(command.contains("$activeJunction.Target"));
+    }
+
+    #[test]
+    fn remote_output_framing_discards_any_banner_and_preserves_binary() {
+        let payload = [0, 1, 2, 0xff, b'\n'];
+        let mut input = vec![b'x'; 4 * 1024 * 1024];
+        input.extend_from_slice(b"\r\nherdr-remote-output-ready:1\r\n");
+        input.extend_from_slice(&payload);
+        let mut reader = io::BufReader::with_capacity(17, io::Cursor::new(input));
+
+        discard_remote_output_preamble(&mut reader).unwrap();
+        let mut output = Vec::new();
+        io::Read::read_to_end(&mut reader, &mut output).unwrap();
+        assert_eq!(output, payload);
+
+        let mut missing = b"profile output without marker".to_vec();
+        assert!(normalize_remote_stdout(&mut missing, true).is_err());
+        normalize_remote_stdout(&mut missing, false).unwrap();
+        assert_eq!(missing, b"profile output without marker");
+
+        let mut platform = b"profile output\nherdr-remote-output-ready:1\nLinux\nx86_64\n".to_vec();
+        normalize_remote_stdout(&mut platform, true).unwrap();
+        let platform = String::from_utf8(platform).unwrap();
+        let mut lines = platform.lines();
+        assert_eq!(
+            RemotePlatform::from_uname(lines.next().unwrap(), lines.next().unwrap()),
+            Some(RemotePlatform {
+                os: "linux",
+                arch: "x86_64"
+            })
+        );
+    }
+
     #[cfg(unix)]
     #[test]
     fn reattach_command_includes_remote_and_session() {
@@ -2818,6 +3921,7 @@ mod tests {
                 "work",
                 RemoteKeybindings::Local,
                 false,
+                false,
             ),
             "target/release/herdr --remote user@host --session work"
         );
@@ -2828,6 +3932,7 @@ mod tests {
                 crate::session::DEFAULT_SESSION_NAME,
                 RemoteKeybindings::Local,
                 false,
+                false,
             ),
             "herdr --remote 'host name'"
         );
@@ -2838,6 +3943,7 @@ mod tests {
                 crate::session::DEFAULT_SESSION_NAME,
                 RemoteKeybindings::Server,
                 false,
+                false,
             ),
             "herdr --remote host --remote-keybindings server"
         );
@@ -2848,6 +3954,7 @@ mod tests {
                 crate::session::DEFAULT_SESSION_NAME,
                 RemoteKeybindings::Local,
                 true,
+                false,
             ),
             "herdr --remote host --handoff"
         );
@@ -2864,6 +3971,7 @@ mod tests {
                 "work'name",
                 RemoteKeybindings::Local,
                 false,
+                false,
             ),
             format!(
                 "& '{}' --remote 'host''name' --session 'work''name'",
@@ -2879,8 +3987,20 @@ mod tests {
             arch: "x86_64",
         });
         assert_eq!(
-            remote_bridge_command(&remote_herdr, crate::session::DEFAULT_SESSION_NAME),
-            "exec \"$HOME/.local/bin/herdr\" remote-client-bridge"
+            remote_herdr
+                .executable
+                .bridge_command(crate::session::DEFAULT_SESSION_NAME, false),
+            "printf '\n%s\n' 'herdr-remote-output-ready:1'\nexec \"$HOME/.local/bin/herdr\" remote-client-bridge"
+        );
+        assert_eq!(
+            remote_herdr
+                .executable
+                .saved_bridge_command("agents", false),
+            "exec \"$HOME/.local/bin/herdr\" --session agents remote-client-bridge </dev/null"
+        );
+        assert_eq!(
+            remote_herdr.executable.saved_bridge_command("agents", true),
+            "exec \"$HOME/.local/bin/herdr\" --session agents remote-client-bridge --require-desktop </dev/null"
         );
     }
 
@@ -2894,8 +4014,10 @@ mod tests {
             .expect("path binary");
 
         assert_eq!(
-            remote_bridge_command(&remote_herdr, crate::session::DEFAULT_SESSION_NAME),
-            "exec /usr/bin/herdr remote-client-bridge"
+            remote_herdr
+                .executable
+                .bridge_command(crate::session::DEFAULT_SESSION_NAME, false),
+            "printf '\n%s\n' 'herdr-remote-output-ready:1'\nexec /usr/bin/herdr remote-client-bridge"
         );
     }
 
@@ -2910,8 +4032,10 @@ mod tests {
                 .expect("path binary");
 
         assert_eq!(
-            remote_bridge_command(&remote_herdr, crate::session::DEFAULT_SESSION_NAME),
-            "exec '/opt/herdr bin/herdr' remote-client-bridge"
+            remote_herdr
+                .executable
+                .bridge_command(crate::session::DEFAULT_SESSION_NAME, false),
+            "printf '\n%s\n' 'herdr-remote-output-ready:1'\nexec '/opt/herdr bin/herdr' remote-client-bridge"
         );
     }
 
@@ -2926,8 +4050,10 @@ mod tests {
                 .expect("path binary");
 
         assert_eq!(
-            remote_bridge_command(&remote_herdr, crate::session::DEFAULT_SESSION_NAME),
-            "exec /opt/homebrew/bin/herdr remote-client-bridge"
+            remote_herdr
+                .executable
+                .bridge_command(crate::session::DEFAULT_SESSION_NAME, false),
+            "printf '\n%s\n' 'herdr-remote-output-ready:1'\nexec /opt/homebrew/bin/herdr remote-client-bridge"
         );
         assert_eq!(remote_herdr.platform.asset_key(), "macos-aarch64");
     }
@@ -2944,8 +4070,14 @@ mod tests {
         );
 
         assert_eq!(candidates.len(), 2);
-        assert_eq!(candidates[0].shell_path, "/usr/bin/herdr");
-        assert_eq!(candidates[1].shell_path, "'/opt/herdr bin/herdr'");
+        assert_eq!(
+            candidates[0].executable,
+            RemoteExecutable::PosixShellPath("/usr/bin/herdr".to_string())
+        );
+        assert_eq!(
+            candidates[1].executable,
+            RemoteExecutable::PosixShellPath("'/opt/herdr bin/herdr'".to_string())
+        );
     }
 
     #[test]
@@ -2961,8 +4093,10 @@ mod tests {
 
         assert_eq!(candidates.len(), 1);
         assert_eq!(
-            candidates[0].shell_path,
-            "/home/can/.local/share/mise/installs/herdr/0.7.1/bin/herdr"
+            candidates[0].executable,
+            RemoteExecutable::PosixShellPath(
+                "/home/can/.local/share/mise/installs/herdr/0.7.1/bin/herdr".to_string()
+            )
         );
     }
 
@@ -3013,8 +4147,10 @@ mod tests {
                 .expect("path binary");
 
         assert_eq!(
-            remote_bridge_command(&remote_herdr, crate::session::DEFAULT_SESSION_NAME),
-            "exec '/opt/herdr'\\''s/bin/herdr' remote-client-bridge"
+            remote_herdr
+                .executable
+                .bridge_command(crate::session::DEFAULT_SESSION_NAME, false),
+            "printf '\n%s\n' 'herdr-remote-output-ready:1'\nexec '/opt/herdr'\\''s/bin/herdr' remote-client-bridge"
         );
     }
 
@@ -3074,6 +4210,10 @@ mod tests {
 
     #[test]
     fn saved_machine_setup_handoffs_old_server_missing_presentation_fence() {
+        let linux = RemotePlatform {
+            os: "linux",
+            arch: "x86_64",
+        };
         // Captured from Rohan after installing a new binary while the old daemon stayed alive.
         let installed = parse_client_status_json(
             r#"{"version":"0.8.2","protocol":22,"endpoint_protocol_generation":1,"endpoint_capabilities":["surface_interest","presentation_effects_fence","health_check"]}"#,
@@ -3083,8 +4223,8 @@ mod tests {
             r#"{"version":"0.8.2","protocol":22,"endpoint_protocol_generation":1,"endpoint_capabilities":["surface_interest","health_check"]}"#,
         )
         .unwrap();
-        assert!(installed.supports_endpoint_requirement(true));
-        assert!(!running_binary.supports_endpoint_requirement(true));
+        assert!(installed.supports_endpoint_requirement(&linux, true, false));
+        assert!(!running_binary.supports_endpoint_requirement(&linux, true, false));
         for (live_capabilities, expected) in [
             (
                 running_binary.endpoint_capabilities,
@@ -3130,6 +4270,44 @@ mod tests {
         }
     }
 
+    #[test]
+    fn windows_reuse_requires_explicit_remote_host_bridge() {
+        let windows = RemotePlatform {
+            os: "windows",
+            arch: "x86_64",
+        };
+        let linux = RemotePlatform {
+            os: "linux",
+            arch: "x86_64",
+        };
+        let old =
+            parse_client_status_json(r#"{"version":"0.8.2","endpoint_protocol_generation":1}"#)
+                .unwrap();
+        let current = parse_client_status_json(
+            r#"{"version":"0.9.0","endpoint_protocol_generation":1,"remote_host_bridge":true}"#,
+        )
+        .unwrap();
+        let desktop = parse_client_status_json(
+            r#"{"version":"0.9.0","endpoint_protocol_generation":1,"remote_host_bridge":true,"remote_desktop_host":true}"#,
+        )
+        .unwrap();
+
+        assert!(!old.supports_endpoint_requirement(&windows, false, false));
+        assert!(current.supports_endpoint_requirement(&windows, false, false));
+        assert!(!current.supports_endpoint_requirement(&windows, false, true));
+        assert!(desktop.supports_endpoint_requirement(&windows, false, true));
+        assert!(old.supports_endpoint_requirement(&linux, false, false));
+        assert!(!local_binary_can_seed_remote(&windows));
+        assert_eq!(
+            windows_package_identity(true, &"a".repeat(64)),
+            format!("{}-custom.{}", current_version(), "a".repeat(64))
+        );
+        assert_eq!(
+            windows_package_identity(false, "ignored"),
+            current_version()
+        );
+    }
+
     #[test]
     fn parse_remote_server_status_json_reads_running_server() {
         assert_eq!(
@@ -3339,8 +4517,7 @@ mod tests {
             os: "linux",
             arch: "x86_64",
         });
-        let command = remote_live_handoff_command(
-            &remote_herdr,
+        let command = remote_herdr.executable.live_handoff_command(
             crate::session::DEFAULT_SESSION_NAME,
             19,
             "0.7.9",
diff --git a/src/remote/desktop.rs b/src/remote/desktop.rs
new file mode 100644
index 0000000000..f982467c43
--- /dev/null
+++ b/src/remote/desktop.rs
@@ -0,0 +1,203 @@
+use base64::Engine as _;
+use serde::{Deserialize, Serialize};
+use std::{io, path::PathBuf};
+
+const BOOTSTRAP_ARG: &str = "--desktop-bootstrap";
+
+#[derive(Serialize, Deserialize)]
+struct DesktopBootstrap {
+    config_path: Option<String>,
+    xdg_config_home: Option<String>,
+    xdg_state_home: Option<String>,
+    startup_cwd: String,
+}
+
+pub(crate) fn apply_desktop_bootstrap_args(args: &[String]) -> Result<Vec<String>, String> {
+    let (cleaned, bootstrap) = extract_bootstrap_args(args)?;
+    if let Some(bootstrap) = bootstrap {
+        apply_bootstrap(&bootstrap)?;
+    }
+    Ok(cleaned)
+}
+
+fn extract_bootstrap_args(
+    args: &[String],
+) -> Result<(Vec<String>, Option<DesktopBootstrap>), String> {
+    let mut cleaned = Vec::with_capacity(args.len());
+    if let Some(program) = args.first() {
+        cleaned.push(program.clone());
+    }
+
+    let mut bootstrap = None;
+    let mut index = 1;
+    while index < args.len() {
+        if args[index] == "--" {
+            cleaned.extend_from_slice(&args[index..]);
+            break;
+        }
+        if args[index] == BOOTSTRAP_ARG {
+            if bootstrap.is_some() {
+                return Err(format!("{BOOTSTRAP_ARG} can only be specified once"));
+            }
+            let value = args
+                .get(index + 1)
+                .ok_or_else(|| format!("missing value for {BOOTSTRAP_ARG}"))?;
+            bootstrap = Some(decode_bootstrap(value)?);
+            index += 2;
+            continue;
+        }
+        cleaned.push(args[index].clone());
+        index += 1;
+    }
+
+    Ok((cleaned, bootstrap))
+}
+
+pub(crate) fn run_remote_desktop_command(args: &[String]) -> io::Result<()> {
+    match args {
+        [operation] if operation == "inspect" => {
+            #[cfg(windows)]
+            {
+                println!(
+                    "{}",
+                    serde_json::to_string(&crate::platform::inspect_remote_desktop_host()?)
+                        .map_err(io::Error::other)?
+                );
+                Ok(())
+            }
+            #[cfg(not(windows))]
+            Err(io::Error::new(
+                io::ErrorKind::Unsupported,
+                "Windows desktop hosting is unavailable on this platform",
+            ))
+        }
+        [operation, flag, raw_session] if operation == "start" && flag == "--windows-session" => {
+            #[cfg(windows)]
+            {
+                let windows_session = raw_session.parse::<u32>().map_err(|_| {
+                    io::Error::new(
+                        io::ErrorKind::InvalidInput,
+                        "--windows-session must be an unsigned integer",
+                    )
+                })?;
+                crate::platform::start_remote_desktop_server(windows_session, &capture_bootstrap()?)
+            }
+            #[cfg(not(windows))]
+            {
+                let _ = raw_session;
+                Err(io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "Windows desktop hosting is unavailable on this platform",
+                ))
+            }
+        }
+        _ => Err(io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "usage: herdr remote-desktop <inspect|start --windows-session <id>>",
+        )),
+    }
+}
+
+#[cfg(windows)]
+fn capture_bootstrap() -> io::Result<String> {
+    let bootstrap = DesktopBootstrap {
+        config_path: unicode_env(crate::config::CONFIG_PATH_ENV_VAR)?,
+        xdg_config_home: unicode_env("XDG_CONFIG_HOME")?,
+        xdg_state_home: unicode_env("XDG_STATE_HOME")?,
+        startup_cwd: std::env::current_dir()?
+            .into_os_string()
+            .into_string()
+            .map_err(|_| io::Error::other("SSH working directory is not valid Unicode"))?,
+    };
+    let bytes = serde_json::to_vec(&bootstrap).map_err(io::Error::other)?;
+    Ok(base64::engine::general_purpose::URL_SAFE_NO_PAD.encode(bytes))
+}
+
+#[cfg(windows)]
+fn unicode_env(name: &str) -> io::Result<Option<String>> {
+    std::env::var_os(name)
+        .map(|value| {
+            value.into_string().map_err(|_| {
+                io::Error::new(
+                    io::ErrorKind::InvalidData,
+                    format!("{name} is not valid Unicode"),
+                )
+            })
+        })
+        .transpose()
+}
+
+fn decode_bootstrap(value: &str) -> Result<DesktopBootstrap, String> {
+    let bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
+        .decode(value)
+        .map_err(|error| format!("invalid {BOOTSTRAP_ARG}: {error}"))?;
+    serde_json::from_slice(&bytes).map_err(|error| format!("invalid {BOOTSTRAP_ARG}: {error}"))
+}
+
+fn apply_bootstrap(bootstrap: &DesktopBootstrap) -> Result<(), String> {
+    crate::platform::detach_remote_desktop_console()
+        .map_err(|error| format!("failed to detach the Windows desktop server console: {error}"))?;
+    apply_env(crate::config::CONFIG_PATH_ENV_VAR, &bootstrap.config_path);
+    apply_env("XDG_CONFIG_HOME", &bootstrap.xdg_config_home);
+    apply_env("XDG_STATE_HOME", &bootstrap.xdg_state_home);
+    std::env::set_var(
+        crate::server::autodetect::STARTUP_CWD_ENV_VAR,
+        &bootstrap.startup_cwd,
+    );
+    std::env::set_current_dir(PathBuf::from(&bootstrap.startup_cwd)).map_err(|error| {
+        format!(
+            "failed to restore desktop server working directory {}: {error}",
+            bootstrap.startup_cwd
+        )
+    })
+}
+
+fn apply_env(name: &str, value: &Option<String>) {
+    match value {
+        Some(value) => std::env::set_var(name, value),
+        None => std::env::remove_var(name),
+    }
+}
+
+#[cfg(windows)]
+pub(crate) fn desktop_server_args(bootstrap: &str) -> Vec<String> {
+    let mut args = vec![BOOTSTRAP_ARG.to_owned(), bootstrap.to_owned()];
+    if let Some(session) = crate::session::active_name() {
+        args.extend(["--session".to_owned(), session]);
+    }
+    args.push("server".to_owned());
+    args
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn bootstrap_arguments_are_removed_before_normal_dispatch() {
+        let bootstrap = DesktopBootstrap {
+            config_path: None,
+            xdg_config_home: None,
+            xdg_state_home: None,
+            startup_cwd: std::env::current_dir()
+                .unwrap()
+                .to_string_lossy()
+                .into_owned(),
+        };
+        let encoded = base64::engine::general_purpose::URL_SAFE_NO_PAD
+            .encode(serde_json::to_vec(&bootstrap).unwrap());
+        let args = vec![
+            "herdr".into(),
+            BOOTSTRAP_ARG.into(),
+            encoded,
+            "--session".into(),
+            "agents".into(),
+            "server".into(),
+        ];
+
+        assert_eq!(
+            extract_bootstrap_args(&args).unwrap().0,
+            vec!["herdr", "--session", "agents", "server"]
+        );
+    }
+}
diff --git a/src/remote/host_unix.rs b/src/remote/host.rs
similarity index 51%
rename from src/remote/host_unix.rs
rename to src/remote/host.rs
index 48b20e0bc3..c41ad60ea4 100644
--- a/src/remote/host_unix.rs
+++ b/src/remote/host.rs
@@ -1,15 +1,13 @@
-//! Unix remote-host side of the SSH stdio bridge.
+//! Remote-host side of the SSH stdio bridge.
 
 use std::io;
-use std::os::unix::net::UnixStream;
-use std::thread;
 use std::time::Duration;
 
-pub(crate) fn run_remote_client_bridge() -> io::Result<()> {
-    ensure_remote_server_running()?;
+pub(crate) fn run_remote_client_bridge(require_desktop: bool) -> io::Result<()> {
+    ensure_remote_server_running(require_desktop)?;
 
     let socket_path = crate::server::socket_paths::client_socket_path();
-    let stream = UnixStream::connect(&socket_path).map_err(|err| {
+    let stream = crate::ipc::connect_local_stream(&socket_path).map_err(|err| {
         io::Error::new(
             err.kind(),
             format!(
@@ -18,37 +16,14 @@ pub(crate) fn run_remote_client_bridge() -> io::Result<()> {
             ),
         )
     })?;
-
-    let mut stdout = io::stdout().lock();
-    let mut socket_to_stdout = stream.try_clone()?;
-    let mut stdin_to_socket = stream;
-
-    let _upload = thread::spawn(move || {
-        let mut stdin = io::stdin();
-        let _ = copy_flush(&mut stdin, &mut stdin_to_socket);
-        let _ = stdin_to_socket.shutdown(std::net::Shutdown::Write);
-    });
-
-    copy_flush(&mut socket_to_stdout, &mut stdout).map(|_| ())
-}
-
-fn copy_flush<R: io::Read, W: io::Write>(reader: &mut R, writer: &mut W) -> io::Result<u64> {
-    let mut buffer = [0_u8; 16 * 1024];
-    let mut total = 0;
-    loop {
-        let read = match reader.read(&mut buffer) {
-            Ok(0) => return Ok(total),
-            Ok(read) => read,
-            Err(err) if err.kind() == io::ErrorKind::Interrupted => continue,
-            Err(err) => return Err(err),
-        };
-        writer.write_all(&buffer[..read])?;
-        writer.flush()?;
-        total += read as u64;
+    if require_desktop {
+        crate::platform::verify_remote_desktop_stream(&stream)?;
     }
+
+    crate::platform::forward_remote_bridge_stdio(stream)
 }
 
-fn ensure_remote_server_running() -> io::Result<()> {
+fn ensure_remote_server_running(require_desktop: bool) -> io::Result<()> {
     let socket_path = crate::server::socket_paths::client_socket_path();
     if crate::server::autodetect::is_server_listening() {
         let status = crate::api::read_runtime_status_at(
@@ -69,6 +44,12 @@ fn ensure_remote_server_running() -> io::Result<()> {
         ));
     }
 
+    if require_desktop {
+        return Err(io::Error::new(
+            io::ErrorKind::NotFound,
+            "the Windows desktop Herdr server is not running; run the interactive remote command to prepare it",
+        ));
+    }
     crate::server::autodetect::spawn_server_daemon()?;
     crate::server::autodetect::wait_for_server_socket(&socket_path, Duration::from_secs(5))
 }
diff --git a/src/remote/saved.rs b/src/remote/saved.rs
index 5b570af4b1..c0a83059e1 100644
--- a/src/remote/saved.rs
+++ b/src/remote/saved.rs
@@ -16,12 +16,13 @@ pub(crate) fn connect_saved_ssh(
     profile_id: &str,
     target: &str,
     session: &str,
+    windows_desktop: bool,
 ) -> io::Result<SavedSshStream> {
     validate_profile_path_id(profile_id)?;
     crate::session::validate_name(session)
         .map_err(|error| io::Error::new(io::ErrorKind::InvalidInput, error))?;
     let ssh = RemoteSsh::new_noninteractive(target.to_owned());
-    let remote_herdr = find_installed_remote_herdr(&ssh)?;
+    let remote_herdr = find_installed_remote_herdr(&ssh, windows_desktop)?;
     let path = saved_bridge_path(profile_id);
     let bridge = SshStdioBridge::start(
         target.to_owned(),
@@ -30,6 +31,7 @@ pub(crate) fn connect_saved_ssh(
         session.to_owned(),
         ssh.options(),
         true,
+        windows_desktop,
     )?;
     let stream = crate::ipc::connect_local_stream(&path)?;
     Ok(SavedSshStream {
@@ -38,11 +40,20 @@ pub(crate) fn connect_saved_ssh(
     })
 }
 
-pub(crate) fn saved_ssh_bootstrap_command(target: &str, session: &str) -> String {
+pub(crate) fn saved_ssh_bootstrap_command(
+    target: &str,
+    session: &str,
+    windows_desktop: bool,
+) -> String {
     format!(
-        "herdr --remote {} --session {}",
+        "herdr --remote {} --session {}{}",
         super::shell_quote(target),
-        super::shell_quote(session)
+        super::shell_quote(session),
+        if windows_desktop {
+            " --remote-desktop"
+        } else {
+            ""
+        }
     )
 }
 
@@ -111,9 +122,13 @@ mod tests {
     #[test]
     fn bootstrap_command_preserves_the_explicit_remote_session() {
         assert_eq!(
-            saved_ssh_bootstrap_command("build host", "agent work"),
+            saved_ssh_bootstrap_command("build host", "agent work", false),
             "herdr --remote 'build host' --session 'agent work'"
         );
+        assert_eq!(
+            saved_ssh_bootstrap_command("build", "agents", true),
+            "herdr --remote build --session agents --remote-desktop"
+        );
     }
 
     #[test]
diff --git a/src/server/headless/tests/surface_interest.rs b/src/server/headless/tests/surface_interest.rs
index 591f6a8f1c..e0fa7beb53 100644
--- a/src/server/headless/tests/surface_interest.rs
+++ b/src/server/headless/tests/surface_interest.rs
@@ -414,6 +414,7 @@ async fn two_headless_servers_drive_atomic_endpoint_handoff() {
         target: "dev@example.com".into(),
         session: "main".into(),
         enabled: true,
+        windows_desktop: false,
     };
     let target_id = ClientEndpointId::Ssh(profile.id.clone());
     let mut shell = crate::client::ClientShellState::new(
diff --git a/src/update.rs b/src/update.rs
index f836fb80b3..4c128c5782 100644
--- a/src/update.rs
+++ b/src/update.rs
@@ -698,8 +698,7 @@ fn install_downloaded_update(mut update: DownloadedUpdate) -> Result<(), String>
     Ok(())
 }
 
-#[cfg(windows)]
-const WINDOWS_INSTALLER: &str = include_str!("../distribution/install.ps1");
+pub(crate) const WINDOWS_INSTALLER: &str = include_str!("../distribution/install.ps1");
 
 #[cfg(windows)]
 struct DownloadedWindowsUpdate {
diff --git a/tests/cli/sessions.rs b/tests/cli/sessions.rs
index 8e5fc48f66..e8f405561e 100644
--- a/tests/cli/sessions.rs
+++ b/tests/cli/sessions.rs
@@ -458,6 +458,7 @@ fn status_commands_report_client_and_server_versions() {
     assert_eq!(full_json["client"]["version"], env!("CARGO_PKG_VERSION"));
     assert_eq!(full_json["client"]["protocol"], 22);
     assert_eq!(full_json["client"]["endpoint_protocol_generation"], 1);
+    assert_eq!(full_json["client"]["remote_host_bridge"], true);
     assert_eq!(full_json["server"]["status"], "running");
     assert_eq!(full_json["server"]["running"], true);
     assert_eq!(full_json["server"]["compatible"], true);
@@ -482,6 +483,7 @@ fn status_commands_report_client_and_server_versions() {
     assert_eq!(client_json["version"], env!("CARGO_PKG_VERSION"));
     assert_eq!(client_json["protocol"], 22);
     assert_eq!(client_json["endpoint_protocol_generation"], 1);
+    assert_eq!(client_json["remote_host_bridge"], true);
     assert!(client_json["binary"]
         .as_str()
         .is_some_and(|path| !path.is_empty()));
diff --git a/tests/machine_setup.rs b/tests/machine_setup.rs
index 752126fce1..d7c4902713 100644
--- a/tests/machine_setup.rs
+++ b/tests/machine_setup.rs
@@ -19,7 +19,11 @@ fi
 case "$last" in
     'tee '*) cat >/dev/null; exit 0 ;;
 esac
-script=$(cat)
+case "$last" in
+    *'herdr-remote-output-ready:1'*) script=$last ;;
+    *) script=$(cat) ;;
+esac
+printf '\n%s\n' 'herdr-remote-output-ready:1'
 case "$script" in
     *'uname -s'*) uname -s; uname -m ;;
     *'version='*) echo /home/remote/.local/bin/herdr ;;