From 4bc6321aff16c6cdd1638831e80221cf6aada2d7 Mon Sep 17 00:00:00 2001
From: Looped <nonlooped@gmail.com>
Date: Wed, 2 Sep 2026 01:43:57 +0300
Subject: [PATCH 1/6] Add Windows desktop support

- run agent CLIs and terminals with Windows-native process handling\n- normalize Windows paths and add Acrylic window styling\n- build, test, and publish an NSIS installer\n\nCloses #18
---
 .github/ISSUE_TEMPLATE/bug_report.yml |  19 ++-
 .github/workflows/ci.yml              |   2 +-
 .github/workflows/release.yml         |  40 ++++-
 CHANGELOG.md                          |   4 +
 CONTRIBUTING.md                       |   2 +-
 Cargo.lock                            | 101 +++++++++++-
 README.md                             |  16 +-
 index.html                            |   1 +
 package.json                          |   3 +-
 src-tauri/Cargo.toml                  |   3 +
 src-tauri/build.rs                    |   7 +
 src-tauri/icons/installer-sidebar.bmp | Bin 0 -> 154542 bytes
 src-tauri/src/checkpoint.rs           |   7 +-
 src-tauri/src/fs.rs                   |  71 ++++----
 src-tauri/src/harness.rs              | 227 +++++++++++++++++++-------
 src-tauri/src/lib.rs                  |  49 ++++--
 src-tauri/src/pty.rs                  | 219 ++++++++++++++++++-------
 src-tauri/src/search.rs               |   3 +-
 src-tauri/src/skills.rs               |   2 +-
 src-tauri/src/window.rs               |  11 +-
 src-tauri/tauri.windows.conf.json     |  34 ++++
 src/App.tsx                           |   4 +-
 src/chrome/FileTree.tsx               |   4 +-
 src/chrome/FileTypeIcon.tsx           |  23 +--
 src/chrome/ProjectRail.tsx            |   4 +-
 src/index.css                         |  10 +-
 src/lib/appearance.ts                 |   3 +-
 src/lib/fileIndex.ts                  |   4 +-
 src/lib/fs.ts                         |  22 ++-
 src/lib/paths.test.ts                 |  63 +++++++
 src/lib/paths.ts                      |  73 +++++++--
 src/lib/platform.ts                   |   6 +
 src/lib/recents.test.ts               |  37 ++---
 src/lib/recents.ts                    |  68 ++++----
 src/lib/search.ts                     |   3 +-
 src/surfaces/TerminalView.tsx         |  44 +++--
 36 files changed, 891 insertions(+), 298 deletions(-)
 create mode 100644 src-tauri/icons/installer-sidebar.bmp
 create mode 100644 src-tauri/tauri.windows.conf.json
 create mode 100644 src/lib/paths.test.ts

diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index a49ea143..d4cd37c2 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -5,7 +5,7 @@ body:
   - type: markdown
     attributes:
       value: |
-        MonoCode is macOS (Apple Silicon) only. Linux and Windows are out of scope.
+        MonoCode supports macOS, Linux, and Windows.
 
   - type: input
     id: version
@@ -15,11 +15,22 @@ body:
     validations:
       required: true
 
+  - type: dropdown
+    id: os
+    attributes:
+      label: Operating system
+      options:
+        - macOS
+        - Linux
+        - Windows
+    validations:
+      required: true
+
   - type: input
-    id: macos
+    id: os-version
     attributes:
-      label: macOS version
-      placeholder: "15.5"
+      label: OS version
+      placeholder: "Windows 11, Ubuntu 24.04, macOS 15.5"
     validations:
       required: true
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 752b3033..b95ba6e9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -9,7 +9,7 @@ jobs:
   check:
     strategy:
       matrix:
-        os: [macos-latest, ubuntu-latest]
+        os: [macos-latest, ubuntu-latest, windows-latest]
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 766e983f..1f9566d5 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -10,7 +10,7 @@ permissions:
 
 jobs:
   release:
-    needs: linux
+    needs: [linux, windows]
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v4
@@ -168,6 +168,12 @@ jobs:
           name: linux-packages
           path: target/release/bundle/linux
 
+      - name: Download Windows packages
+        uses: actions/download-artifact@v4
+        with:
+          name: windows-packages
+          path: target/release/bundle/nsis
+
       - name: GitHub Release
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -181,14 +187,15 @@ jobs:
           shopt -s nullglob
           DEB=("$BUNDLE"/linux/*.deb)
           APPIMAGE=("$BUNDLE"/linux/*.AppImage)
-          if (( ${#DEB[@]} != 1 || ${#APPIMAGE[@]} != 1 )); then
-            echo "Expected exactly one .deb and one AppImage" >&2
+          NSIS=("$BUNDLE"/nsis/*.exe)
+          if (( ${#DEB[@]} != 1 || ${#APPIMAGE[@]} != 1 || ${#NSIS[@]} != 1 )); then
+            echo "Expected exactly one .deb, one AppImage, and one NSIS installer" >&2
             exit 1
           fi
           gh release create "$GITHUB_REF_NAME" \
             --title "MonoCode $VERSION" \
             --notes "See CHANGELOG.md for details." \
-            "$DMG" "$TAR" "$SIG" "${DEB[0]}" "${APPIMAGE[0]}"
+            "$DMG" "$TAR" "$SIG" "${DEB[0]}" "${APPIMAGE[0]}" "${NSIS[0]}"
 
   linux:
     name: Linux packages
@@ -230,3 +237,28 @@ jobs:
           name: linux-packages
           path: release-artifacts/
           if-no-files-found: error
+
+  windows:
+    name: Windows packages
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+
+      - uses: dtolnay/rust-toolchain@stable
+
+      - run: npm ci
+
+      - name: Build Windows packages
+        run: npm run build:windows
+
+      - name: Upload Windows packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: windows-packages
+          path: target/release/bundle/nsis/*.exe
+          if-no-files-found: error
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3e19b987..754a1130 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+
+- Windows is a supported desktop target. Terminals, agent CLIs, and the rest of the macOS/Linux feature set run there, and the window uses Tauri Acrylic in place of macOS vibrancy.
+
 ## [0.1.28] - 2026-09-01
 
 ### Added
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index deb4c4a6..acafbb0b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -15,7 +15,7 @@ You need Node.js 20+, a current stable Rust toolchain, and at least one provider
 - [omp](https://omp.sh) - `curl -fsSL https://omp.sh/install | sh`
 - [fx](https://fx.sh) - `curl -fsSL https://fx.sh/setup.sh | bash` then `fx login`
 
-macOS and Linux are supported targets. On Debian/Ubuntu, `npm run setup:linux:deb` installs the native Tauri build dependencies.
+macOS, Linux, and Windows are supported targets. On Debian/Ubuntu, `npm run setup:linux:deb` installs the native Tauri build dependencies.
 
 ```bash
 npm install
diff --git a/Cargo.lock b/Cargo.lock
index 7790a1a9..402e17f9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -462,6 +462,12 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "cfg_aliases"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd16c4719339c4530435d38e511904438d07cce7950afa3718a84ac36c10e89e"
+
 [[package]]
 name = "chrono"
 version = "0.4.45"
@@ -834,6 +840,12 @@ dependencies = [
  "tendril",
 ]
 
+[[package]]
+name = "downcast-rs"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b325c5dbd37f80359721ad39aca5a29fb04c89279657cffdda8736d0c0b9d2"
+
 [[package]]
 name = "dpi"
 version = "0.1.2"
@@ -896,7 +908,7 @@ dependencies = [
  "rustc_version",
  "toml 1.1.4+spec-1.1.0",
  "vswhom",
- "winreg",
+ "winreg 0.55.0",
 ]
 
 [[package]]
@@ -1016,6 +1028,17 @@ dependencies = [
  "rustc_version",
 ]
 
+[[package]]
+name = "filedescriptor"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e40758ed24c9b2eeb76c35fb0aebc66c626084edd827e07e1552279814c6682d"
+dependencies = [
+ "libc",
+ "thiserror 1.0.69",
+ "winapi",
+]
+
 [[package]]
 name = "filetime"
 version = "0.2.29"
@@ -2014,6 +2037,12 @@ dependencies = [
  "unicode-segmentation",
 ]
 
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
 [[package]]
 name = "libappindicator"
 version = "0.9.0"
@@ -2180,6 +2209,7 @@ dependencies = [
  "objc2-app-kit",
  "objc2-foundation",
  "objc2-user-notifications",
+ "portable-pty",
  "raw-window-handle",
  "rusqlite",
  "serde",
@@ -2245,6 +2275,18 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
+[[package]]
+name = "nix"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab2156c4fce2f8df6c499cc1c763e4394b7482525bf2a9701c9d79d215f519e4"
+dependencies = [
+ "bitflags 2.13.1",
+ "cfg-if",
+ "cfg_aliases",
+ "libc",
+]
+
 [[package]]
 name = "num-conv"
 version = "0.2.2"
@@ -2772,6 +2814,27 @@ dependencies = [
  "portable-atomic",
 ]
 
+[[package]]
+name = "portable-pty"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4a596a2b3d2752d94f51fac2d4a96737b8705dddd311a32b9af47211f08671e"
+dependencies = [
+ "anyhow",
+ "bitflags 1.3.2",
+ "downcast-rs",
+ "filedescriptor",
+ "lazy_static",
+ "libc",
+ "log",
+ "nix",
+ "serial2",
+ "shared_library",
+ "shell-words",
+ "winapi",
+ "winreg 0.10.1",
+]
+
 [[package]]
 name = "potential_utf"
 version = "0.1.5"
@@ -3413,6 +3476,17 @@ dependencies = [
  "syn 2.0.119",
 ]
 
+[[package]]
+name = "serial2"
+version = "0.2.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b16809bc35793b19ce4e0c53924bc0dce3937f15487997cfdaed936004180730"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "serialize-to-javascript"
 version = "0.1.2"
@@ -3455,6 +3529,22 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "shared_library"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11"
+dependencies = [
+ "lazy_static",
+ "libc",
+]
+
+[[package]]
+name = "shell-words"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc6fe69c597f9c37bfeeeeeb33da3530379845f10be461a66d16d03eca2ded77"
+
 [[package]]
 name = "shlex"
 version = "2.0.1"
@@ -5353,6 +5443,15 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "winreg"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
+dependencies = [
+ "winapi",
+]
+
 [[package]]
 name = "winreg"
 version = "0.55.0"
diff --git a/README.md b/README.md
index ddd6d39a..7ccdb1b4 100644
--- a/README.md
+++ b/README.md
@@ -31,6 +31,8 @@ macOS (Apple Silicon): download [MonoCode.dmg](https://dl.usemono.dev/MonoCode.d
 
 Linux (x86_64): download the `.deb` or AppImage from [GitHub Releases](https://github.com/hardbeat920/monocode/releases/latest). Install the `.deb` with `sudo apt install ./MonoCode_*.deb`, or make the AppImage executable with `chmod +x MonoCode_*.AppImage` and run it directly.
 
+Windows (x86_64): download the NSIS installer from [GitHub Releases](https://github.com/hardbeat920/monocode/releases/latest) and run it.
+
 ## Some notes
 
 This is very early and you should expect bugs.
@@ -39,9 +41,9 @@ Small, focused pull requests are welcome. Anything large is worth an issue first
 
 ## Build from source
 
-Supports macOS and Linux.
+Supports macOS, Linux, and Windows.
 
-Need Node.js 20+ and a current stable Rust toolchain. On Linux, ensure standard Tauri prerequisites are installed (e.g. `libwebkit2gtk-4.1-dev`, `libgtk-3-dev`, `libsoup-3.0-dev`, `libjavascriptcoregtk-4.1-dev`).
+Need Node.js 20+ and a current stable Rust toolchain. On Linux, ensure standard Tauri prerequisites are installed (e.g. `libwebkit2gtk-4.1-dev`, `libgtk-3-dev`, `libsoup-3.0-dev`, `libjavascriptcoregtk-4.1-dev`). On Windows, the installer bootstraps the [WebView2](https://developer.microsoft.com/microsoft-edge/webview2/) runtime when it is missing.
 
 ```bash
 npm install
@@ -61,6 +63,16 @@ npm run build:linux
 The Linux build emits `.deb` and AppImage bundles under `target/release/bundle/`.
 Tauri loads `src-tauri/tauri.linux.conf.json` automatically for Linux development and builds.
 
+### Windows packages
+
+```bash
+npm ci
+npm run build:windows
+```
+
+The Windows build emits an NSIS installer under `target/release/bundle/nsis/`.
+Tauri loads `src-tauri/tauri.windows.conf.json` automatically for Windows development and builds.
+
 ## License
 
 [MIT](LICENSE). Provider names and logos are trademarks of their owners - see [NOTICE](NOTICE).
diff --git a/index.html b/index.html
index b8182e8e..28eb0578 100644
--- a/index.html
+++ b/index.html
@@ -3,6 +3,7 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <link rel="icon" href="/monocode.png" />
     <title>MonoCode</title>
     <script>
       (function () {
diff --git a/package.json b/package.json
index b3b3cb9d..0f74066b 100644
--- a/package.json
+++ b/package.json
@@ -17,7 +17,8 @@
     "tauri": "tauri",
     "tauri:stable": "tauri dev --no-watch --config src-tauri/tauri.stable.conf.json",
     "setup:linux:deb": "bash scripts/install-linux-deps-debian.sh",
-    "build:linux": "tauri build --bundles deb,appimage"
+    "build:linux": "tauri build --bundles deb,appimage",
+    "build:windows": "tauri build --bundles nsis"
   },
   "dependencies": {
     "@codemirror/lang-css": "^6.3.1",
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 05a00aa7..df2d19b3 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -29,6 +29,9 @@ tauri-plugin-process = "2"
 [target.'cfg(unix)'.dependencies]
 libc = "0.2"
 
+[target.'cfg(windows)'.dependencies]
+portable-pty = "0.9"
+
 [target.'cfg(target_os = "macos")'.dependencies]
 block2 = "0.6.2"
 objc2 = "0.6"
diff --git a/src-tauri/build.rs b/src-tauri/build.rs
index a971b1e9..ae3b454a 100644
--- a/src-tauri/build.rs
+++ b/src-tauri/build.rs
@@ -2,5 +2,12 @@ fn main() {
     // generate_context! embeds icons; cargo ignores them unless we watch here.
     println!("cargo:rerun-if-changed=icons");
     println!("cargo:rerun-if-changed=macos/Assets.car");
+    // GNU ld exports every symbol from the Tauri cdylib and blows past the
+    // 65535 PE ordinal limit. Hide them; the desktop exe links the rlib.
+    if std::env::var("CARGO_CFG_TARGET_OS").as_deref() == Ok("windows")
+        && std::env::var("CARGO_CFG_TARGET_ENV").as_deref() == Ok("gnu")
+    {
+        println!("cargo::rustc-link-arg-cdylib=-Wl,--exclude-libs=ALL,--exclude-all-symbols");
+    }
     tauri_build::build()
 }
diff --git a/src-tauri/icons/installer-sidebar.bmp b/src-tauri/icons/installer-sidebar.bmp
new file mode 100644
index 0000000000000000000000000000000000000000..74b6d4ed51fdd5b06ffe43e4b4842dd5e38ba253
GIT binary patch
literal 154542
zcmeI*>x&fG9met5`~mxR^4d2p_#z-ANJNljU=aznAR>z5q9|TaMDfLdcSS@+T+!Lp
z(e{oqalPOLB{8<fC`64Wq8Ov5y)Udc6a+<kpYhC`Jyf6SsXnvY(^dUF;81hA>QvR|
zsb6)^%<1;aKYc&$H%*=G5Bm3o{_WPkKYrHK^jXtywPf1gKW}R4{MX%@X$T;I00Iag
zfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}
z0tg_000IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_000IagfB*sr
zAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_0
z00IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@
z2q1s}0tg_000IagfB*tD7sxd?mx}pfsnndyYv;v$u2d?u7D`$+59!<H)`B^%R;^qr
zsK>NizG#oPd}TYDHfV0vrk$<A2;LPEZfp16eP|_nMjE#KQFmCg-$wXq9E^-LF%<S&
zlXan0K}Vael24XDd)f;lpVRspxbxyLSyvuG+T|;l1M@zlk<0fUIX-hW+7q#l+CyrD
zi0wJLS=)4EqR1?fmTf&+Ub}L{(`0S8)ldeu#}VubZV(0SCYQGlCEUBtu2g8%uFa)l
z55``H_VgQS!Ohy-!1Dr?RH5V&nTm5$kdj&7bh<0shl(1hR5UB}ID%P0TbO4PH-#Rz
zjqF|9+MdXXxWhKuvN4fxE|<4Y+@GRW)~)JMS}KRG%b@#?ZIn!Dn{=$LRyO^LIG<B-
zb!FY-2;LRUj=T@W?cFA5x6-Y_oQTfFH20N;T|e^+HtT$AUb&c?q^YBvN+Kw0bN`g5
z4PDRIR^B|n8(23l?+Ru$??djk?v-XEvs;n1F|k<}3o68tx!}$7V_qHIS$l7=22*P(
zN~>M?G>*Au+^l;X!MlPvNbf`5z1wGGdpz93?Zt1iE)_eUUF~zFYE$2;Q(pvF;nk5a
zHJY{U+^BmTH|yjh6h2)%T`6mbim%Ngd$(Dedy6@Edu;Ymd-@HvU>(F_im?mX`3cJq
znc%dV+iWiGIQH4l&051&9>Kdp<g#&ht!3}t-F3_vxyNQ6b<ebM;&vTuMml|4hQhJs
z;I6EGQ&YyuK4krEc5aVd&6v9*SaVyFTE}LsM=NX_dB_YNci4KgF|)S9EFgdY0tg_0
z00IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_000IagfB*srAb<b@
z2q1s}0tg_000IagfB*srAb<b@2q1s}0tg_000MO`(63*=fddErF0^S|jo>}U0RsjM
z8Z_wly=ZYGdv`}?j{@VyjoY+o(>I~5t*vd!lquf5EMC00qoZR_P}{qA@4kKeMvWTf
z9huHBfr%3*wzs!`8``#R-8y~xbnmWLtXOg6$dNw>wF3tZ96We%?AWp1k?9N*m@r|&
z=FOW`+F@<WmMzn!P4n)0`SRt54jocyhc(4LX3QAx$aIDYkad__8n+_rG^Q4I%w!$r
zmd35fI*qA?9Wz;nxutO{vQA@aVaH6?VQy*MimcO^TG%m@b(mWkw<7B_rWSV0WF6*~
z#;wRYjj4qlGg*hZrEx2=PGf3e$4u5?ZfV?#tkalU*fEoJm|GgRQr6qHZTl{?<@5O&
zGiG>CeC5iOM~@!;KB#E|(&590M~)on9l0?(HPiCTUbL2$7R@(XwQ7~-hK04&t5=U7
zKi-Q!fBt;UMhl(D_N`_{&6zW2^5n^12enC)Ch0QH(o9rM%3ZW*k!Eb_Yd~AJY}wSQ
zQ@u&mL#HOHojZ5#Z$a(s*|R54o*X=Qa6O#JFLDgZdclGP3l}cb*MPQU$&z}`TGNIV
z*<XU%>C>lAoH#+&_Nu7=tk0Y|^Vgt8);49cK-Ry=-L*D@Wd0sbUE2$ZtmAI*+{3wt
z+cHVr0(DJYN9s53TV9)`sJf|Z>N>8FBmLAhbzLU{`n?%HbJ;AohjR~)+^gfh<sNRU
zrv4XdT-UQ_&(<Hi^_R-9rfu~n)a0t%!(FQyXMO6_sZ#ISjvYJP<FC9-)~-*Dv(`M5
z-bG!~4Z%JB%FAT!`j9oR&Ej5+Mf$6KZAM+Yg;wKb>bi02T61hvn@g82)z^Tg`Gj$^
zK)n}j<+^_V{{7v%cmM0OCr_S4p5Lo_zSb1f3l}bE8d5+zfBw8KgCRqPcuypao%$Hj
zpjnn(8)=qiRr7MovwrjD&4&*kOrZDf-HRA%itD>~@7%bn%39a(#*G`pK0b59h7If1
zt&>mWkoY#CKqPDBIAX*I&0>A|@}&aRw>NLz{EyR$#p1`0AA_?_cvP(RYY0TLRz>SR
zsU3|TJ^In3M{cHZ%T?9&uW<^DnNT2-wF&grty}u|Xnl0_!-o&!BDVcxoshcESMz4A
z997gRZGAlT+qZ9RtlkB(?(+~69za~yidFC4(jYHhyzoYBJIOjBb)T>1%~~(X^xi8S
z+wtSaZKiPxWZmZ>COm-hte-!BuJ@5?bA42JT)u8UStq0}UrnE;{*T_Z-Me>}4;$AL
z$yyaXY}hcZtasSCfmT?qD(kgt*Y4c8Q-28!Xxq1M*ZYk1-;u<fOX~XP&6`&NHpxT!
zEm!ihj%2N$xs>wl+qaYK$gERU*7|`?Kd}EhsNJ}6<I<%|`ejb?v#awp^$z9a&fYck
zn~&t@7|Gf@VCBxLvOad~*ww37{~6RSU%sqglMWp^H2K-p`I=-McOj5<dC^hVbzaW)
z@ThC*y1ahldaA1H-p@DF>uP(U_PD_FwM$gvy4Ihx<gZs~VNKg=CaQb<m6yrd^{H{z
z?yhUFOx7+kS@V1y_v~EWU)A%qdzsZ>nYwn7scY)Gynf?)sB5=&>Uo*Ermo|vxV)db
zuIE~IkBz#fuFLB;u7|pIYp0%<scY&wu8Pb1sq1>KW%t;qYwEhZe&c%TysocZyQZl`
z0qx3_E1HPMyc9S0>({TlH;TGi)`z|8@ctFlbdg-Vcri;^>pi*4d)IdD+9glT*a>Tz
z!l$=GdasbSwl--Of|}lhtJz|D%ka#ZGp7eNz1LX(<w5`c{k_N5n4N3Zta<(V^^c)V
z@5$Y>XOEXo@1B1A__5xR9nkdl-uw6OD`@Y?bcPA6U%&p@vuAo!d|1<)dg4CXX#f8G
zdQYz2*%#0>lljh_J9_0Ac2aER6(DObOC~$XI+L+_Pl~L)ESc;i>rBS#Jt?yGvShN8
ztTP#__oT?$%aX}Xvd(0z-jgD0FH0sn$vTs<dQXb1y)2pRB<oDZ>OCp4_OfKMldLlt
ztM{bH+RKv3PO{EqtlpC%YcESCJN5bb`lR<CLfflXui`!erK6+c!Gj0?3vHT)G<WXY
zOq%!ANol^BW*_}Ov^{<Lw7tFEd+_@7OHC!xoaC^kS&Oq~&GL>+XPAKgM+|+Y=vSd_
z`0(LzpZTdzk8f#d(WgWPG;OHHEYPq_*$M#!5I_I{1Q0*~0R#|0009ILKmY**5I_I{
z1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009IL
zKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q0*~
t0R#|0009ILKmY**5I_I{1Q0*~0R#|0009ILKmY**5I_I{1Q1BOz)$-7no<A&

literal 0
HcmV?d00001

diff --git a/src-tauri/src/checkpoint.rs b/src-tauri/src/checkpoint.rs
index 55afc09c..a3ed4006 100644
--- a/src-tauri/src/checkpoint.rs
+++ b/src-tauri/src/checkpoint.rs
@@ -9,8 +9,8 @@ use tauri::{AppHandle, Manager, State};
 #[cfg(test)]
 use crate::fs::GitDiffStats;
 use crate::fs::{
-    expand_home, git_checked, git_diff_files_for, resolve_repo_path, GitChangedFile, GitDiffIndex,
-    MAX_TEXT_FILE_BYTES,
+    expand_home, git_checked, git_diff_files_for, path_to_js, resolve_repo_path, GitChangedFile,
+    GitDiffIndex, MAX_TEXT_FILE_BYTES,
 };
 
 const MAX_SNAPSHOT_FILES: usize = 500;
@@ -497,7 +497,7 @@ fn describe_change(root: &Path, relative: &str, git: Option<&GitChangedFile>) ->
     let abs = root.join(relative);
     let status = if !abs.exists() { "deleted" } else { "modified" };
     CheckpointFile {
-        path: abs.to_string_lossy().into_owned(),
+        path: path_to_js(&abs),
         relative: relative.to_string(),
         status: status.into(),
         additions: 0,
@@ -774,6 +774,7 @@ mod tests {
         }
         let _ = git(dir, &["config", "user.email", "monocode@test"]);
         let _ = git(dir, &["config", "user.name", "monocode"]);
+        let _ = git(dir, &["config", "core.autocrlf", "false"]);
         for (name, contents) in files {
             let path = dir.join(name);
             if let Some(parent) = path.parent() {
diff --git a/src-tauri/src/fs.rs b/src-tauri/src/fs.rs
index 3fa79c0e..632e7977 100644
--- a/src-tauri/src/fs.rs
+++ b/src-tauri/src/fs.rs
@@ -45,7 +45,7 @@ pub fn list_dir(path: String) -> Result<Vec<DirEntry>, String> {
         out.push(DirEntry {
             ignored: ignore.matches(name),
             name: name.to_string(),
-            path: path.to_string_lossy().into_owned(),
+            path: path_to_js(&path),
             is_dir,
         });
     }
@@ -95,7 +95,7 @@ pub(crate) fn list_project_files_sync(cwd: &str) -> Result<Vec<ProjectFile>, Str
 }
 
 fn git_ls_files(root: &Path) -> Option<Vec<ProjectFile>> {
-    let output = Command::new("git")
+    let output = git_cmd()
         .arg("-C")
         .arg(root)
         .args(["ls-files", "-co", "--exclude-standard", "-z"])
@@ -123,7 +123,7 @@ fn git_ls_files(root: &Path) -> Option<Vec<ProjectFile>> {
         }
         files.push(ProjectFile {
             name: name.to_string(),
-            path: path.to_string_lossy().into_owned(),
+            path: path_to_js(&path),
             relative,
         });
         if files.len() >= MAX_PROJECT_FILES {
@@ -794,7 +794,7 @@ fn git_diff_index_with(root: &Path, include_sync: bool) -> GitDiffIndex {
             "modified"
         };
         out.push(GitChangedFile {
-            path: abs.to_string_lossy().into_owned(),
+            path: path_to_js(&abs),
             relative,
             status: status.to_string(),
             additions: acc.additions,
@@ -992,7 +992,7 @@ fn git_file_diff_for(root: &Path, relative: &str) -> Result<GitFileDiff, String>
         )
     };
     Ok(GitFileDiff {
-        path: abs.to_string_lossy().into_owned(),
+        path: path_to_js(&abs),
         relative,
         status: status.to_string(),
         original: original_text,
@@ -1038,7 +1038,7 @@ fn git_index_mode(root: &Path, relative: &str) -> Option<String> {
 }
 
 fn git_hash_object(root: &Path, relative: &str, contents: &[u8]) -> Result<String, String> {
-    let mut child = Command::new("git")
+    let mut child = git_cmd()
         .arg("--no-pager")
         .arg("-C")
         .arg(root)
@@ -2169,8 +2169,14 @@ pub(crate) fn resolve_repo_path(root: &Path, relative: &str) -> Result<String, S
     Ok(relative)
 }
 
+fn git_cmd() -> Command {
+    let mut cmd = Command::new("git");
+    crate::hide_window_console(&mut cmd);
+    cmd
+}
+
 pub(crate) fn git_checked(root: &Path, args: &[&str]) -> Result<(), String> {
-    let output = Command::new("git")
+    let output = git_cmd()
         .arg("--no-pager")
         .arg("-C")
         .arg(root)
@@ -2204,7 +2210,7 @@ fn git_run(root: &Path, args: &[&str]) -> Option<String> {
 }
 
 fn git_output(root: &Path, args: &[&str]) -> Option<Vec<u8>> {
-    let output = Command::new("git")
+    let output = git_cmd()
         .arg("--no-pager")
         .arg("-C")
         .arg(root)
@@ -2409,7 +2415,7 @@ fn git_branch_name(root: &Path, name: &str) -> Result<String, String> {
     if name.is_empty() {
         return Err("Branch name cannot be empty".into());
     }
-    let output = Command::new("git")
+    let output = git_cmd()
         .arg("-C")
         .arg(root)
         .args(["check-ref-format", "--branch", name])
@@ -2535,12 +2541,7 @@ fn git_ahead_behind(root: &Path, base: &str) -> (i64, i64) {
 }
 
 fn git_stdout(root: &Path, args: &[&str]) -> Option<String> {
-    let output = Command::new("git")
-        .arg("-C")
-        .arg(root)
-        .args(args)
-        .output()
-        .ok()?;
+    let output = git_cmd().arg("-C").arg(root).args(args).output().ok()?;
     if !output.status.success() {
         return None;
     }
@@ -2602,7 +2603,7 @@ fn walk_project_files(root: &Path) -> Vec<ProjectFile> {
             let relative = relative.to_string_lossy().replace('\\', "/");
             files.push(ProjectFile {
                 name: name.to_string(),
-                path: path.to_string_lossy().into_owned(),
+                path: path_to_js(&path),
                 relative,
             });
             if files.len() >= MAX_PROJECT_FILES {
@@ -2648,7 +2649,7 @@ fn skip_walk_dir_name(name: &str) -> bool {
 }
 
 fn path_has_skipped_dir(relative: &str) -> bool {
-    relative.split('/').any(skip_walk_dir_name)
+    relative.split(['/', '\\']).any(skip_walk_dir_name)
 }
 
 /// Directories the OS guards behind a consent prompt. macOS pops "would like to
@@ -2776,7 +2777,8 @@ pub(crate) fn expand_home(path: &str) -> PathBuf {
             .map(PathBuf::from)
             .unwrap_or_else(|| PathBuf::from(path));
     }
-    if let Some(rest) = path.strip_prefix("~/") {
+    let rest = path.strip_prefix("~/").or_else(|| path.strip_prefix("~\\"));
+    if let Some(rest) = rest {
         if let Some(home) = dirs_home() {
             return PathBuf::from(home).join(rest);
         }
@@ -2784,6 +2786,10 @@ pub(crate) fn expand_home(path: &str) -> PathBuf {
     PathBuf::from(path)
 }
 
+pub(crate) fn path_to_js(path: &Path) -> String {
+    path.to_string_lossy().replace('\\', "/")
+}
+
 struct Ignore {
     exact: HashSet<String>,
     suffixes: Vec<String>,
@@ -2853,7 +2859,7 @@ fn clone_repo_sync(url: &str, parent: &str) -> Result<String, String> {
         return Err(format!("{} already exists", dest.display()));
     }
     let dest_str = dest.to_str().ok_or("Invalid destination path")?;
-    let output = std::process::Command::new("git")
+    let output = git_cmd()
         .args(["clone", "--", url, dest_str])
         .output()
         .map_err(|e| {
@@ -2999,7 +3005,7 @@ fn inspect_path_sync(path: &str) -> Option<PathInfo> {
         .unwrap_or(path.to_str().unwrap_or("attachment"))
         .to_string();
     Some(PathInfo {
-        path: path.to_string_lossy().into_owned(),
+        path: path_to_js(&path),
         name,
         size: meta.len(),
         is_dir: meta.is_dir(),
@@ -3217,7 +3223,10 @@ fn same_entry(a: &Path, b: &Path) -> bool {
     #[cfg(not(unix))]
     {
         let _ = (a_meta, b_meta);
-        a == b
+        match (std::fs::canonicalize(a), std::fs::canonicalize(b)) {
+            (Ok(left), Ok(right)) => left == right,
+            _ => false,
+        }
     }
 }
 
@@ -3400,11 +3409,9 @@ pub fn reveal_path(path: String) -> Result<(), String> {
     if !path.exists() {
         return Err(format!("{}: No such file or directory", path.display()));
     }
-    #[cfg(any(target_os = "macos", target_os = "windows"))]
-    let path_str = path.to_str().ok_or_else(|| "Invalid path".to_string())?;
-
     #[cfg(target_os = "macos")]
     {
+        let path_str = path.to_str().ok_or_else(|| "Invalid path".to_string())?;
         let status = Command::new("open")
             .args(["-R", path_str])
             .status()
@@ -3417,14 +3424,13 @@ pub fn reveal_path(path: String) -> Result<(), String> {
 
     #[cfg(target_os = "windows")]
     {
-        let status = Command::new("explorer")
+        // explorer.exe returns 1 even when it opened the folder.
+        let path_str = path.to_string_lossy().replace('/', "\\");
+        Command::new("explorer")
             .arg(format!("/select,{path_str}"))
-            .status()
+            .spawn()
             .map_err(|e| e.to_string())?;
-        if !status.success() {
-            return Err("Could not reveal in File Explorer.".into());
-        }
-        return Ok(());
+        Ok(())
     }
 
     #[cfg(not(any(target_os = "macos", target_os = "windows")))]
@@ -3505,7 +3511,7 @@ mod tests {
         assert!(!notes.is_dir);
         assert_eq!(notes.size, 6);
         let folder = infos.iter().find(|info| info.is_dir).unwrap();
-        assert_eq!(folder.path, dir.0.to_string_lossy());
+        assert_eq!(folder.path, path_to_js(&dir.0));
     }
 
     #[test]
@@ -3713,6 +3719,7 @@ mod tests {
         git(dir, &["config", "user.name", "MonoCode"])
             && git(dir, &["config", "user.email", "monocode@test"])
             && git(dir, &["config", "commit.gpgsign", "false"])
+            && git(dir, &["config", "core.autocrlf", "false"])
     }
 
     #[test]
@@ -4153,6 +4160,8 @@ mod tests {
             || !git(&b.0, &["config", "user.name", "MonoCode"])
             || !git(&b.0, &["config", "user.email", "monocode@test"])
             || !git(&b.0, &["config", "commit.gpgsign", "false"])
+            || !git(&b.0, &["config", "core.autocrlf", "false"])
+            || !git(&b.0, &["checkout", "--", "."])
         {
             return;
         }
diff --git a/src-tauri/src/harness.rs b/src-tauri/src/harness.rs
index 81d77c1b..20c8b455 100644
--- a/src-tauri/src/harness.rs
+++ b/src-tauri/src/harness.rs
@@ -115,7 +115,7 @@ impl HarnessHost {
         (epoch, kill_all, prev)
     }
 
-    #[cfg(test)]
+    #[cfg(all(test, unix))]
     fn spawn_stamp_current(&self, session_id: &str, epoch: u64, kill_all: u64) -> bool {
         let inner = self.lock_inner();
         self.kill_all_gen.load(Ordering::SeqCst) == kill_all
@@ -722,6 +722,7 @@ const KILL_ESCALATE: Duration = Duration::from_secs(2);
 
 /// An interactive shell has to source the user's whole rc file; nvm alone can
 /// take a second.
+#[cfg(not(windows))]
 const LOGIN_SHELL_TIMEOUT: Duration = Duration::from_secs(5);
 
 /// A spawn that was cancelled mid-fork. The session it was starting is already
@@ -734,7 +735,14 @@ fn isolate_child(cmd: &mut Command) {
         use std::os::unix::process::CommandExt;
         cmd.process_group(0);
     }
-    #[cfg(not(unix))]
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+        const CREATE_NEW_PROCESS_GROUP: u32 = 0x0000_0200;
+        cmd.creation_flags(CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP);
+    }
+    #[cfg(not(any(unix, windows)))]
     {
         let _ = cmd;
     }
@@ -748,16 +756,25 @@ fn terminate_after(pid: u32, escalate: Duration) {
     if pid == 0 || pid == 1 {
         return;
     }
-    signal_tree(pid, TreeSignal::Term);
-    thread::spawn(move || {
-        thread::sleep(escalate);
-        if tree_alive(pid) {
-            signal_tree(pid, TreeSignal::Kill);
-        }
-    });
+    #[cfg(windows)]
+    {
+        let _ = escalate;
+        signal_tree(pid, TreeSignal::Kill);
+    }
+    #[cfg(not(windows))]
+    {
+        signal_tree(pid, TreeSignal::Term);
+        thread::spawn(move || {
+            thread::sleep(escalate);
+            if tree_alive(pid) {
+                signal_tree(pid, TreeSignal::Kill);
+            }
+        });
+    }
 }
 
 enum TreeSignal {
+    #[cfg(not(windows))]
     Term,
     Kill,
 }
@@ -779,13 +796,24 @@ fn signal_tree(pid: u32, signal: TreeSignal) {
             libc::kill(ipid, sig);
         }
     }
-    #[cfg(not(unix))]
+    #[cfg(windows)]
+    {
+        let _ = signal;
+        let mut cmd = Command::new("taskkill");
+        crate::hide_window_console(&mut cmd);
+        cmd.args(["/PID", &pid.to_string(), "/T", "/F"])
+            .stdout(Stdio::null())
+            .stderr(Stdio::null());
+        let _ = cmd.status();
+    }
+    #[cfg(not(any(unix, windows)))]
     {
         let _ = signal;
         let _ = Command::new("kill").arg(pid.to_string()).status();
     }
 }
 
+#[cfg(not(windows))]
 fn tree_alive(pid: u32) -> bool {
     #[cfg(unix)]
     {
@@ -819,7 +847,7 @@ fn resolve_cursor_agent() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| is_cursor_agent(path))
+    first_binary_matching(candidates, is_cursor_agent)
 }
 
 fn resolve_codex() -> Option<PathBuf> {
@@ -850,7 +878,7 @@ fn resolve_codex() -> Option<PathBuf> {
         "/Applications/Codex.app/Contents/Resources/codex",
     ));
 
-    candidates.into_iter().find(|path| path.is_file())
+    first_binary(candidates)
 }
 
 fn resolve_opencode() -> Option<PathBuf> {
@@ -872,7 +900,7 @@ fn resolve_opencode() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| path.is_file())
+    first_binary(candidates)
 }
 
 fn resolve_claude() -> Option<PathBuf> {
@@ -895,7 +923,7 @@ fn resolve_claude() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| path.is_file())
+    first_binary(candidates)
 }
 
 fn resolve_pi() -> Option<PathBuf> {
@@ -924,7 +952,7 @@ fn resolve_pi() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| is_pi_coding_agent(path))
+    first_binary_matching(candidates, is_pi_coding_agent)
 }
 
 fn resolve_omp() -> Option<PathBuf> {
@@ -948,7 +976,7 @@ fn resolve_omp() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| is_omp_agent(path))
+    first_binary_matching(candidates, is_omp_agent)
 }
 
 /// omp ships as a ~126MB compiled binary, so the cheap string scan that
@@ -958,8 +986,7 @@ fn is_omp_agent(path: &Path) -> bool {
     if !path.is_file() {
         return false;
     }
-    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-    if name != "omp" {
+    if !binary_name_eq(path, "omp") {
         return false;
     }
     help_mentions_rpc_mode(path)
@@ -986,7 +1013,7 @@ fn resolve_fx() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| is_fx_agent(path))
+    first_binary_matching(candidates, is_fx_agent)
 }
 
 fn resolve_grok() -> Option<PathBuf> {
@@ -1009,20 +1036,19 @@ fn resolve_grok() -> Option<PathBuf> {
         candidates.push(from_shell);
     }
 
-    candidates.into_iter().find(|path| is_grok_agent(path))
+    first_binary_matching(candidates, is_grok_agent)
 }
 
 fn is_pi_coding_agent(path: &Path) -> bool {
     if !path.is_file() {
         return false;
     }
-    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-    if name != "pi" && name != "pi-coding-agent" {
-        return false;
-    }
-    if name == "pi-coding-agent" {
+    if binary_name_eq(path, "pi-coding-agent") {
         return true;
     }
+    if !binary_name_eq(path, "pi") {
+        return false;
+    }
     file_mentions_pi_coding_agent(path) || help_mentions_rpc_mode(path)
 }
 
@@ -1080,8 +1106,7 @@ fn is_fx_agent(path: &Path) -> bool {
     if !path.is_file() {
         return false;
     }
-    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-    if name != "fx" {
+    if !binary_name_eq(path, "fx") {
         return false;
     }
     file_mentions_fx_agent(path) || fx_help_mentions_acp(path)
@@ -1091,12 +1116,11 @@ fn is_grok_agent(path: &Path) -> bool {
     if !path.is_file() {
         return false;
     }
-    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-    if name != "grok" {
+    if !binary_name_eq(path, "grok") {
         return false;
     }
     // Official installer: ~/.grok/bin/grok
-    if path.to_string_lossy().contains("/.grok/") {
+    if path_has_component(path, ".grok") {
         return true;
     }
     file_mentions_grok_agent(path) || grok_help_mentions_agent(path)
@@ -1234,15 +1258,13 @@ fn is_cursor_agent(path: &Path) -> bool {
     if !path.is_file() {
         return false;
     }
-    let text = path.to_string_lossy();
-    if text.contains("/.grok/") {
+    if path_has_component(path, ".grok") {
         return false;
     }
-    let name = path.file_name().and_then(|n| n.to_str()).unwrap_or("");
-    if name == "cursor-agent" {
+    if binary_name_eq(path, "cursor-agent") {
         return true;
     }
-    if name == "agent" {
+    if binary_name_eq(path, "agent") {
         // One symlink hop. canonicalize() can walk into another .app
         // and trip macOS "data from other apps" TCC.
         if let Ok(target) = std::fs::read_link(path) {
@@ -1251,7 +1273,11 @@ fn is_cursor_agent(path: &Path) -> bool {
             } else {
                 path.parent().unwrap_or(path).join(target)
             };
-            return resolved.to_string_lossy().contains("cursor-agent");
+            return path_has_component(&resolved, "cursor-agent")
+                || resolved
+                    .to_string_lossy()
+                    .to_ascii_lowercase()
+                    .contains("cursor-agent");
         }
     }
     false
@@ -1266,10 +1292,63 @@ fn which_via_login_shell(name: &str) -> Option<PathBuf> {
 }
 
 fn which_in_path(path: &str, name: &str) -> Option<PathBuf> {
-    path.split(':')
-        .filter(|dir| !dir.is_empty())
-        .map(|dir| Path::new(dir).join(name))
-        .find(|candidate| is_executable_file(candidate))
+    std::env::split_paths(std::ffi::OsStr::new(path)).find_map(|dir| {
+        if dir.as_os_str().is_empty() {
+            return None;
+        }
+        existing_binary(dir.join(name))
+    })
+}
+
+fn first_binary(candidates: Vec<PathBuf>) -> Option<PathBuf> {
+    candidates.into_iter().find_map(existing_binary)
+}
+
+fn first_binary_matching(
+    candidates: Vec<PathBuf>,
+    pred: impl Fn(&Path) -> bool,
+) -> Option<PathBuf> {
+    candidates.into_iter().find_map(|path| {
+        let path = existing_binary(path)?;
+        pred(&path).then_some(path)
+    })
+}
+
+fn existing_binary(path: PathBuf) -> Option<PathBuf> {
+    if is_executable_file(&path) {
+        return Some(path);
+    }
+    #[cfg(windows)]
+    if path.extension().is_none() {
+        for ext in ["exe", "cmd", "bat", "com"] {
+            let candidate = path.with_extension(ext);
+            if is_executable_file(&candidate) {
+                return Some(candidate);
+            }
+        }
+    }
+    None
+}
+
+fn binary_name_eq(path: &Path, expected: &str) -> bool {
+    path.file_stem()
+        .and_then(|name| name.to_str())
+        .is_some_and(|name| {
+            if cfg!(windows) {
+                name.eq_ignore_ascii_case(expected)
+            } else {
+                name == expected
+            }
+        })
+}
+
+fn path_has_component(path: &Path, needle: &str) -> bool {
+    path.components().any(|component| {
+        component
+            .as_os_str()
+            .to_str()
+            .is_some_and(|name| name == needle)
+    })
 }
 
 fn is_executable_file(path: &Path) -> bool {
@@ -1293,7 +1372,7 @@ pub(crate) fn resolve_gui_binary(name: &str) -> Option<PathBuf> {
     which_in_path(&gui_search_path(), name)
 }
 
-fn gui_search_path() -> String {
+pub(crate) fn gui_search_path() -> String {
     gui_search_path_from(login_shell_path(), dirs_home(), std::env::var("PATH").ok())
 }
 
@@ -1302,30 +1381,42 @@ fn gui_search_path_from(
     home: Option<String>,
     existing: Option<String>,
 ) -> String {
-    let mut parts: Vec<String> = Vec::new();
+    let mut parts: Vec<PathBuf> = Vec::new();
     // Login-shell PATH first so Homebrew, mise, nvm, and custom dirs match
     // the user's terminal. The fixed list is a fallback when that read fails.
     if let Some(path) = login_path {
-        parts.push(path);
+        parts.extend(std::env::split_paths(&path));
     }
     if let Some(home) = home {
-        parts.push(format!("{home}/.local/bin"));
-        parts.push(format!("{home}/.cargo/bin"));
-        parts.push(format!("{home}/.claude/local"));
-        parts.push(format!("{home}/.local/share/claude"));
-        parts.push(format!("{home}/.opencode/bin"));
-        parts.push(format!("{home}/.grok/bin"));
-        parts.push(format!("{home}/.npm-global/bin"));
+        parts.push(format!("{home}/.local/bin").into());
+        parts.push(format!("{home}/.cargo/bin").into());
+        parts.push(format!("{home}/.claude/local").into());
+        parts.push(format!("{home}/.local/share/claude").into());
+        parts.push(format!("{home}/.opencode/bin").into());
+        parts.push(format!("{home}/.grok/bin").into());
+        parts.push(format!("{home}/.npm-global/bin").into());
+        parts.push(format!("{home}/.bun/bin").into());
+        parts.push(format!("{home}/AppData/Roaming/npm").into());
+        parts.push(format!("{home}/AppData/Local/Yarn/bin").into());
+        parts.push(format!("{home}/scoop/shims").into());
     }
     parts.push("/opt/homebrew/bin".into());
     parts.push("/usr/local/bin".into());
     parts.push("/usr/bin".into());
     parts.push("/bin".into());
     parts.push("/snap/bin".into());
+    #[cfg(windows)]
+    {
+        parts.push(r"C:\Program Files\Git\cmd".into());
+        parts.push(r"C:\Program Files\nodejs".into());
+    }
     if let Some(existing) = existing {
-        parts.push(existing);
+        parts.extend(std::env::split_paths(&existing));
     }
-    parts.join(":")
+    std::env::join_paths(parts)
+        .unwrap_or_default()
+        .to_string_lossy()
+        .into_owned()
 }
 
 fn apply_gui_path(cmd: &mut Command) {
@@ -1334,6 +1425,7 @@ fn apply_gui_path(cmd: &mut Command) {
 
 pub(crate) fn apply_gui_env(cmd: &mut Command) {
     apply_gui_path(cmd);
+    crate::hide_window_console(cmd);
     if let Some(id) = passwd_identity() {
         if std::env::var_os("HOME").is_none() {
             cmd.env("HOME", &id.home);
@@ -1346,7 +1438,15 @@ pub(crate) fn apply_gui_env(cmd: &mut Command) {
             cmd.env("SHELL", &id.shell);
         }
     } else if let Some(home) = dirs_home() {
-        cmd.env("HOME", home);
+        cmd.env("HOME", &home);
+        if std::env::var_os("USERPROFILE").is_none() {
+            cmd.env("USERPROFILE", &home);
+        }
+        if std::env::var_os("USER").is_none() {
+            if let Ok(username) = std::env::var("USERNAME") {
+                cmd.env("USER", username);
+            }
+        }
     }
     if std::env::var_os("LANG").is_none() && std::env::var_os("LC_ALL").is_none() {
         cmd.env("LANG", "en_US.UTF-8");
@@ -1423,13 +1523,29 @@ fn login_shell_env(name: &str) -> Option<String> {
         .filter(|value| !value.is_empty())
 }
 
+fn load_login_shell_env() -> HashMap<String, String> {
+    #[cfg(windows)]
+    {
+        LOGIN_SHELL_KEYS
+            .into_iter()
+            .filter_map(|key| {
+                let value = std::env::var(key).ok()?;
+                (!value.is_empty()).then(|| (key.to_string(), value))
+            })
+            .collect()
+    }
+    #[cfg(not(windows))]
+    load_unix_login_shell_env()
+}
+
 /// Read the environment the user actually gets in a terminal.
 ///
 /// `-lic`, not `-lc`: zsh reads `.zshrc` only for *interactive* shells, and
 /// version managers (nvm, fnm, mise, volta) all initialize from there. A
 /// login-but-not-interactive shell sees `.zshenv`/`.zprofile` only, so every
 /// nvm-managed CLI looks uninstalled.
-fn load_login_shell_env() -> HashMap<String, String> {
+#[cfg(not(windows))]
+fn load_unix_login_shell_env() -> HashMap<String, String> {
     let shell = std::env::var("SHELL").unwrap_or_else(|_| {
         if cfg!(target_os = "macos") {
             "/bin/zsh".into()
@@ -1472,7 +1588,7 @@ fn load_login_shell_env() -> HashMap<String, String> {
 
 fn command_basename(command: &str) -> &str {
     Path::new(command)
-        .file_name()
+        .file_stem()
         .and_then(|name| name.to_str())
         .unwrap_or(command)
 }
@@ -1851,6 +1967,7 @@ mod tests {
         assert_eq!(command_basename("/Users/me/.local/bin/fx"), "fx");
         assert_eq!(command_basename("fx"), "fx");
         assert_eq!(command_basename("/Users/me/.grok/bin/grok"), "grok");
+        assert_eq!(command_basename("fx.exe"), "fx");
     }
 
     #[test]
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index f01a9fb0..fbefbb25 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -25,14 +25,18 @@ mod window_transfer;
 #[tauri::command]
 fn default_cwd() -> String {
     if let Ok(cwd) = std::env::current_dir() {
-        return cwd.to_string_lossy().into_owned();
+        return fs::path_to_js(&cwd);
     }
-    dirs_home().unwrap_or_else(|| "~".into())
+    dirs_home()
+        .map(|home| fs::path_to_js(std::path::Path::new(&home)))
+        .unwrap_or_else(|| "~".into())
 }
 
 #[tauri::command]
 fn home_dir() -> String {
-    dirs_home().unwrap_or_else(|| "~".into())
+    dirs_home()
+        .map(|home| fs::path_to_js(std::path::Path::new(&home)))
+        .unwrap_or_else(|| "~".into())
 }
 
 pub(crate) struct PasswdIdentity {
@@ -42,13 +46,35 @@ pub(crate) struct PasswdIdentity {
 }
 
 pub(crate) fn dirs_home() -> Option<String> {
-    if let Some(home) = std::env::var_os("HOME") {
-        let home = home.to_string_lossy().into_owned();
-        if !home.is_empty() {
-            return Some(home);
+    #[cfg(windows)]
+    let keys = ["USERPROFILE", "HOME"];
+    #[cfg(not(windows))]
+    let keys = ["HOME", "USERPROFILE"];
+    for key in keys {
+        if let Some(home) = std::env::var_os(key) {
+            let home = home.to_string_lossy().into_owned();
+            if !home.is_empty() {
+                return Some(home);
+            }
+        }
+    }
+    match (std::env::var("HOMEDRIVE"), std::env::var("HOMEPATH")) {
+        (Ok(drive), Ok(path)) if !drive.is_empty() && !path.is_empty() => {
+            Some(format!("{drive}{path}"))
         }
+        _ => passwd_identity().map(|id| id.home),
+    }
+}
+
+/// Hide the console window that Windows allocates for GUI-spawned children.
+pub(crate) fn hide_window_console(cmd: &mut std::process::Command) {
+    #[cfg(windows)]
+    {
+        use std::os::windows::process::CommandExt;
+        const CREATE_NO_WINDOW: u32 = 0x0800_0000;
+        cmd.creation_flags(CREATE_NO_WINDOW);
     }
-    passwd_identity().map(|id| id.home)
+    let _ = cmd;
 }
 
 /// Finder-launched .app bundles often omit HOME/USER/SHELL. Fall back to the
@@ -310,9 +336,12 @@ pub fn run() {
                 return;
             }
             api.prevent_exit();
-            // Last window destroyed (red button). Stay in the dock; ⌘Q is a
-            // separate menu handler and arrives with an exit code.
+            // Last window destroyed (red button). Stay in the dock on macOS;
+            // ⌘Q is a separate menu handler and arrives with an exit code.
+            // Windows has no dock, so the last close is a quit.
             if code.is_none() {
+                #[cfg(target_os = "windows")]
+                window::request_quit(handle);
                 return;
             }
             window::request_quit(handle);
diff --git a/src-tauri/src/pty.rs b/src-tauri/src/pty.rs
index acaffabd..021eb671 100644
--- a/src-tauri/src/pty.rs
+++ b/src-tauri/src/pty.rs
@@ -1,14 +1,12 @@
 use std::collections::HashMap;
-#[cfg(unix)]
-use std::io::Read;
-use std::io::Write;
+use std::io::{Read, Write};
 #[cfg(unix)]
 use std::os::unix::io::AsRawFd;
 use std::sync::{Arc, Mutex};
-#[cfg(unix)]
 use std::thread;
+use std::time::Duration;
 #[cfg(unix)]
-use std::time::{Duration, Instant};
+use std::time::Instant;
 
 use serde::Serialize;
 use tauri::{AppHandle, Emitter, Manager, State};
@@ -18,11 +16,9 @@ use crate::fs::expand_home;
 
 const DATA_EVENT: &str = "pty-data";
 const EXIT_EVENT: &str = "pty-exit";
-#[cfg(unix)]
 const READ_CHUNK: usize = 32 * 1024;
 /// Cap how often a busy PTY hops the webview. Each `emit` is a JS eval; a
 /// flood of small reads was thousands per second and froze input.
-#[cfg(unix)]
 const PTY_COALESCE: Duration = Duration::from_millis(8);
 #[cfg(unix)]
 const KILL_ESCALATE: Duration = Duration::from_secs(1);
@@ -45,6 +41,8 @@ struct LivePty {
     writer: Mutex<Box<dyn Write + Send>>,
     #[cfg(unix)]
     master_fd: i32,
+    #[cfg(windows)]
+    master: Mutex<Box<dyn portable_pty::MasterPty + Send>>,
     pid: u32,
 }
 
@@ -123,15 +121,20 @@ pub fn pty_spawn(
         close_fd(prev.master_fd);
     }
 
-    #[cfg(not(unix))]
+    #[cfg(unix)]
     {
-        let _ = (app, cwd, cols, rows);
-        return Err("Terminals are supported on macOS and Linux.".into());
+        spawn_unix(app, host, id, cwd, cols.max(2), rows.max(2))
     }
 
-    #[cfg(unix)]
+    #[cfg(windows)]
     {
-        spawn_unix(app, host, id, cwd, cols.max(2), rows.max(2))
+        spawn_windows(app, host, id, cwd, cols.max(2), rows.max(2))
+    }
+
+    #[cfg(not(any(unix, windows)))]
+    {
+        let _ = (app, cwd, cols, rows);
+        Err("Terminals are not supported on this platform.".into())
     }
 }
 
@@ -156,10 +159,22 @@ pub fn pty_resize(host: State<PtyHost>, id: String, cols: u16, rows: u16) -> Res
     {
         resize_fd(live.master_fd, cols.max(2), rows.max(2))
     }
-    #[cfg(not(unix))]
+    #[cfg(windows)]
+    {
+        let master = live.master.lock().unwrap_or_else(|e| e.into_inner());
+        master
+            .resize(portable_pty::PtySize {
+                rows: rows.max(2),
+                cols: cols.max(2),
+                pixel_width: 0,
+                pixel_height: 0,
+            })
+            .map_err(|err| format!("Failed to resize terminal: {err}"))
+    }
+    #[cfg(not(any(unix, windows)))]
     {
         let _ = (live, cols, rows);
-        Err("Terminals are supported on macOS and Linux.".into())
+        Err("Terminals are not supported on this platform.".into())
     }
 }
 
@@ -231,8 +246,8 @@ fn spawn_unix(
         .env("TERM", "xterm-256color")
         .env("COLORTERM", "truecolor")
         .env("COLORFGBG", "15;0")
-        .env("TERM_PROGRAM", "MonoCode");
-    apply_path(&mut cmd);
+        .env("TERM_PROGRAM", "MonoCode")
+        .env("PATH", crate::harness::gui_search_path());
     if let Some(home) = dirs_home() {
         cmd.env("HOME", &home);
     }
@@ -333,7 +348,99 @@ fn spawn_unix(
     Ok(())
 }
 
-#[cfg(unix)]
+#[cfg(windows)]
+fn spawn_windows(
+    app: AppHandle,
+    host: State<PtyHost>,
+    id: String,
+    cwd: String,
+    cols: u16,
+    rows: u16,
+) -> Result<(), String> {
+    use portable_pty::{native_pty_system, CommandBuilder, PtySize};
+
+    let workdir = working_dir(&cwd);
+    let (shell, args) = default_shell();
+    let pty_system = native_pty_system();
+    let pair = pty_system
+        .openpty(PtySize {
+            rows,
+            cols,
+            pixel_width: 0,
+            pixel_height: 0,
+        })
+        .map_err(|err| format!("Failed to open terminal: {err}"))?;
+
+    let mut cmd = CommandBuilder::new(&shell);
+    cmd.args(&args);
+    cmd.cwd(&workdir);
+    cmd.env("TERM", "xterm-256color");
+    cmd.env("COLORTERM", "truecolor");
+    cmd.env("COLORFGBG", "15;0");
+    cmd.env("TERM_PROGRAM", "MonoCode");
+    cmd.env("PATH", crate::harness::gui_search_path());
+    if let Some(home) = dirs_home() {
+        cmd.env("HOME", &home);
+        cmd.env("USERPROFILE", &home);
+    }
+    cmd.env("PWD", workdir.to_string_lossy().as_ref());
+
+    let mut child = pair
+        .slave
+        .spawn_command(cmd)
+        .map_err(|err| format!("Failed to start {shell}: {err}"))?;
+    let pid = child.process_id().unwrap_or(0);
+    let mut reader = pair
+        .master
+        .try_clone_reader()
+        .map_err(|err| format!("Failed to read terminal: {err}"))?;
+    let writer = pair
+        .master
+        .take_writer()
+        .map_err(|err| format!("Failed to write to terminal: {err}"))?;
+
+    let live = Arc::new(LivePty {
+        writer: Mutex::new(Box::new(writer)),
+        master: Mutex::new(pair.master),
+        pid,
+    });
+    host.insert(id.clone(), live);
+
+    let data_app = app.clone();
+    let data_id = id.clone();
+    thread::spawn(move || {
+        let mut buf = vec![0_u8; READ_CHUNK];
+        loop {
+            match reader.read(&mut buf) {
+                Ok(0) => break,
+                Ok(n) => {
+                    // ponytail: caps bridge traffic at 125 emits/s; use a timed
+                    // drain only if sustained PTY throughput becomes limiting.
+                    thread::sleep(PTY_COALESCE);
+                    emit_pty_data(&data_app, &data_id, &buf[..n]);
+                }
+                Err(_) => break,
+            }
+        }
+    });
+
+    let wait_app = app;
+    let wait_id = id;
+    thread::spawn(move || {
+        let code = child.wait().ok().map(|status| status.exit_code() as i32);
+        let emit = if let Some(host) = wait_app.try_state::<PtyHost>() {
+            host.remove_if_pid(&wait_id, pid).is_some()
+        } else {
+            false
+        };
+        if emit {
+            let _ = wait_app.emit(EXIT_EVENT, PtyExit { id: wait_id, code });
+        }
+    });
+
+    Ok(())
+}
+
 fn working_dir(cwd: &str) -> std::path::PathBuf {
     let path = expand_home(cwd);
     if path.is_dir() {
@@ -342,26 +449,40 @@ fn working_dir(cwd: &str) -> std::path::PathBuf {
     dirs_home().map(std::path::PathBuf::from).unwrap_or(path)
 }
 
-#[cfg(unix)]
 fn default_shell() -> (String, Vec<String>) {
-    let shell = std::env::var("SHELL").unwrap_or_else(|_| {
-        if cfg!(target_os = "macos") {
-            "/bin/zsh".into()
-        } else {
-            "/bin/bash".into()
+    #[cfg(windows)]
+    {
+        if let Ok(comspec) = std::env::var("COMSPEC") {
+            if !comspec.is_empty() {
+                return (comspec, Vec::new());
+            }
         }
-    });
-    let args = login_args(&shell)
-        .iter()
-        .map(|arg| (*arg).to_string())
-        .collect();
-    (shell, args)
+        ("powershell.exe".into(), vec!["-NoLogo".into()])
+    }
+    #[cfg(not(windows))]
+    {
+        let shell = std::env::var("SHELL")
+            .ok()
+            .filter(|shell| !shell.is_empty())
+            .unwrap_or_else(|| {
+                if cfg!(target_os = "macos") {
+                    "/bin/zsh".into()
+                } else {
+                    "/bin/bash".into()
+                }
+            });
+        let args = login_args(&shell)
+            .iter()
+            .map(|arg| (*arg).to_string())
+            .collect();
+        (shell, args)
+    }
 }
 
-#[cfg(unix)]
+#[cfg(not(windows))]
 fn login_args(shell: &str) -> &'static [&'static str] {
     match std::path::Path::new(shell)
-        .file_name()
+        .file_stem()
         .and_then(|name| name.to_str())
         .unwrap_or(shell)
     {
@@ -370,29 +491,6 @@ fn login_args(shell: &str) -> &'static [&'static str] {
     }
 }
 
-#[cfg(unix)]
-fn apply_path(cmd: &mut std::process::Command) {
-    let mut parts: Vec<String> = Vec::new();
-    if let Some(home) = dirs_home() {
-        parts.push(format!("{home}/.local/bin"));
-        parts.push(format!("{home}/.cargo/bin"));
-        parts.push(format!("{home}/.claude/local"));
-        parts.push(format!("{home}/.local/share/claude"));
-        parts.push(format!("{home}/.opencode/bin"));
-        parts.push(format!("{home}/.grok/bin"));
-        parts.push(format!("{home}/.npm-global/bin"));
-    }
-    parts.push("/opt/homebrew/bin".into());
-    parts.push("/usr/local/bin".into());
-    parts.push("/usr/bin".into());
-    parts.push("/bin".into());
-    parts.push("/snap/bin".into());
-    if let Ok(existing) = std::env::var("PATH") {
-        parts.push(existing);
-    }
-    cmd.env("PATH", parts.join(":"));
-}
-
 fn terminate(pid: u32) {
     if pid == 0 || pid == 1 {
         return;
@@ -414,7 +512,17 @@ fn terminate(pid: u32) {
             }
         });
     }
-    #[cfg(not(unix))]
+    #[cfg(windows)]
+    {
+        let mut cmd = std::process::Command::new("taskkill");
+        crate::hide_window_console(&mut cmd);
+        let _ = cmd
+            .args(["/PID", &pid.to_string(), "/T", "/F"])
+            .stdout(std::process::Stdio::null())
+            .stderr(std::process::Stdio::null())
+            .status();
+    }
+    #[cfg(not(any(unix, windows)))]
     {
         let _ = pid;
     }
@@ -524,7 +632,6 @@ fn os_err(ctx: &str) -> String {
     format!("{ctx}: {}", std::io::Error::last_os_error())
 }
 
-#[cfg(unix)]
 fn emit_pty_data(app: &AppHandle, id: &str, bytes: &[u8]) {
     if bytes.is_empty() {
         return;
diff --git a/src-tauri/src/search.rs b/src-tauri/src/search.rs
index cc8880ad..089bb7ff 100644
--- a/src-tauri/src/search.rs
+++ b/src-tauri/src/search.rs
@@ -70,6 +70,7 @@ fn search_project_sync(options: &SearchOptions) -> Result<SearchResult, String>
 
 fn git_grep(root: &Path, options: &SearchOptions, query: &str) -> Option<SearchResult> {
     let mut cmd = Command::new("git");
+    crate::hide_window_console(&mut cmd);
     cmd.arg("-C").arg(root).arg("grep").arg("-z").arg("-n");
     if !options.case_sensitive {
         cmd.arg("-i");
@@ -134,7 +135,7 @@ fn git_grep(root: &Path, options: &SearchOptions, query: &str) -> Option<SearchR
             .and_then(|value| value.parse::<u32>().ok())
             .unwrap_or(1);
         let preview = String::from_utf8_lossy(preview_bytes).to_string();
-        let path = root.join(&relative).to_string_lossy().into_owned();
+        let path = crate::fs::path_to_js(&root.join(&relative));
         let column = match_column(
             &preview,
             query,
diff --git a/src-tauri/src/skills.rs b/src-tauri/src/skills.rs
index 846e210f..9539d905 100644
--- a/src-tauri/src/skills.rs
+++ b/src-tauri/src/skills.rs
@@ -302,7 +302,7 @@ fn scan_root(root: &Path, scope: &str, source: &str) -> Vec<DiscoveredSkill> {
         out.push(DiscoveredSkill {
             name,
             description,
-            path: skill_md.to_string_lossy().into_owned(),
+            path: crate::fs::path_to_js(&skill_md),
             scope: scope.to_string(),
             source: source.to_string(),
         });
diff --git a/src-tauri/src/window.rs b/src-tauri/src/window.rs
index 4e5119c4..b11f16c5 100644
--- a/src-tauri/src/window.rs
+++ b/src-tauri/src/window.rs
@@ -1,7 +1,9 @@
 use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
 
-#[cfg(target_os = "macos")]
+#[cfg(any(target_os = "macos", target_os = "windows"))]
 use tauri::window::Color;
+#[cfg(target_os = "windows")]
+use tauri::window::{Effect, EffectsBuilder};
 use tauri::{AppHandle, Emitter, Manager, WebviewWindow, WebviewWindowBuilder};
 
 static WINDOW_COUNTER: AtomicU32 = AtomicU32::new(1);
@@ -48,7 +50,12 @@ pub fn enable_window_glass(window: WebviewWindow) {
         let _ = window.set_background_color(Some(Color(0, 0, 0, 3)));
         crate::macos::enable_glass(&window);
     }
-    #[cfg(not(target_os = "macos"))]
+    #[cfg(target_os = "windows")]
+    {
+        let _ = window.set_background_color(Some(Color(0, 0, 0, 0)));
+        let _ = window.set_effects(EffectsBuilder::new().effect(Effect::Acrylic).build());
+    }
+    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
     {
         let _ = window;
     }
diff --git a/src-tauri/tauri.windows.conf.json b/src-tauri/tauri.windows.conf.json
new file mode 100644
index 00000000..470e90d6
--- /dev/null
+++ b/src-tauri/tauri.windows.conf.json
@@ -0,0 +1,34 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "app": {
+    "windows": [
+      {
+        "label": "main",
+        "title": "MonoCode",
+        "width": 1280,
+        "height": 800,
+        "minWidth": 800,
+        "minHeight": 520,
+        "decorations": false,
+        "transparent": true,
+        "backgroundColor": "#171717",
+        "backgroundThrottling": "throttle",
+        "shadow": true
+      }
+    ]
+  },
+  "bundle": {
+    "targets": [
+      "nsis"
+    ],
+    "createUpdaterArtifacts": false,
+    "category": "DeveloperTool",
+    "windows": {
+      "nsis": {
+        "installMode": "currentUser",
+        "sidebarImage": "icons/installer-sidebar.bmp"
+      }
+    },
+    "resources": null
+  }
+}
diff --git a/src/App.tsx b/src/App.tsx
index 3024d9e7..eaf4cc6a 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -23,7 +23,7 @@ import {
   type SidebarLayout,
   type SidebarTabId,
 } from "./lib/appearance";
-import { IS_MAC } from "./lib/platform";
+import { HAS_NATIVE_GLASS, IS_MAC } from "./lib/platform";
 import { runUpdateFlow } from "./lib/updater";
 import { displayAttachments, prepareAttachments } from "./lib/attachments";
 import { basename, notifyGitChanged, pickFolder, restoreSessionCheckout } from "./lib/fs";
@@ -4218,7 +4218,7 @@ export default function App({
   return (
     <div
       className={`flex h-full text-content ${
-        IS_MAC ? "bg-background-base/40" : "bg-background-base"
+        HAS_NATIVE_GLASS ? "bg-background-base/40" : "bg-background-base"
       }`}
     >
       <Sidebar
diff --git a/src/chrome/FileTree.tsx b/src/chrome/FileTree.tsx
index 18ac5027..dcbb1e68 100644
--- a/src/chrome/FileTree.tsx
+++ b/src/chrome/FileTree.tsx
@@ -50,7 +50,7 @@ import {
   type FsEntry,
 } from "../lib/fs";
 import { displayPath, parentPath, rebasePath } from "../lib/paths";
-import { IS_MAC, MOD } from "../lib/platform";
+import { IS_MAC, IS_WIN, MOD } from "../lib/platform";
 import type { GitStatusMap } from "../hooks/useGitFileStatuses";
 import { useProjectDiffStats } from "../hooks/useProjectDiffStats";
 import { ExplorerMenu, type ExplorerMenuItem } from "./ExplorerMenu";
@@ -82,7 +82,7 @@ type MenuState = { x: number; y: number; target: MenuTarget };
 
 const REVEAL_LABEL = IS_MAC
   ? "Reveal in Finder"
-  : typeof navigator !== "undefined" && /Win/.test(navigator.platform)
+  : IS_WIN
     ? "Reveal in File Explorer"
     : "Open Containing Folder";
 
diff --git a/src/chrome/FileTypeIcon.tsx b/src/chrome/FileTypeIcon.tsx
index b118fe7f..d55ecf8d 100644
--- a/src/chrome/FileTypeIcon.tsx
+++ b/src/chrome/FileTypeIcon.tsx
@@ -60,23 +60,16 @@ export function FileTypeIcon({
     );
   }
 
-  if (isDir) {
-    return (
-      <icons.FolderIcon
-        folderName={name}
-        isOpen={isOpen}
-        isRoot={isRoot}
-        size={size}
-        className="shrink-0"
-      />
-    );
-  }
+  const iconName = isDir
+    ? icons.getFolderIcon({ folderName: name, isOpen, isRoot })
+    : resolveFileIcon(icons, name);
 
   return (
-    <icons.MaterialIcon
-      name={resolveFileIcon(icons, name)}
-      size={size}
-      className="shrink-0"
+    <span
+      aria-hidden
+      className="material-icon inline-block shrink-0 align-middle"
+      style={{ width: size, height: size }}
+      dangerouslySetInnerHTML={{ __html: icons.getIconSvg(iconName) ?? "" }}
     />
   );
 }
diff --git a/src/chrome/ProjectRail.tsx b/src/chrome/ProjectRail.tsx
index 1fe7f6b1..fafe430a 100644
--- a/src/chrome/ProjectRail.tsx
+++ b/src/chrome/ProjectRail.tsx
@@ -29,7 +29,7 @@ import {
   saveProjectRailWidth,
 } from "../lib/appearance";
 import { basename, revealPath, type GitDiffStats } from "../lib/fs";
-import { IS_MAC, MOD } from "../lib/platform";
+import { IS_MAC, IS_WIN, MOD } from "../lib/platform";
 import { projectName } from "../lib/paths";
 import {
   collectRailProjects,
@@ -75,7 +75,7 @@ import type { SettingsSectionId } from "../lib/settings";
 
 const REVEAL_LABEL = IS_MAC
   ? "Reveal in Finder"
-  : typeof navigator !== "undefined" && /Win/.test(navigator.platform)
+  : IS_WIN
     ? "Reveal in File Explorer"
     : "Open Containing Folder";
 
diff --git a/src/index.css b/src/index.css
index c5ae0902..4f5dec4f 100644
--- a/src/index.css
+++ b/src/index.css
@@ -95,9 +95,9 @@ html:not(.is-mac) ::-webkit-scrollbar-corner {
   background: transparent;
 }
 
-html.is-mac,
-html.is-mac body,
-html.is-mac #root {
+html.has-native-glass,
+html.has-native-glass body,
+html.has-native-glass #root {
   background: transparent;
 }
 
@@ -109,7 +109,7 @@ html.theme-light .sidebar-glass {
   background: color-mix(in srgb, var(--color-background-base) 93%, black 7%);
 }
 
-html.is-mac .sidebar-glass {
+html.has-native-glass .sidebar-glass {
   background: hsl(
     var(--theme-hue) var(--theme-saturation) var(--background-lightness) /
       var(--sidebar-opacity)
@@ -143,7 +143,7 @@ html.is-mac .sidebar-glass {
   min-height: var(--transcript-viewport, 0px);
 }
 
-html.is-mac.glass-body .body-glass {
+html.has-native-glass.glass-body .body-glass {
   background: color-mix(
     in srgb,
     var(--color-background-base) calc(var(--sidebar-opacity) * 100%),
diff --git a/src/lib/appearance.ts b/src/lib/appearance.ts
index 047a9ecb..3517c58d 100644
--- a/src/lib/appearance.ts
+++ b/src/lib/appearance.ts
@@ -1,5 +1,5 @@
 import { invoke } from "@tauri-apps/api/core";
-import { IS_MAC } from "./platform";
+import { HAS_NATIVE_GLASS, IS_MAC } from "./platform";
 
 const THEME_HUE_KEY = "monocode.themeHue";
 const THEME_SATURATION_KEY = "monocode.themeSaturation";
@@ -169,6 +169,7 @@ export function applyThemeTint(hue: number, saturation: number) {
 
 export function initAppearance() {
   document.documentElement.classList.toggle("is-mac", IS_MAC);
+  document.documentElement.classList.toggle("has-native-glass", HAS_NATIVE_GLASS);
   applyThemeTint(loadThemeHue(), loadThemeSaturation());
   applyThemePreference(loadThemePreference());
   watchSystemColorScheme();
diff --git a/src/lib/fileIndex.ts b/src/lib/fileIndex.ts
index d08f224e..4c234766 100644
--- a/src/lib/fileIndex.ts
+++ b/src/lib/fileIndex.ts
@@ -1,6 +1,6 @@
 import { listProjectFiles, type ProjectFile } from "./fs";
 import { scorePath, type FuzzyHit } from "./fuzzy";
-import { resolveWorkspacePath } from "./paths";
+import { resolveWorkspacePath, slash } from "./paths";
 import { looksLikeProject } from "./recents";
 import { normalizeEditorPath } from "./search";
 
@@ -18,7 +18,7 @@ let epoch = 0;
 const recentsByCwd = new Map<string, string[]>();
 
 function normCwd(cwd: string): string {
-  return cwd.replace(/\/+$/, "") || "/";
+  return slash(cwd).replace(/\/+$/, "") || "/";
 }
 
 export function peekProjectFiles(cwd: string): ProjectFile[] | null {
diff --git a/src/lib/fs.ts b/src/lib/fs.ts
index 18af476b..1793511e 100644
--- a/src/lib/fs.ts
+++ b/src/lib/fs.ts
@@ -1,5 +1,6 @@
 import { invoke } from "@tauri-apps/api/core";
 import { open } from "@tauri-apps/plugin-dialog";
+import { slash } from "./paths";
 
 export type FsEntry = {
   name: string;
@@ -255,11 +256,11 @@ export function createPath(
   name: string,
   isDir: boolean,
 ): Promise<string> {
-  return invoke<string>("create_path", { parent, name, isDir });
+  return invoke<string>("create_path", { parent, name, isDir }).then(slash);
 }
 
 export function renamePath(path: string, name: string): Promise<string> {
-  return invoke<string>("rename_path", { path, name });
+  return invoke<string>("rename_path", { path, name }).then(slash);
 }
 
 export function deletePath(path: string): Promise<void> {
@@ -267,11 +268,11 @@ export function deletePath(path: string): Promise<void> {
 }
 
 export function copyPath(from: string, destParent: string): Promise<string> {
-  return invoke<string>("copy_path", { from, destParent });
+  return invoke<string>("copy_path", { from, destParent }).then(slash);
 }
 
 export function movePath(from: string, destParent: string): Promise<string> {
-  return invoke<string>("move_path", { from, destParent });
+  return invoke<string>("move_path", { from, destParent }).then(slash);
 }
 
 export function revealPath(path: string): Promise<void> {
@@ -288,7 +289,7 @@ export async function pickFolder(title = "Open project"): Promise<string | null>
     multiple: false,
     title,
   });
-  return typeof selected === "string" && selected ? selected : null;
+  return typeof selected === "string" && selected ? slash(selected) : null;
 }
 
 export async function pickFiles(title = "Attach files"): Promise<string[] | null> {
@@ -298,15 +299,17 @@ export async function pickFiles(title = "Attach files"): Promise<string[] | null
     title,
   });
   if (Array.isArray(selected)) {
-    const paths = selected.filter((path): path is string => Boolean(path));
+    const paths = selected
+      .filter((path): path is string => Boolean(path))
+      .map(slash);
     return paths.length > 0 ? paths : null;
   }
-  if (typeof selected === "string" && selected) return [selected];
+  if (typeof selected === "string" && selected) return [slash(selected)];
   return null;
 }
 
 export function cloneRepo(url: string, parent: string): Promise<string> {
-  return invoke<string>("clone_repo", { url, parent });
+  return invoke<string>("clone_repo", { url, parent }).then(slash);
 }
 
 export function readFilePreview(
@@ -341,7 +344,8 @@ export function writeTextFile(path: string, content: string): Promise<void> {
 
 /** Last path segment, or `/` for the filesystem root. */
 export function basename(path: string): string {
-  const trimmed = path.replace(/\/+$/, "") || "/";
+  const trimmed = slash(path).replace(/\/+$/, "") || "/";
+  if (/^[A-Za-z]:$/.test(trimmed)) return trimmed;
   const parts = trimmed.split("/").filter(Boolean);
   return parts[parts.length - 1] ?? trimmed;
 }
diff --git a/src/lib/paths.test.ts b/src/lib/paths.test.ts
new file mode 100644
index 00000000..ca35eeb1
--- /dev/null
+++ b/src/lib/paths.test.ts
@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import {
+  displayPath,
+  isEqualOrInside,
+  joinPath,
+  parentPath,
+  prettyCwd,
+  projectName,
+  rebasePath,
+  slash,
+} from "./paths";
+
+describe("slash", () => {
+  it("normalizes Windows separators", () => {
+    expect(slash("C:\\Users\\me\\code")).toBe("C:/Users/me/code");
+  });
+});
+
+describe("prettyCwd", () => {
+  it("collapses unix and Windows home prefixes", () => {
+    expect(prettyCwd("/Users/me")).toBe("~");
+    expect(prettyCwd("/Users/me/code")).toBe("~/code");
+    expect(prettyCwd("C:\\Users\\me")).toBe("~");
+    expect(prettyCwd("C:/Users/me/code/app")).toBe("~/code/app");
+  });
+});
+
+describe("parentPath and joinPath", () => {
+  it("walks Windows drive paths", () => {
+    expect(parentPath("C:/Users/me/code")).toBe("C:/Users/me");
+    expect(parentPath("C:/Users")).toBe("C:/");
+    expect(parentPath("C:/")).toBe("C:/");
+    expect(joinPath("C:/Users/me", "code/app")).toBe("C:/Users/me/code/app");
+    expect(joinPath("C:/Users/me/code", "..")).toBe("C:/Users/me");
+    expect(joinPath("C:/", "Users")).toBe("C:/Users");
+  });
+});
+
+describe("path relations", () => {
+  it("treats backslash and slash as the same path", () => {
+    expect(isEqualOrInside("C:\\Users\\me\\app\\src", "C:/Users/me/app")).toBe(
+      true,
+    );
+    expect(isEqualOrInside("C:/Users/me", "C:/")).toBe(true);
+    expect(rebasePath("C:\\Users\\me\\app\\src\\a.ts", "C:/Users/me/app", "D:/x")).toBe(
+      "D:/x/src/a.ts",
+    );
+    expect(displayPath("C:\\Users\\me\\app\\src\\a.ts", "C:/Users/me/app")).toBe(
+      "src/a.ts",
+    );
+    expect(projectName("C:\\Users\\me\\app")).toBe("app");
+  });
+
+  it("compares Windows paths without case", () => {
+    expect(isEqualOrInside("c:/USERS/me/App/src", "C:/Users/ME/app")).toBe(true);
+    expect(rebasePath("c:/USERS/me/App/src/a.ts", "C:/Users/ME/app", "D:/x")).toBe(
+      "D:/x/src/a.ts",
+    );
+    expect(displayPath("c:/USERS/me/App/src/a.ts", "C:/Users/ME/app")).toBe(
+      "src/a.ts",
+    );
+  });
+});
diff --git a/src/lib/paths.ts b/src/lib/paths.ts
index 1f6874b5..257cd721 100644
--- a/src/lib/paths.ts
+++ b/src/lib/paths.ts
@@ -1,6 +1,22 @@
 /** Display path with home collapsed to `~`. */
+export function slash(path: string): string {
+  return path.replace(/\\/g, "/");
+}
+
+function trimSlash(path: string): string {
+  return slash(path).replace(/\/+$/, "") || "/";
+}
+
+/** Stable comparison key for Windows paths without changing their display case. */
+export function pathKey(path: string): string {
+  const normalized = trimSlash(path);
+  return /^[A-Za-z]:(?:\/|$)/.test(normalized) || normalized.startsWith("//")
+    ? normalized.toLowerCase()
+    : normalized;
+}
+
 export function prettyCwd(cwd: string): string {
-  const trimmed = cwd.replace(/\/+$/, "") || "/";
+  const trimmed = trimSlash(cwd);
   if (trimmed === "~") return "~";
 
   const parts = trimmed.split("/").filter(Boolean);
@@ -8,29 +24,53 @@ export function prettyCwd(cwd: string): string {
     const rest = parts.slice(2).join("/");
     return rest ? `~/${rest}` : "~";
   }
+  if (
+    parts.length >= 3 &&
+    /^[A-Za-z]:$/.test(parts[0]) &&
+    parts[1] === "Users"
+  ) {
+    const rest = parts.slice(3).join("/");
+    return rest ? `~/${rest}` : "~";
+  }
   return trimmed;
 }
 
 export function parentPath(path: string): string {
-  const trimmed = path.replace(/\/+$/, "") || "/";
+  const trimmed = trimSlash(path);
+  if (/^[A-Za-z]:$/.test(trimmed)) return `${trimmed}/`;
   const i = trimmed.lastIndexOf("/");
   if (i <= 0) return "/";
-  return trimmed.slice(0, i);
+  const parent = trimmed.slice(0, i);
+  if (/^[A-Za-z]:$/.test(parent)) return `${parent}/`;
+  return parent;
 }
 
 export function rebasePath(path: string, from: string, to: string): string {
-  if (path === from) return to;
-  if (path.startsWith(`${from}/`)) return `${to}${path.slice(from.length)}`;
-  return path;
+  const normalized = trimSlash(path);
+  const source = trimSlash(from);
+  const dest = trimSlash(to);
+  const key = pathKey(normalized);
+  const sourceKey = pathKey(source);
+  if (key === sourceKey) return dest;
+  if (key.startsWith(`${sourceKey}/`)) {
+    return `${dest}${normalized.slice(source.length)}`;
+  }
+  return slash(path);
 }
 
 export function isEqualOrInside(path: string, root: string): boolean {
-  return path === root || path.startsWith(`${root}/`);
+  const normalized = trimSlash(path);
+  const base = trimSlash(root);
+  const key = pathKey(normalized);
+  const baseKey = pathKey(base);
+  return key === baseKey || key.startsWith(`${baseKey}/`);
 }
 
 export function joinPath(parent: string, relative: string): string {
-  const base = parent.replace(/\/+$/, "") || "/";
-  const parts = relative.split(/[/\\]/).filter((part) => part && part !== ".");
+  const base = trimSlash(parent);
+  const parts = relative
+    .split(/[/\\]/)
+    .filter((part) => part && part !== ".");
   let out = base;
   for (const part of parts) {
     if (part === "..") {
@@ -58,7 +98,7 @@ export function resolveWorkspacePath(
     }
   }
 
-  value = value.replace(/\\/g, "/").replace(/(?::\d+(?::\d+)?|#L\d+(?:-L\d+)?)$/, "");
+  value = slash(value).replace(/(?::\d+(?::\d+)?|#L\d+(?:-L\d+)?)$/, "");
   if (!value || value === "." || value.startsWith("#") || value.startsWith("?") || value.includes("://")) {
     return undefined;
   }
@@ -84,14 +124,16 @@ export function prettyParent(path: string): string {
 
 /** Path relative to cwd when it lives under the project, otherwise unchanged. */
 export function displayPath(path: string, cwd?: string): string {
-  const normalized = path.replace(/\\/g, "/").replace(/\/+$/, "");
-  const base = cwd?.replace(/\\/g, "/").replace(/\/+$/, "");
+  const normalized = trimSlash(path);
+  const base = cwd ? trimSlash(cwd) : undefined;
   if (base && base !== "~") {
-    if (normalized === base) {
+    const key = pathKey(normalized);
+    const baseKey = pathKey(base);
+    if (key === baseKey) {
       return normalized.split("/").filter(Boolean).pop() || normalized;
     }
     const prefix = `${base}/`;
-    if (normalized.startsWith(prefix)) {
+    if (key.startsWith(`${baseKey}/`)) {
       return normalized.slice(prefix.length);
     }
   }
@@ -101,7 +143,8 @@ export function displayPath(path: string, cwd?: string): string {
 /** Folder name for tab labels — `~` when the cwd is home. */
 export function projectName(cwd: string): string {
   if (!cwd || prettyCwd(cwd) === "~") return "~";
-  const trimmed = cwd.replace(/\/+$/, "") || "/";
+  const trimmed = trimSlash(cwd);
+  if (/^[A-Za-z]:$/.test(trimmed)) return trimmed;
   const parts = trimmed.split("/").filter(Boolean);
   return parts[parts.length - 1] ?? trimmed;
 }
diff --git a/src/lib/platform.ts b/src/lib/platform.ts
index 3747d89b..c40cd09c 100644
--- a/src/lib/platform.ts
+++ b/src/lib/platform.ts
@@ -2,6 +2,12 @@ export const IS_MAC =
   typeof navigator !== "undefined" &&
   /Mac|iPhone|iPad/.test(navigator.platform);
 
+export const IS_WIN =
+  typeof navigator !== "undefined" && /Win/i.test(navigator.platform);
+
+/** Native desktop blur: macOS vibrancy and Windows acrylic. Linux stays opaque. */
+export const HAS_NATIVE_GLASS = IS_MAC || IS_WIN;
+
 export const MOD = IS_MAC ? "⌘" : "Ctrl+";
 export const ALT = IS_MAC ? "⌥" : "Alt+";
 export const SHIFT = IS_MAC ? "⇧" : "Shift+";
diff --git a/src/lib/recents.test.ts b/src/lib/recents.test.ts
index 14099651..e1e9c962 100644
--- a/src/lib/recents.test.ts
+++ b/src/lib/recents.test.ts
@@ -46,12 +46,16 @@ describe("looksLikeProject", () => {
     expect(looksLikeProject("/Users/me")).toBe(false);
     expect(looksLikeProject("/Users/me/")).toBe(false);
     expect(looksLikeProject("/home/me")).toBe(false);
+    expect(looksLikeProject("C:/Users/me")).toBe(false);
+    expect(looksLikeProject("C:\\Users\\me")).toBe(false);
     expect(looksLikeProject("~")).toBe(false);
   });
 
   it("rejects system roots and app bundles", () => {
     expect(looksLikeProject("/")).toBe(false);
     expect(looksLikeProject("")).toBe(false);
+    expect(looksLikeProject("C:/")).toBe(false);
+    expect(looksLikeProject("C:")).toBe(false);
     expect(looksLikeProject("/Applications/Some.app/Contents")).toBe(false);
   });
 
@@ -59,6 +63,7 @@ describe("looksLikeProject", () => {
     expect(looksLikeProject("/Users/me/code/app")).toBe(true);
     expect(looksLikeProject("/Users/me/Desktop")).toBe(true);
     expect(looksLikeProject("/tmp/scratch")).toBe(true);
+    expect(looksLikeProject("C:/Users/me/code/app")).toBe(true);
   });
 });
 
@@ -144,6 +149,14 @@ describe("forgetProject", () => {
     expect(loadProjectRailOrder()).toEqual(["/tmp/keep"]);
     expect(loadPinnedProjects()).toEqual([]);
   });
+
+  it("treats differently-cased Windows paths as one project", () => {
+    rememberProject("C:/Users/me/Code/App");
+    rememberProject("c:/users/ME/code/app");
+    expect(loadRecents().map((item) => item.path)).toEqual([
+      "c:/users/ME/code/app",
+    ]);
+  });
 });
 
 describe("archiveProject", () => {
@@ -188,27 +201,3 @@ describe("archiveProject", () => {
     expect(loadRecents()).toEqual([]);
   });
 });
-
-
-describe("looksLikeProject", () => {
-  it("rejects the home directory so it is never indexed", () => {
-    // Home arrives expanded from `default_cwd`. Walking it reaches
-    // ~/Library, which makes macOS prompt for access to other apps' data.
-    expect(looksLikeProject("/Users/me")).toBe(false);
-    expect(looksLikeProject("/Users/me/")).toBe(false);
-    expect(looksLikeProject("/home/me")).toBe(false);
-    expect(looksLikeProject("~")).toBe(false);
-  });
-
-  it("rejects system roots and app bundles", () => {
-    expect(looksLikeProject("/")).toBe(false);
-    expect(looksLikeProject("")).toBe(false);
-    expect(looksLikeProject("/Applications/Some.app/Contents")).toBe(false);
-  });
-
-  it("accepts real projects, including ones directly under home", () => {
-    expect(looksLikeProject("/Users/me/code/app")).toBe(true);
-    expect(looksLikeProject("/Users/me/Desktop")).toBe(true);
-    expect(looksLikeProject("/tmp/scratch")).toBe(true);
-  });
-});
diff --git a/src/lib/recents.ts b/src/lib/recents.ts
index 8afaac3e..df9576e0 100644
--- a/src/lib/recents.ts
+++ b/src/lib/recents.ts
@@ -1,4 +1,4 @@
-import { prettyCwd } from "./paths";
+import { pathKey, prettyCwd, slash } from "./paths";
 
 const KEY = "monocode.recentProjects";
 const RAIL_ORDER_KEY = "monocode.projectRailOrder";
@@ -18,7 +18,7 @@ export type ArchivedProject = {
 };
 
 export function normalizeProjectPath(path: string): string {
-  return path.replace(/\/+$/, "") || "/";
+  return slash(path).replace(/\/+$/, "") || "/";
 }
 
 function normalize(path: string): string {
@@ -26,7 +26,7 @@ function normalize(path: string): string {
 }
 
 export function sameProjectPath(a: string, b: string): boolean {
-  return normalizeProjectPath(a) === normalizeProjectPath(b);
+  return pathKey(a) === pathKey(b);
 }
 
 export function loadRecents(): RecentProject[] {
@@ -64,7 +64,7 @@ export function rememberProject(path: string): RecentProject[] {
   const normalized = normalize(path);
   if (normalized === "~") return loadRecents();
   dropArchived(normalized);
-  const prev = loadRecents().filter((p) => p.path !== normalized);
+  const prev = loadRecents().filter((p) => !sameProjectPath(p.path, normalized));
   const next = [{ path: normalized, openedAt: Date.now() }, ...prev].slice(
     0,
     MAX,
@@ -76,13 +76,13 @@ export function rememberProject(path: string): RecentProject[] {
 /** Drops a project from the rail: its recent entry, saved order slot, and pin. */
 function dropFromRail(path: string): RecentProject[] {
   const normalized = normalize(path);
-  const next = loadRecents().filter((item) => item.path !== normalized);
+  const next = loadRecents().filter((item) => !sameProjectPath(item.path, normalized));
   save(next);
   saveProjectRailOrder(
-    loadProjectRailOrder().filter((entry) => entry !== normalized),
+    loadProjectRailOrder().filter((entry) => !sameProjectPath(entry, normalized)),
   );
   savePinnedProjects(
-    loadPinnedProjects().filter((entry) => entry !== normalized),
+    loadPinnedProjects().filter((entry) => !sameProjectPath(entry, normalized)),
   );
   return next;
 }
@@ -98,7 +98,9 @@ export function archiveProject(path: string): RecentProject[] {
   const normalized = normalize(path);
   if (!looksLikeProject(normalized)) return loadRecents();
   const recents = dropFromRail(normalized);
-  const rest = loadArchivedProjects().filter((item) => item.path !== normalized);
+  const rest = loadArchivedProjects().filter(
+    (item) => !sameProjectPath(item.path, normalized),
+  );
   saveArchived([{ path: normalized, archivedAt: Date.now() }, ...rest]);
   return recents;
 }
@@ -116,8 +118,9 @@ export function loadArchivedProjects(): ArchivedProject[] {
       const rec = item as { path?: unknown; archivedAt?: unknown };
       if (typeof rec.path !== "string" || !rec.path) continue;
       const path = normalize(rec.path);
-      if (seen.has(path) || !looksLikeProject(path)) continue;
-      seen.add(path);
+      const key = pathKey(path);
+      if (seen.has(key) || !looksLikeProject(path)) continue;
+      seen.add(key);
       const archivedAt =
         typeof rec.archivedAt === "number" && Number.isFinite(rec.archivedAt)
           ? rec.archivedAt
@@ -150,7 +153,7 @@ function saveArchived(next: ArchivedProject[]) {
 function dropArchived(path: string) {
   const normalized = normalize(path);
   const prev = loadArchivedProjects();
-  const next = prev.filter((item) => item.path !== normalized);
+  const next = prev.filter((item) => !sameProjectPath(item.path, normalized));
   if (next.length === prev.length) return;
   saveArchived(next);
 }
@@ -179,8 +182,9 @@ function readPathList(key: string): string[] {
     for (const item of parsed) {
       if (typeof item !== "string" || !item) continue;
       const path = normalize(item);
-      if (seen.has(path)) continue;
-      seen.add(path);
+      const normalized = pathKey(path);
+      if (seen.has(normalized)) continue;
+      seen.add(normalized);
       out.push(path);
     }
     return out;
@@ -222,12 +226,13 @@ export function collectRailProjects(
   for (const item of recents) {
     if (!looksLikeProject(item.path)) continue;
     const path = normalize(item.path);
-    map.set(path, { path, openedAt: item.openedAt });
+    map.set(pathKey(path), { path, openedAt: item.openedAt });
   }
   if (currentCwd && looksLikeProject(currentCwd)) {
     const path = normalize(currentCwd);
-    if (!map.has(path)) {
-      map.set(path, { path, openedAt: Date.now() });
+    const key = pathKey(path);
+    if (!map.has(key)) {
+      map.set(key, { path, openedAt: Date.now() });
     }
   }
   return map;
@@ -238,21 +243,19 @@ export function syncProjectRailOrder(
   order: string[],
   projects: Map<string, RecentProject>,
 ): string[] {
-  const paths = new Set(projects.keys());
   const next: string[] = [];
   const seen = new Set<string>();
   for (const path of order) {
-    const normalized = normalize(path);
-    if (!paths.has(normalized) || seen.has(normalized)) continue;
-    seen.add(normalized);
-    next.push(normalized);
+    const key = pathKey(path);
+    const project = projects.get(key);
+    if (!project || seen.has(key)) continue;
+    seen.add(key);
+    next.push(project.path);
   }
-  const newcomers = [...paths]
-    .filter((path) => !seen.has(path))
-    .sort(
-      (a, b) =>
-        (projects.get(b)?.openedAt ?? 0) - (projects.get(a)?.openedAt ?? 0),
-    );
+  const newcomers = [...projects.entries()]
+    .filter(([key]) => !seen.has(key))
+    .sort(([, a], [, b]) => b.openedAt - a.openedAt)
+    .map(([, project]) => project.path);
   return [...next, ...newcomers];
 }
 
@@ -264,13 +267,14 @@ export function projectRailSections(
 ): ProjectRailSections {
   const projects = collectRailProjects(recents, currentCwd);
   const syncedOrder = syncProjectRailOrder(order, projects);
-  const pinnedSet = new Set(pinnedPaths.map(normalize));
+  const pinnedSet = new Set(pinnedPaths.map(pathKey));
   const pinned: RecentProject[] = [];
   const unpinned: RecentProject[] = [];
   for (const path of syncedOrder) {
-    const item = projects.get(path);
+    const key = pathKey(path);
+    const item = projects.get(key);
     if (!item) continue;
-    if (pinnedSet.has(path)) pinned.push(item);
+    if (pinnedSet.has(key)) pinned.push(item);
     else unpinned.push(item);
   }
   return { pinned, projects: unpinned };
@@ -295,9 +299,11 @@ export function projectRailItems(
 /** True if this looks like a user project, not an app bundle or system root. */
 export function looksLikeProject(path: string): boolean {
   if (!path || path === "/" || path === "~") return false;
+  const normalized = path.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+  if (/^[A-Za-z]:$/.test(normalized) || normalized === "/") return false;
   // Home itself arrives expanded (`/Users/me`), so the `~` check above misses
   // it. Indexing it walks `~/Library`, which trips the OS consent prompt.
   if (prettyCwd(path) === "~") return false;
-  if (path.includes(".app/")) return false;
+  if (path.includes(".app/") || path.includes(".app\\")) return false;
   return true;
 }
diff --git a/src/lib/search.ts b/src/lib/search.ts
index 7dde5548..9d62e1a2 100644
--- a/src/lib/search.ts
+++ b/src/lib/search.ts
@@ -1,4 +1,5 @@
 import { invoke } from "@tauri-apps/api/core";
+import { pathKey } from "./paths";
 
 export type ProjectSearchMatch = {
   path: string;
@@ -40,7 +41,7 @@ export function normalizeEditorPath(path: string): string {
 }
 
 export function editorPathsEqual(a: string, b: string): boolean {
-  return normalizeEditorPath(a) === normalizeEditorPath(b);
+  return pathKey(a) === pathKey(b);
 }
 
 export function searchProject(
diff --git a/src/surfaces/TerminalView.tsx b/src/surfaces/TerminalView.tsx
index 5f677eb4..ef4e17fc 100644
--- a/src/surfaces/TerminalView.tsx
+++ b/src/surfaces/TerminalView.tsx
@@ -85,9 +85,7 @@ function terminalTheme(light: boolean) {
     foreground: cssColor("var(--color-content)", light ? "#2e2e2e" : "#e8eef2"),
     cursor: cssColor("var(--color-accent)", light ? "#4078f2" : "#4da3f5"),
     cursorAccent: light ? "#ffffff" : "#000000",
-    selectionBackground: light
-      ? "rgba(0,0,0,0.18)"
-      : "rgba(255,255,255,0.18)",
+    selectionBackground: light ? "rgba(0,0,0,0.18)" : "rgba(255,255,255,0.18)",
     selectionInactiveBackground: light
       ? "rgba(0,0,0,0.08)"
       : "rgba(255,255,255,0.08)",
@@ -197,13 +195,34 @@ export function TerminalView({ id, cwd, active, onMetaChange }: Props) {
       },
     );
 
+    const starting = spawnPty(id, cwd, term.cols, term.rows)
+      .then(() => {
+        if (!closed) spawned.current = true;
+      })
+      .catch((error) => {
+        spawned.current = false;
+        if (!closed) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          term.writeln(`\x1b[31m${message}\x1b[0m`);
+        }
+        throw error;
+      });
+    void starting.catch(() => undefined);
+
     const dataSub = term.onData((data) => {
-      void writePty(id, data);
+      void starting
+        .then(() => (closed ? undefined : writePty(id, data)))
+        .catch(() => undefined);
     });
 
     const replyOsc = (code: 10 | 11 | 12, hex: string) => {
       const reply = oscColorReply(code, hex);
-      if (reply) void writePty(id, reply);
+      if (reply) {
+        void starting
+          .then(() => (closed ? undefined : writePty(id, reply)))
+          .catch(() => undefined);
+      }
       return true;
     };
     const oscFg = term.parser.registerOscHandler(10, (data) =>
@@ -253,19 +272,12 @@ export function TerminalView({ id, cwd, active, onMetaChange }: Props) {
       if (cols === lastCols && rows === lastRows) return;
       lastCols = cols;
       lastRows = rows;
-      if (!spawned.current) {
-        spawned.current = true;
-        void spawnPty(id, cwd, cols, rows).catch((error) => {
-          spawned.current = false;
+      void starting
+        .then(() => (closed ? undefined : resizePty(id, cols, rows)))
+        .catch(() => {
           lastCols = 0;
           lastRows = 0;
-          const message =
-            error instanceof Error ? error.message : String(error);
-          term.writeln(`\x1b[31m${message}\x1b[0m`);
         });
-        return;
-      }
-      void resizePty(id, cols, rows);
     };
 
     const schedule = () => {
@@ -303,7 +315,7 @@ export function TerminalView({ id, cwd, active, onMetaChange }: Props) {
       renderSub.dispose();
       bufferSub.dispose();
       unsubscribe();
-      void killPty(id);
+      void starting.catch(() => undefined).then(() => killPty(id));
       term.dispose();
       termRef.current = null;
       spawned.current = false;

From b9837d8f75388d6b810fc8dabdc1f75637fb6a0c Mon Sep 17 00:00:00 2001
From: Looped <nonlooped@gmail.com>
Date: Wed, 2 Sep 2026 02:13:19 +0300
Subject: [PATCH 2/6] Fix WebView2 loader packaging on Windows

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index 0f74066b..351502d8 100644
--- a/package.json
+++ b/package.json
@@ -18,7 +18,7 @@
     "tauri:stable": "tauri dev --no-watch --config src-tauri/tauri.stable.conf.json",
     "setup:linux:deb": "bash scripts/install-linux-deps-debian.sh",
     "build:linux": "tauri build --bundles deb,appimage",
-    "build:windows": "tauri build --bundles nsis"
+    "build:windows": "set \"RUSTUP_TOOLCHAIN=stable-x86_64-pc-windows-msvc\" && tauri build --bundles nsis"
   },
   "dependencies": {
     "@codemirror/lang-css": "^6.3.1",

From 9a7791dc82c381937098b40a7ef8ee0e6c3155f7 Mon Sep 17 00:00:00 2001
From: Looped <nonlooped@gmail.com>
Date: Fri, 4 Sep 2026 18:23:00 +0300
Subject: [PATCH 3/6] Fix Windows integration after upstream sync

---
 src-tauri/src/checkpoint.rs | 10 +++++++---
 src-tauri/src/fs.rs         |  8 +++++---
 src/App.tsx                 |  5 +++++
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/src-tauri/src/checkpoint.rs b/src-tauri/src/checkpoint.rs
index accc4971..331427fb 100644
--- a/src-tauri/src/checkpoint.rs
+++ b/src-tauri/src/checkpoint.rs
@@ -247,7 +247,7 @@ impl CheckpointStore {
             .map(|stats| stats.status.clone())
             .unwrap_or_else(|| "modified".into());
         Ok(CheckpointFileDiff {
-            path: root.join(&relative).to_string_lossy().into_owned(),
+            path: path_to_js(&root.join(&relative)),
             relative,
             status,
             original,
@@ -719,7 +719,7 @@ fn describe_change(
 ) -> CheckpointFile {
     if let Some((status, additions, deletions)) = session_change {
         return CheckpointFile {
-            path: root.join(relative).to_string_lossy().into_owned(),
+            path: path_to_js(&root.join(relative)),
             relative: relative.to_string(),
             status,
             additions,
@@ -775,7 +775,9 @@ fn calculate_session_stats(dir: &Path, manifest: &Manifest, relative: &str) -> O
 }
 
 fn diff_numstat(before: &Path, after: &Path) -> Option<(i64, i64)> {
-    let output = Command::new("git")
+    let mut cmd = Command::new("git");
+    crate::hide_window_console(&mut cmd);
+    let output = cmd
         .args(["diff", "--no-index", "--no-ext-diff", "--numstat", "--"])
         .arg(before)
         .arg(after)
@@ -1397,10 +1399,12 @@ mod tests {
         assert_eq!(status.files[0].deletions, 0);
         assert!(status.files[0].exact);
         assert!(status.files[0].undoable);
+        assert_eq!(status.files[0].path, path_to_js(&repo.0.join("app.ts")));
 
         let diff = store.file_diff("s1", &cwd, "app.ts").unwrap();
         assert_eq!(diff.original, "user-one\nuser-two\n");
         assert_eq!(diff.current, "user-one\nuser-two\nagent\n");
+        assert_eq!(diff.path, path_to_js(&repo.0.join("app.ts")));
 
         // Review remains the captured session result, not a later shared
         // working-tree state.
diff --git a/src-tauri/src/fs.rs b/src-tauri/src/fs.rs
index d2c2a1ea..513b2546 100644
--- a/src-tauri/src/fs.rs
+++ b/src-tauri/src/fs.rs
@@ -1292,7 +1292,7 @@ fn git_commit_files_for(root: &Path, sha: &str) -> Result<Vec<GitChangedFile>, S
         seen.insert(relative.clone());
         let status = statuses.get(&relative).copied().unwrap_or("modified");
         out.push(GitChangedFile {
-            path: root.join(&relative).to_string_lossy().into_owned(),
+            path: path_to_js(&root.join(&relative)),
             relative,
             status: status.to_string(),
             additions: acc.additions,
@@ -1306,7 +1306,7 @@ fn git_commit_files_for(root: &Path, sha: &str) -> Result<Vec<GitChangedFile>, S
             continue;
         }
         out.push(GitChangedFile {
-            path: root.join(&relative).to_string_lossy().into_owned(),
+            path: path_to_js(&root.join(&relative)),
             relative,
             status: status.to_string(),
             additions: 0,
@@ -1350,7 +1350,7 @@ fn git_commit_file_diff_for(root: &Path, sha: &str, relative: &str) -> Result<Gi
         )
     };
     Ok(GitFileDiff {
-        path: root.join(&relative).to_string_lossy().into_owned(),
+        path: path_to_js(&root.join(&relative)),
         relative,
         status: status.to_string(),
         original,
@@ -4415,11 +4415,13 @@ mod tests {
         assert_eq!(files.len(), 1);
         assert_eq!(files[0].relative, "a.txt");
         assert_eq!(files[0].status, "modified");
+        assert_eq!(files[0].path, path_to_js(&dir.0.join("a.txt")));
 
         let diff = git_commit_file_diff_for(&dir.0, sha, "a.txt").unwrap();
         assert_eq!(diff.original, "alpha\n");
         assert_eq!(diff.current, "beta\n");
         assert_eq!(diff.status, "modified");
+        assert_eq!(diff.path, path_to_js(&dir.0.join("a.txt")));
     }
 
     #[test]
diff --git a/src/App.tsx b/src/App.tsx
index bdf170fd..4218545d 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -338,6 +338,7 @@ import {
 import type { InstalledUpdate } from "./lib/updateNotice";
 import {
   bindResumedSessions,
+  handleQuitRequested,
   hasInFlightSessions,
   hideCurrentWindow,
   closeCurrentWindow,
@@ -978,6 +979,10 @@ export default function App({
         event.preventDefault();
         if (hasInFlightSessions(sessionsRef.current)) {
           flushHarnessEvents();
+          if (!IS_MAC) {
+            void handleQuitRequested();
+            return;
+          }
           void persistLiveTranscripts(sessionsRef.current);
           void hideCurrentWindow();
           return;

From e2b048d615894e6ceab9146924121e2ed5eb1f85 Mon Sep 17 00:00:00 2001
From: Looped <nonlooped@gmail.com>
Date: Sat, 5 Sep 2026 15:48:07 +0300
Subject: [PATCH 4/6] Fix Windows process supervision and review regressions

---
 Cargo.lock                   |   1 +
 src-tauri/Cargo.toml         |   1 +
 src-tauri/src/fs.rs          |  34 +++--
 src-tauri/src/harness.rs     |  61 ++++++---
 src-tauri/src/lib.rs         |   4 +
 src-tauri/src/pty.rs         |   9 ++
 src-tauri/src/windows.rs     | 234 +++++++++++++++++++++++++++++++++++
 src/App.tsx                  |   4 +-
 src/lib/appLifecycle.test.ts |  74 +++++++++++
 src/lib/appLifecycle.ts      |  27 +++-
 src/lib/paths.test.ts        |   9 ++
 src/lib/paths.ts             |  15 ++-
 src/lib/recents.ts           |   2 +-
 src/lib/search.ts            |   4 +-
 14 files changed, 445 insertions(+), 34 deletions(-)
 create mode 100644 src-tauri/src/windows.rs
 create mode 100644 src/lib/appLifecycle.test.ts

diff --git a/Cargo.lock b/Cargo.lock
index 03ddbae8..4b8fe757 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2222,6 +2222,7 @@ dependencies = [
  "tauri-plugin-updater",
  "tauri-plugin-window-state",
  "ureq",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index df2d19b3..805b6e0e 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -31,6 +31,7 @@ libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
 portable-pty = "0.9"
+windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_System_JobObjects", "Win32_System_Threading", "Win32_System_LibraryLoader", "Win32_System_Diagnostics_ToolHelp"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 block2 = "0.6.2"
diff --git a/src-tauri/src/fs.rs b/src-tauri/src/fs.rs
index 513b2546..9409f436 100644
--- a/src-tauri/src/fs.rs
+++ b/src-tauri/src/fs.rs
@@ -111,7 +111,7 @@ fn git_ls_files(root: &Path) -> Option<Vec<ProjectFile>> {
         if rel.is_empty() {
             continue;
         }
-        let relative = String::from_utf8_lossy(rel).replace('\\', "/");
+        let relative = path_to_js(Path::new(String::from_utf8_lossy(rel).as_ref()));
         if relative.ends_with('/') || path_has_skipped_dir(&relative) {
             continue;
         }
@@ -947,7 +947,7 @@ fn normalize_diff_path(path: &str) -> String {
     } else {
         path
     };
-    path.replace('\\', "/")
+    path_to_js(Path::new(path))
 }
 
 const MAX_UNTRACKED_BYTES: u64 = 1024 * 1024;
@@ -963,7 +963,7 @@ fn add_untracked_map(root: &Path, files: &mut HashMap<String, FileAcc>) {
         if rel.is_empty() {
             continue;
         }
-        let relative = rel.replace('\\', "/");
+        let relative = path_to_js(Path::new(rel));
         let entry = files.entry(relative.clone()).or_default();
         entry.untracked = true;
         if entry.additions == 0 {
@@ -2971,7 +2971,7 @@ fn walk_project_files(root: &Path) -> Vec<ProjectFile> {
             let Ok(relative) = path.strip_prefix(root) else {
                 continue;
             };
-            let relative = relative.to_string_lossy().replace('\\', "/");
+            let relative = path_to_js(relative);
             files.push(ProjectFile {
                 name: name.to_string(),
                 path: path_to_js(&path),
@@ -3020,7 +3020,9 @@ fn skip_walk_dir_name(name: &str) -> bool {
 }
 
 fn path_has_skipped_dir(relative: &str) -> bool {
-    relative.split(['/', '\\']).any(skip_walk_dir_name)
+    relative
+        .split(std::path::is_separator)
+        .any(skip_walk_dir_name)
 }
 
 /// Directories the OS guards behind a consent prompt. macOS pops "would like to
@@ -3148,7 +3150,13 @@ pub(crate) fn expand_home(path: &str) -> PathBuf {
             .map(PathBuf::from)
             .unwrap_or_else(|| PathBuf::from(path));
     }
-    let rest = path.strip_prefix("~/").or_else(|| path.strip_prefix("~\\"));
+    let rest = path.strip_prefix("~/").or_else(|| {
+        if cfg!(windows) {
+            path.strip_prefix("~\\")
+        } else {
+            None
+        }
+    });
     if let Some(rest) = rest {
         if let Some(home) = dirs_home() {
             return PathBuf::from(home).join(rest);
@@ -3158,7 +3166,19 @@ pub(crate) fn expand_home(path: &str) -> PathBuf {
 }
 
 pub(crate) fn path_to_js(path: &Path) -> String {
-    path.to_string_lossy().replace('\\', "/")
+    let text = path.to_string_lossy();
+    if cfg!(windows) {
+        text.replace('\\', "/")
+    } else {
+        text.into_owned()
+    }
+}
+
+#[cfg(all(test, unix))]
+#[test]
+fn preserves_unix_backslash_filenames() {
+    assert_eq!(path_to_js(Path::new(r"/tmp/a\b.txt")), r"/tmp/a\b.txt");
+    assert_eq!(expand_home(r"~\literal"), PathBuf::from(r"~\literal"));
 }
 
 struct Ignore {
diff --git a/src-tauri/src/harness.rs b/src-tauri/src/harness.rs
index a0453c0b..b61fa28e 100644
--- a/src-tauri/src/harness.rs
+++ b/src-tauri/src/harness.rs
@@ -348,9 +348,8 @@ pub fn harness_spawn(
         .stderr(Stdio::piped());
     prepare_child(&mut cmd, &command);
 
-    let mut child = cmd
-        .spawn()
-        .map_err(|e| format!("Failed to start {command}: {e}"))?;
+    let mut child =
+        spawn_managed(&mut cmd).map_err(|e| format!("Failed to start {command}: {e}"))?;
     let pid = child.id();
 
     let stdin = child
@@ -697,9 +696,7 @@ fn exec_capture(command: &str, args: &[String], cwd: Option<&str>) -> Result<Str
         }
     }
 
-    let child = cmd
-        .spawn()
-        .map_err(|e| format!("Failed to run {command}: {e}"))?;
+    let child = spawn_managed(&mut cmd).map_err(|e| format!("Failed to run {command}: {e}"))?;
     let pid = child.id();
     let (tx, rx) = mpsc::channel();
     thread::spawn(move || {
@@ -765,6 +762,17 @@ fn isolate_child(cmd: &mut Command) {
     }
 }
 
+fn spawn_managed(cmd: &mut Command) -> std::io::Result<std::process::Child> {
+    #[cfg(windows)]
+    {
+        crate::windows::spawn_managed(cmd)
+    }
+    #[cfg(not(windows))]
+    {
+        cmd.spawn()
+    }
+}
+
 fn terminate(pid: u32) {
     terminate_after(pid, KILL_ESCALATE);
 }
@@ -1442,7 +1450,7 @@ fn help_mentions_rpc_mode(path: &Path) -> bool {
     // fails outright without a PATH that has node on it.
     apply_gui_env(&mut cmd);
     isolate_child(&mut cmd);
-    let Ok(child) = cmd.spawn() else {
+    let Ok(child) = spawn_managed(&mut cmd) else {
         return false;
     };
     let pid = child.id();
@@ -1533,7 +1541,7 @@ fn fx_help_mentions_acp(path: &Path) -> bool {
     // fails outright without a PATH that has node on it.
     apply_gui_env(&mut cmd);
     isolate_child(&mut cmd);
-    let Ok(child) = cmd.spawn() else {
+    let Ok(child) = spawn_managed(&mut cmd) else {
         return false;
     };
     let pid = child.id();
@@ -1594,7 +1602,7 @@ fn grok_help_mentions_agent(path: &Path) -> bool {
         .stderr(Stdio::piped());
     apply_gui_env(&mut cmd);
     isolate_child(&mut cmd);
-    let Ok(child) = cmd.spawn() else {
+    let Ok(child) = spawn_managed(&mut cmd) else {
         return false;
     };
     let pid = child.id();
@@ -1653,7 +1661,7 @@ fn is_cursor_agent(path: &Path) -> bool {
 /// Reads the cached PATH rather than spawning a shell per lookup: six
 /// resolvers each asking `command -v` meant six shell startups per probe.
 fn which_via_login_shell(name: &str) -> Option<PathBuf> {
-    which_in_path(&login_shell_path()?, name)
+    which_in_path(&gui_search_path(), name)
 }
 
 fn which_in_path(path: &str, name: &str) -> Option<PathBuf> {
@@ -1680,9 +1688,6 @@ fn first_binary_matching(
 }
 
 fn existing_binary(path: PathBuf) -> Option<PathBuf> {
-    if is_executable_file(&path) {
-        return Some(path);
-    }
     #[cfg(windows)]
     if path.extension().is_none() {
         for ext in ["exe", "cmd", "bat", "com"] {
@@ -1692,7 +1697,27 @@ fn existing_binary(path: PathBuf) -> Option<PathBuf> {
             }
         }
     }
-    None
+    is_executable_file(&path).then_some(path)
+}
+
+#[cfg(all(test, windows))]
+mod windows_launcher_tests {
+    use super::*;
+
+    #[test]
+    fn npm_shell_shim_does_not_hide_windows_launcher() {
+        let dir = std::env::temp_dir().join(format!("monocode-launcher-{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let bare = dir.join("agent");
+        let cmd = dir.join("agent.cmd");
+        std::fs::write(&bare, b"#!/bin/sh\n").unwrap();
+        std::fs::write(&cmd, b"@echo off\n").unwrap();
+        assert_eq!(existing_binary(bare.clone()), Some(cmd.clone()));
+        std::fs::remove_file(&cmd).unwrap();
+        assert_eq!(existing_binary(bare.clone()), None);
+        std::fs::remove_file(bare).unwrap();
+        std::fs::remove_dir(dir).unwrap();
+    }
 }
 
 fn binary_name_eq(path: &Path, expected: &str) -> bool {
@@ -1727,6 +1752,14 @@ fn is_executable_file(path: &Path) -> bool {
     #[cfg(not(unix))]
     {
         path.is_file()
+            && path
+                .extension()
+                .and_then(|ext| ext.to_str())
+                .is_some_and(|ext| {
+                    ["exe", "cmd", "bat", "com"]
+                        .iter()
+                        .any(|allowed| ext.eq_ignore_ascii_case(allowed))
+                })
     }
 }
 
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index 978fbe62..21cb8acf 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -18,6 +18,8 @@ mod session_store;
 mod skills;
 mod window;
 mod window_transfer;
+#[cfg(windows)]
+mod windows;
 
 // Phase 1 seam: spawn / kill harness children per MonoCode thread.
 // Adapters own the protocol; this host only supervises processes.
@@ -155,6 +157,8 @@ fn open_new_window(app: tauri::AppHandle) -> Result<(), String> {
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
 pub fn run() {
+    #[cfg(windows)]
+    windows::initialize().expect("Failed to initialize Windows process safety");
     let app = tauri::Builder::default()
         .plugin(tauri_plugin_process::init())
         .plugin(tauri_plugin_updater::Builder::new().build())
diff --git a/src-tauri/src/pty.rs b/src-tauri/src/pty.rs
index 3efd897a..8bbe9dff 100644
--- a/src-tauri/src/pty.rs
+++ b/src-tauri/src/pty.rs
@@ -400,6 +400,15 @@ fn spawn_windows(
         .slave
         .spawn_command(cmd)
         .map_err(|err| format!("Failed to start {shell}: {err}"))?;
+    let registered = child
+        .as_raw_handle()
+        .ok_or_else(|| std::io::Error::other("Terminal has no process handle"))
+        .and_then(crate::windows::assign_child);
+    if let Err(err) = registered {
+        let _ = child.kill();
+        let _ = child.wait();
+        return Err(format!("Failed to supervise terminal: {err}"));
+    }
     let pid = child.process_id().unwrap_or(0);
     let mut reader = pair
         .master
diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rs
new file mode 100644
index 00000000..195b73ae
--- /dev/null
+++ b/src-tauri/src/windows.rs
@@ -0,0 +1,234 @@
+use std::io;
+use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
+use std::sync::OnceLock;
+use windows_sys::Win32::System::{
+    JobObjects::{
+        AssignProcessToJobObject, CreateJobObjectW, JobObjectExtendedLimitInformation,
+        SetInformationJobObject, JOBOBJECT_EXTENDED_LIMIT_INFORMATION,
+        JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE,
+    },
+    LibraryLoader::{
+        SetDefaultDllDirectories, LOAD_LIBRARY_SEARCH_APPLICATION_DIR, LOAD_LIBRARY_SEARCH_SYSTEM32,
+    },
+};
+
+static MANAGED_JOB: OnceLock<Result<OwnedHandle, i32>> = OnceLock::new();
+
+/// Restrict DLL lookup before the first PTY is opened. MonoCode itself stays
+/// outside the job so relaunches and external applications do not inherit it.
+pub(crate) fn initialize() -> io::Result<()> {
+    unsafe {
+        if SetDefaultDllDirectories(
+            LOAD_LIBRARY_SEARCH_APPLICATION_DIR | LOAD_LIBRARY_SEARCH_SYSTEM32,
+        ) == 0
+        {
+            return Err(io::Error::last_os_error());
+        }
+    }
+    managed_job().map(|_| ())
+}
+
+fn managed_job() -> io::Result<&'static OwnedHandle> {
+    MANAGED_JOB
+        .get_or_init(|| create_job().map_err(|err| err.raw_os_error().unwrap_or(1)))
+        .as_ref()
+        .map_err(|code| io::Error::from_raw_os_error(*code))
+}
+
+fn create_job() -> io::Result<OwnedHandle> {
+    unsafe {
+        let raw = CreateJobObjectW(std::ptr::null(), std::ptr::null());
+        if raw.is_null() {
+            return Err(io::Error::last_os_error());
+        }
+        let job = OwnedHandle::from_raw_handle(raw);
+        let mut limits: JOBOBJECT_EXTENDED_LIMIT_INFORMATION = std::mem::zeroed();
+        limits.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE;
+        if SetInformationJobObject(
+            job.as_raw_handle(),
+            JobObjectExtendedLimitInformation,
+            &limits as *const _ as *const _,
+            std::mem::size_of_val(&limits) as u32,
+        ) == 0
+        {
+            return Err(io::Error::last_os_error());
+        }
+        Ok(job)
+    }
+}
+
+/// The app owns the only job handle. OS handle cleanup kills registered trees
+/// after a crash; unrelated children are never enrolled in this job.
+pub(crate) fn assign_child(process: RawHandle) -> io::Result<()> {
+    if unsafe { AssignProcessToJobObject(managed_job()?.as_raw_handle(), process) } == 0 {
+        return Err(io::Error::last_os_error());
+    }
+    Ok(())
+}
+
+pub(crate) fn spawn_managed(
+    command: &mut std::process::Command,
+) -> io::Result<std::process::Child> {
+    use std::os::windows::process::CommandExt;
+    use windows_sys::Win32::System::Threading::{
+        CREATE_NEW_PROCESS_GROUP, CREATE_NO_WINDOW, CREATE_SUSPENDED,
+    };
+    managed_job()?;
+    // Probes can exit or create descendants before spawn returns. Enroll them
+    // while suspended, then let the first thread run.
+    command.creation_flags(CREATE_NO_WINDOW | CREATE_NEW_PROCESS_GROUP | CREATE_SUSPENDED);
+    let mut child = command.spawn()?;
+    if let Err(err) = assign_child(child.as_raw_handle()).and_then(|()| resume_child(child.id())) {
+        let _ = child.kill();
+        let _ = child.wait();
+        return Err(err);
+    }
+    Ok(child)
+}
+
+fn resume_child(pid: u32) -> io::Result<()> {
+    use windows_sys::Win32::Foundation::INVALID_HANDLE_VALUE;
+    use windows_sys::Win32::System::{
+        Diagnostics::ToolHelp::{
+            CreateToolhelp32Snapshot, Thread32First, Thread32Next, TH32CS_SNAPTHREAD, THREADENTRY32,
+        },
+        Threading::{OpenThread, ResumeThread, THREAD_SUSPEND_RESUME},
+    };
+    // Stable Rust does not expose Child's primary-thread handle. The suspended
+    // process has not run user code, so find that thread in the OS snapshot.
+    unsafe {
+        let raw = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);
+        if raw == INVALID_HANDLE_VALUE {
+            return Err(io::Error::last_os_error());
+        }
+        let snapshot = OwnedHandle::from_raw_handle(raw);
+        let mut entry: THREADENTRY32 = std::mem::zeroed();
+        entry.dwSize = std::mem::size_of_val(&entry) as u32;
+        let mut found = Thread32First(snapshot.as_raw_handle(), &mut entry);
+        while found != 0 {
+            if entry.th32OwnerProcessID == pid {
+                let raw = OpenThread(THREAD_SUSPEND_RESUME, 0, entry.th32ThreadID);
+                if raw.is_null() {
+                    return Err(io::Error::last_os_error());
+                }
+                let thread = OwnedHandle::from_raw_handle(raw);
+                if ResumeThread(thread.as_raw_handle()) == u32::MAX {
+                    return Err(io::Error::last_os_error());
+                }
+                return Ok(());
+            }
+            found = Thread32Next(snapshot.as_raw_handle(), &mut entry);
+        }
+        Err(io::Error::other("Managed child has no primary thread"))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::{BufRead, BufReader, Write};
+    use std::process::{Command, Stdio};
+    use windows_sys::Win32::System::Threading::{
+        GetCurrentProcess, OpenProcess, TerminateProcess, WaitForSingleObject,
+    };
+
+    #[test]
+    fn managed_short_lived_command_preserves_exit_status() {
+        let mut command = Command::new("cmd.exe");
+        command.args(["/D", "/C", "exit", "7"]);
+        assert_eq!(
+            spawn_managed(&mut command).unwrap().wait().unwrap().code(),
+            Some(7)
+        );
+    }
+
+    #[test]
+    // This subprocess deliberately dies before it can wait; the parent verifies cleanup.
+    #[allow(clippy::zombie_processes)]
+    fn abrupt_exit_kills_children() {
+        const MARKER: &str = "MONOCODE_JOB_TEST_CHILD";
+        if std::env::var_os(MARKER).is_some() {
+            initialize().unwrap();
+            let mut command = Command::new("ping.exe");
+            crate::hide_window_console(&mut command);
+            command
+                .args(["-n", "60", "127.0.0.1"])
+                .stdout(Stdio::null())
+                .stderr(Stdio::null());
+            let child = spawn_managed(&mut command).unwrap();
+            crate::hide_window_console(&mut command);
+            let external = command.spawn().unwrap();
+            let pair = portable_pty::native_pty_system()
+                .openpty(portable_pty::PtySize::default())
+                .unwrap();
+            let mut terminal = portable_pty::CommandBuilder::new("cmd.exe");
+            terminal.arg("/D");
+            let terminal = pair.slave.spawn_command(terminal).unwrap();
+            assign_child(terminal.as_raw_handle().unwrap()).unwrap();
+            println!("CHILD_PID={}", child.id());
+            println!("TERMINAL_PID={}", terminal.process_id().unwrap());
+            println!("EXTERNAL_PID={}", external.id());
+            std::io::stdout().flush().unwrap();
+            // Skip every Rust destructor, as a forced termination would.
+            unsafe {
+                TerminateProcess(GetCurrentProcess(), 0);
+            }
+            unreachable!();
+        }
+        let mut parent = Command::new(std::env::current_exe().unwrap())
+            .args([
+                "--exact",
+                "windows::tests::abrupt_exit_kills_children",
+                "--nocapture",
+            ])
+            .env(MARKER, "1")
+            .stdout(Stdio::piped())
+            .spawn()
+            .unwrap();
+        // Stop at the explicit marker: an ordinary child may still hold an
+        // inherited pipe handle after the helper process has exited.
+        let mut stdout = String::new();
+        for line in BufReader::new(parent.stdout.take().unwrap()).lines() {
+            let line = line.unwrap();
+            stdout.push_str(&line);
+            stdout.push('\n');
+            if line.starts_with("EXTERNAL_PID=") {
+                break;
+            }
+        }
+        assert!(parent.wait().unwrap().success());
+        let external_pid: u32 = stdout
+            .lines()
+            .find_map(|line| line.strip_prefix("EXTERNAL_PID="))
+            .expect("external process was started")
+            .parse()
+            .unwrap();
+        unsafe {
+            // The relaunch/external-app spawn path must survive parent exit.
+            let raw = OpenProcess(0x0010_0001, 0, external_pid); // SYNCHRONIZE | TERMINATE
+            assert!(!raw.is_null());
+            let external = OwnedHandle::from_raw_handle(raw);
+            let status = WaitForSingleObject(external.as_raw_handle(), 0);
+            TerminateProcess(external.as_raw_handle(), 0);
+            WaitForSingleObject(external.as_raw_handle(), 5000);
+            assert_eq!(status, 258); // WAIT_TIMEOUT: still running
+        }
+        for prefix in ["CHILD_PID=", "TERMINAL_PID="] {
+            let pid: u32 = stdout
+                .lines()
+                .find_map(|line| line.strip_prefix(prefix))
+                .expect("child process was started")
+                .parse()
+                .unwrap();
+            unsafe {
+                let raw = OpenProcess(0x0010_0000, 0, pid); // SYNCHRONIZE
+                if raw.is_null() {
+                    assert_eq!(io::Error::last_os_error().raw_os_error(), Some(87));
+                } else {
+                    let process = OwnedHandle::from_raw_handle(raw);
+                    assert_eq!(WaitForSingleObject(process.as_raw_handle(), 5000), 0);
+                }
+            }
+        }
+    }
+}
diff --git a/src/App.tsx b/src/App.tsx
index 4218545d..4b64ac78 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -338,7 +338,7 @@ import {
 import type { InstalledUpdate } from "./lib/updateNotice";
 import {
   bindResumedSessions,
-  handleQuitRequested,
+  closeBusyWindow,
   hasInFlightSessions,
   hideCurrentWindow,
   closeCurrentWindow,
@@ -980,7 +980,7 @@ export default function App({
         if (hasInFlightSessions(sessionsRef.current)) {
           flushHarnessEvents();
           if (!IS_MAC) {
-            void handleQuitRequested();
+            void closeBusyWindow();
             return;
           }
           void persistLiveTranscripts(sessionsRef.current);
diff --git a/src/lib/appLifecycle.test.ts b/src/lib/appLifecycle.test.ts
new file mode 100644
index 00000000..80abc42e
--- /dev/null
+++ b/src/lib/appLifecycle.test.ts
@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { invoke } from "@tauri-apps/api/core";
+import { ask } from "@tauri-apps/plugin-dialog";
+import { forgetHarnessSession, killAllChildren } from "./harness";
+import { newSession } from "./session";
+import { newTab } from "./layout";
+import { closeBusyWindow, setQuitWorkspace } from "./appLifecycle";
+
+vi.mock("@tauri-apps/api/core", () => ({
+  invoke: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("@tauri-apps/plugin-dialog", () => ({
+  ask: vi.fn().mockResolvedValue(true),
+}));
+vi.mock("./harness", () => ({
+  bindHarnessSession: vi.fn(),
+  isLiveHarness: vi.fn(),
+  forgetHarnessSession: vi.fn().mockResolvedValue(undefined),
+  killAllChildren: vi.fn().mockResolvedValue(undefined),
+}));
+
+describe("closing a busy window", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.mocked(ask).mockResolvedValue(true);
+  });
+
+  function workspace() {
+    const session = newSession("cursor", "C:/test");
+    session.busy = true;
+    session.blocks = [{ id: "user", role: "user", text: "test" }];
+    const tab = newTab(session.id);
+    const release = setQuitWorkspace(
+      () => [session],
+      () => [tab],
+      () => tab.id,
+      () => session.cwd,
+      () => [],
+      vi.fn(),
+    );
+    return { session, release };
+  }
+
+  it("stops only its sessions and destroys only its window", async () => {
+    const { session, release } = workspace();
+    try {
+      await closeBusyWindow();
+      expect(ask).toHaveBeenCalled();
+      expect(forgetHarnessSession).toHaveBeenCalledWith("cursor", session.id);
+      expect(killAllChildren).not.toHaveBeenCalled();
+      expect(invoke).toHaveBeenCalledWith("destroy_window");
+      expect(
+        vi
+          .mocked(invoke)
+          .mock.calls.some(([command]) => command === "confirm_quit"),
+      ).toBe(false);
+    } finally {
+      release();
+    }
+  });
+
+  it("leaves the window and sessions running when closing is cancelled", async () => {
+    const { release } = workspace();
+    vi.mocked(ask).mockResolvedValue(false);
+    try {
+      await closeBusyWindow();
+      expect(forgetHarnessSession).not.toHaveBeenCalled();
+      expect(killAllChildren).not.toHaveBeenCalled();
+      expect(invoke).not.toHaveBeenCalled();
+    } finally {
+      release();
+    }
+  });
+});
diff --git a/src/lib/appLifecycle.ts b/src/lib/appLifecycle.ts
index f6199da0..abc9a2cf 100644
--- a/src/lib/appLifecycle.ts
+++ b/src/lib/appLifecycle.ts
@@ -122,6 +122,16 @@ export async function handleQuitRequested(): Promise<void> {
   await invoke("confirm_quit");
 }
 
+/** Confirm and stop this window's work without terminating other windows. */
+export async function closeBusyWindow(): Promise<void> {
+  if (!liveWorkspace) return;
+  liveWorkspace.flush();
+  await confirmQuitAndExit(
+    liveWorkspace.sessions(), liveWorkspace.tabs(), liveWorkspace.activeTabId(),
+    liveWorkspace.projectCwd(), liveWorkspace.projectTerminals(), true,
+  );
+}
+
 export function loadResumedWorkspace(): Promise<ResumedWorkspace | null> {
   if (!resumedPromise) resumedPromise = loadResumedWorkspaceOnce();
   return resumedPromise;
@@ -343,16 +353,19 @@ async function confirmQuitAndExit(
   activeTabId: string,
   projectCwd: string,
   projectTerminals: ProjectTerminalDock[] = [],
+  closeWindow = false,
 ): Promise<void> {
   if (quitDialogOpen) return;
   quitDialogOpen = true;
   try {
     const refs = inFlightRefs(sessions, tabs);
     if (refs.length > 0) {
-      const ok = await ask(quitWhileBusyMessage(refs.length), {
+      const ok = await ask(closeWindow
+        ? "Close this window and stop its running chats? Other windows will stay open."
+        : quitWhileBusyMessage(refs.length), {
         title: "MonoCode",
         kind: "warning",
-        okLabel: "Quit",
+        okLabel: closeWindow ? "Close window" : "Quit",
       });
       if (!ok) return;
     }
@@ -366,7 +379,12 @@ async function confirmQuitAndExit(
         "quit",
         projectTerminals,
       );
-      await invoke("confirm_quit");
+      if (closeWindow) {
+        await reapWindowRuntime(sessions, tabs, projectTerminals, false);
+        await closeCurrentWindow();
+      } else {
+        await invoke("confirm_quit");
+      }
     } catch {
       quitting = false;
     }
@@ -379,6 +397,7 @@ export async function reapWindowRuntime(
   sessions: Session[],
   tabs: WorkspaceTab[],
   projectTerminals: ProjectTerminalDock[] = [],
+  includeAllChildren = true,
 ): Promise<void> {
   await Promise.all(
     sessions.map((session) =>
@@ -396,7 +415,7 @@ export async function reapWindowRuntime(
   );
   // Catalog probes, title generators, and usage scrapers are not session
   // children. Drop them so an unused Pi/Codex probe cannot outlive the window.
-  await killAllChildren().catch(() => undefined);
+  if (includeAllChildren) await killAllChildren().catch(() => undefined);
 }
 
 function terminalFileIds(tabs: WorkspaceTab[]): string[] {
diff --git a/src/lib/paths.test.ts b/src/lib/paths.test.ts
index ca35eeb1..98fa5c34 100644
--- a/src/lib/paths.test.ts
+++ b/src/lib/paths.test.ts
@@ -11,6 +11,11 @@ import {
 } from "./paths";
 
 describe("slash", () => {
+  it("preserves backslashes in absolute Unix filenames", () => {
+    expect(slash("/tmp/a\\b.txt")).toBe("/tmp/a\\b.txt");
+    expect(joinPath("/tmp", "a\\b.txt")).toBe("/tmp/a\\b.txt");
+    expect(parentPath("/tmp/a\\b.txt")).toBe("/tmp");
+  });
   it("normalizes Windows separators", () => {
     expect(slash("C:\\Users\\me\\code")).toBe("C:/Users/me/code");
   });
@@ -26,6 +31,10 @@ describe("prettyCwd", () => {
 });
 
 describe("parentPath and joinPath", () => {
+  it("preserves Windows filesystem roots", () => {
+    expect(parentPath("//server/share")).toBe("//server/share");
+    expect(rebasePath("C:/old", "C:/old", "D:/")).toBe("D:/");
+  });
   it("walks Windows drive paths", () => {
     expect(parentPath("C:/Users/me/code")).toBe("C:/Users/me");
     expect(parentPath("C:/Users")).toBe("C:/");
diff --git a/src/lib/paths.ts b/src/lib/paths.ts
index 257cd721..5de27f44 100644
--- a/src/lib/paths.ts
+++ b/src/lib/paths.ts
@@ -1,6 +1,12 @@
-/** Display path with home collapsed to `~`. */
+import { IS_WIN } from "./platform";
+
+function windowsPath(path: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(path) || path.startsWith("\\\\") || path.startsWith("//");
+}
+
 export function slash(path: string): string {
-  return path.replace(/\\/g, "/");
+  return windowsPath(path) || (IS_WIN && !path.startsWith("/"))
+    ? path.replace(/\\/g, "/") : path;
 }
 
 function trimSlash(path: string): string {
@@ -37,6 +43,7 @@ export function prettyCwd(cwd: string): string {
 
 export function parentPath(path: string): string {
   const trimmed = trimSlash(path);
+  if (/^\/\/[^/]+\/[^/]+$/.test(trimmed)) return trimmed;
   if (/^[A-Za-z]:$/.test(trimmed)) return `${trimmed}/`;
   const i = trimmed.lastIndexOf("/");
   if (i <= 0) return "/";
@@ -51,7 +58,7 @@ export function rebasePath(path: string, from: string, to: string): string {
   const dest = trimSlash(to);
   const key = pathKey(normalized);
   const sourceKey = pathKey(source);
-  if (key === sourceKey) return dest;
+  if (key === sourceKey) return /^[A-Za-z]:$/.test(dest) ? `${dest}/` : dest;
   if (key.startsWith(`${sourceKey}/`)) {
     return `${dest}${normalized.slice(source.length)}`;
   }
@@ -69,7 +76,7 @@ export function isEqualOrInside(path: string, root: string): boolean {
 export function joinPath(parent: string, relative: string): string {
   const base = trimSlash(parent);
   const parts = relative
-    .split(/[/\\]/)
+    .split(windowsPath(parent) ? /[/\\]/ : /\//)
     .filter((part) => part && part !== ".");
   let out = base;
   for (const part of parts) {
diff --git a/src/lib/recents.ts b/src/lib/recents.ts
index df9576e0..b07d4794 100644
--- a/src/lib/recents.ts
+++ b/src/lib/recents.ts
@@ -299,7 +299,7 @@ export function projectRailItems(
 /** True if this looks like a user project, not an app bundle or system root. */
 export function looksLikeProject(path: string): boolean {
   if (!path || path === "/" || path === "~") return false;
-  const normalized = path.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+  const normalized = slash(path).replace(/\/+$/, "") || "/";
   if (/^[A-Za-z]:$/.test(normalized) || normalized === "/") return false;
   // Home itself arrives expanded (`/Users/me`), so the `~` check above misses
   // it. Indexing it walks `~/Library`, which trips the OS consent prompt.
diff --git a/src/lib/search.ts b/src/lib/search.ts
index 9d62e1a2..a5a9dd13 100644
--- a/src/lib/search.ts
+++ b/src/lib/search.ts
@@ -1,5 +1,5 @@
 import { invoke } from "@tauri-apps/api/core";
-import { pathKey } from "./paths";
+import { pathKey, slash } from "./paths";
 
 export type ProjectSearchMatch = {
   path: string;
@@ -37,7 +37,7 @@ export type EditorNavigationTarget = EditorNavigation & {
 export type OpenFileFn = (path: string, navigation?: EditorNavigation) => void;
 
 export function normalizeEditorPath(path: string): string {
-  return path.replace(/\\/g, "/").replace(/\/+$/, "") || path;
+  return slash(path).replace(/\/+$/, "") || path;
 }
 
 export function editorPathsEqual(a: string, b: string): boolean {

From 1169e303b2fbfea7c0b6007af20bda04cf457067 Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Sat, 5 Sep 2026 15:08:58 +0100
Subject: [PATCH 5/6] Fix Windows terminal startup escaping crash cleanup

Assign PTY children to the managed job atomically with PROC_THREAD_ATTRIBUTE_JOB_LIST. Vendor the checksum-verified portable-pty 0.9.0 source for the narrow Windows API extension, and cover immediate descendants and rejected job handles in Windows tests.
---
 Cargo.lock                                    |   2 -
 Cargo.toml                                    |   1 +
 src-tauri/Cargo.toml                          |   2 +-
 src-tauri/src/pty.rs                          |  13 +-
 src-tauri/src/windows.rs                      | 104 ++-
 vendor/portable-pty/Cargo.toml                | 120 +++
 vendor/portable-pty/LICENSE.md                |  21 +
 vendor/portable-pty/UPSTREAM.md               |  29 +
 vendor/portable-pty/examples/bash.rs          |  85 ++
 vendor/portable-pty/examples/narrow.rs        |  92 ++
 vendor/portable-pty/examples/whoami.rs        |  94 ++
 vendor/portable-pty/examples/whoami_async.rs  |  73 ++
 vendor/portable-pty/src/cmdbuilder.rs         | 823 ++++++++++++++++++
 vendor/portable-pty/src/lib.rs                | 418 +++++++++
 vendor/portable-pty/src/serial.rs             | 305 +++++++
 vendor/portable-pty/src/unix.rs               | 414 +++++++++
 vendor/portable-pty/src/win/conpty.rs         | 127 +++
 vendor/portable-pty/src/win/mod.rs            | 149 ++++
 vendor/portable-pty/src/win/procthreadattr.rs |  99 +++
 vendor/portable-pty/src/win/psuedocon.rs      | 186 ++++
 20 files changed, 3136 insertions(+), 21 deletions(-)
 create mode 100644 vendor/portable-pty/Cargo.toml
 create mode 100644 vendor/portable-pty/LICENSE.md
 create mode 100644 vendor/portable-pty/UPSTREAM.md
 create mode 100644 vendor/portable-pty/examples/bash.rs
 create mode 100644 vendor/portable-pty/examples/narrow.rs
 create mode 100644 vendor/portable-pty/examples/whoami.rs
 create mode 100644 vendor/portable-pty/examples/whoami_async.rs
 create mode 100644 vendor/portable-pty/src/cmdbuilder.rs
 create mode 100644 vendor/portable-pty/src/lib.rs
 create mode 100644 vendor/portable-pty/src/serial.rs
 create mode 100644 vendor/portable-pty/src/unix.rs
 create mode 100644 vendor/portable-pty/src/win/conpty.rs
 create mode 100644 vendor/portable-pty/src/win/mod.rs
 create mode 100644 vendor/portable-pty/src/win/procthreadattr.rs
 create mode 100644 vendor/portable-pty/src/win/psuedocon.rs

diff --git a/Cargo.lock b/Cargo.lock
index 4b8fe757..d646dbce 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2818,8 +2818,6 @@ dependencies = [
 [[package]]
 name = "portable-pty"
 version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4a596a2b3d2752d94f51fac2d4a96737b8705dddd311a32b9af47211f08671e"
 dependencies = [
  "anyhow",
  "bitflags 1.3.2",
diff --git a/Cargo.toml b/Cargo.toml
index 99f34b84..74581515 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,7 @@
 [workspace]
 resolver = "2"
 members = ["src-tauri"]
+exclude = ["vendor/portable-pty"]
 
 [workspace.package]
 version = "0.1.32"
diff --git a/src-tauri/Cargo.toml b/src-tauri/Cargo.toml
index 805b6e0e..c9db2912 100644
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@@ -30,7 +30,7 @@ tauri-plugin-process = "2"
 libc = "0.2"
 
 [target.'cfg(windows)'.dependencies]
-portable-pty = "0.9"
+portable-pty = { version = "0.9", path = "../vendor/portable-pty" }
 windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Security", "Win32_System_JobObjects", "Win32_System_Threading", "Win32_System_LibraryLoader", "Win32_System_Diagnostics_ToolHelp"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
diff --git a/src-tauri/src/pty.rs b/src-tauri/src/pty.rs
index 8bbe9dff..8686f516 100644
--- a/src-tauri/src/pty.rs
+++ b/src-tauri/src/pty.rs
@@ -396,19 +396,8 @@ fn spawn_windows(
     }
     cmd.env("PWD", workdir.to_string_lossy().as_ref());
 
-    let mut child = pair
-        .slave
-        .spawn_command(cmd)
+    let mut child = crate::windows::spawn_pty(pair.slave.as_ref(), cmd)
         .map_err(|err| format!("Failed to start {shell}: {err}"))?;
-    let registered = child
-        .as_raw_handle()
-        .ok_or_else(|| std::io::Error::other("Terminal has no process handle"))
-        .and_then(crate::windows::assign_child);
-    if let Err(err) = registered {
-        let _ = child.kill();
-        let _ = child.wait();
-        return Err(format!("Failed to supervise terminal: {err}"));
-    }
     let pid = child.process_id().unwrap_or(0);
     let mut reader = pair
         .master
diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rs
index 195b73ae..331876bb 100644
--- a/src-tauri/src/windows.rs
+++ b/src-tauri/src/windows.rs
@@ -1,5 +1,5 @@
 use std::io;
-use std::os::windows::io::{AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
+use std::os::windows::io::{AsHandle, AsRawHandle, FromRawHandle, OwnedHandle, RawHandle};
 use std::sync::OnceLock;
 use windows_sys::Win32::System::{
     JobObjects::{
@@ -66,6 +66,16 @@ pub(crate) fn assign_child(process: RawHandle) -> io::Result<()> {
     Ok(())
 }
 
+pub(crate) fn spawn_pty(
+    slave: &dyn portable_pty::SlavePty,
+    command: portable_pty::CommandBuilder,
+) -> Result<Box<dyn portable_pty::Child + Send + Sync>, String> {
+    let job = managed_job().map_err(|err| err.to_string())?;
+    slave
+        .spawn_command_in_job(command, job.as_handle())
+        .map_err(|err| err.to_string())
+}
+
 pub(crate) fn spawn_managed(
     command: &mut std::process::Command,
 ) -> io::Result<std::process::Child> {
@@ -130,6 +140,7 @@ mod tests {
     use std::process::{Command, Stdio};
     use windows_sys::Win32::System::Threading::{
         GetCurrentProcess, OpenProcess, TerminateProcess, WaitForSingleObject,
+        PROCESS_QUERY_INFORMATION,
     };
 
     #[test]
@@ -142,11 +153,44 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pty_rejects_an_invalid_job_without_unprotected_fallback() {
+        initialize().unwrap();
+        let pair = portable_pty::native_pty_system()
+            .openpty(portable_pty::PtySize::default())
+            .unwrap();
+        // A valid handle of the wrong object type must fail process creation.
+        let file = std::fs::File::open(std::env::current_exe().unwrap()).unwrap();
+        let mut command = portable_pty::CommandBuilder::new("cmd.exe");
+        command.args(["/D", "/C", "exit", "7"]);
+        assert!(pair
+            .slave
+            .spawn_command_in_job(command, file.as_handle())
+            .is_err());
+    }
+
     #[test]
     // This subprocess deliberately dies before it can wait; the parent verifies cleanup.
     #[allow(clippy::zombie_processes)]
     fn abrupt_exit_kills_children() {
         const MARKER: &str = "MONOCODE_JOB_TEST_CHILD";
+        const PID_FILE: &str = "MONOCODE_JOB_TEST_DESCENDANT_FILE";
+        if std::env::var(MARKER).as_deref() == Ok("terminal") {
+            // This is the terminal's startup code. Launch a detached child
+            // immediately, before the supervisor can do any post-spawn work.
+            let mut command = Command::new("ping.exe");
+            crate::hide_window_console(&mut command);
+            let mut child = command
+                .args(["-n", "60", "127.0.0.1"])
+                .stdin(Stdio::null())
+                .stdout(Stdio::null())
+                .stderr(Stdio::null())
+                .spawn()
+                .unwrap();
+            std::fs::write(std::env::var_os(PID_FILE).unwrap(), child.id().to_string()).unwrap();
+            let _ = child.wait();
+            return;
+        }
         if std::env::var_os(MARKER).is_some() {
             initialize().unwrap();
             let mut command = Command::new("ping.exe");
@@ -161,12 +205,60 @@ mod tests {
             let pair = portable_pty::native_pty_system()
                 .openpty(portable_pty::PtySize::default())
                 .unwrap();
-            let mut terminal = portable_pty::CommandBuilder::new("cmd.exe");
-            terminal.arg("/D");
-            let terminal = pair.slave.spawn_command(terminal).unwrap();
-            assign_child(terminal.as_raw_handle().unwrap()).unwrap();
+            let pid_file = std::env::temp_dir().join(format!(
+                "monocode-pty-descendant-{}.pid",
+                std::process::id()
+            ));
+            let _ = std::fs::remove_file(&pid_file);
+            let mut terminal = portable_pty::CommandBuilder::new(std::env::current_exe().unwrap());
+            terminal.args([
+                "--exact",
+                "windows::tests::abrupt_exit_kills_children",
+                "--nocapture",
+            ]);
+            terminal.env(MARKER, "terminal");
+            terminal.env(PID_FILE, &pid_file);
+            // Drain output even when no UI is present; ConPTY shutdown on older
+            // Windows versions can otherwise wait for its output pipe forever.
+            let mut reader = pair.master.try_clone_reader().unwrap();
+            std::thread::spawn(move || {
+                let _ = std::io::copy(&mut reader, &mut std::io::sink());
+            });
+            let terminal = spawn_pty(pair.slave.as_ref(), terminal).unwrap();
+            let deadline = std::time::Instant::now() + std::time::Duration::from_secs(15);
+            let descendant_pid: u32 = loop {
+                if let Some(pid) = std::fs::read_to_string(&pid_file)
+                    .ok()
+                    .and_then(|text| text.parse().ok())
+                {
+                    break pid;
+                }
+                assert!(
+                    std::time::Instant::now() < deadline,
+                    "terminal startup timed out"
+                );
+                std::thread::sleep(std::time::Duration::from_millis(10));
+            };
+            std::fs::remove_file(pid_file).unwrap();
+            unsafe {
+                // Check our specific job, since CI may already have its own job.
+                let raw = OpenProcess(PROCESS_QUERY_INFORMATION, 0, descendant_pid);
+                assert!(!raw.is_null());
+                let descendant = OwnedHandle::from_raw_handle(raw);
+                let mut in_job = 0;
+                assert_ne!(
+                    windows_sys::Win32::System::JobObjects::IsProcessInJob(
+                        descendant.as_raw_handle(),
+                        managed_job().unwrap().as_raw_handle(),
+                        &mut in_job,
+                    ),
+                    0
+                );
+                assert_ne!(in_job, 0, "startup descendant escaped the managed job");
+            }
             println!("CHILD_PID={}", child.id());
             println!("TERMINAL_PID={}", terminal.process_id().unwrap());
+            println!("DESCENDANT_PID={descendant_pid}");
             println!("EXTERNAL_PID={}", external.id());
             std::io::stdout().flush().unwrap();
             // Skip every Rust destructor, as a forced termination would.
@@ -213,7 +305,7 @@ mod tests {
             WaitForSingleObject(external.as_raw_handle(), 5000);
             assert_eq!(status, 258); // WAIT_TIMEOUT: still running
         }
-        for prefix in ["CHILD_PID=", "TERMINAL_PID="] {
+        for prefix in ["CHILD_PID=", "TERMINAL_PID=", "DESCENDANT_PID="] {
             let pid: u32 = stdout
                 .lines()
                 .find_map(|line| line.strip_prefix(prefix))
diff --git a/vendor/portable-pty/Cargo.toml b/vendor/portable-pty/Cargo.toml
new file mode 100644
index 00000000..b8d11230
--- /dev/null
+++ b/vendor/portable-pty/Cargo.toml
@@ -0,0 +1,120 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "portable-pty"
+version = "0.9.0"
+authors = ["Wez Furlong"]
+build = false
+autolib = false
+autobins = false
+autoexamples = false
+autotests = false
+autobenches = false
+description = "Cross platform pty interface"
+documentation = "https://docs.rs/portable-pty"
+readme = false
+license = "MIT"
+repository = "https://github.com/wezterm/wezterm"
+resolver = "2"
+
+[lib]
+name = "portable_pty"
+path = "src/lib.rs"
+
+[[example]]
+name = "bash"
+path = "examples/bash.rs"
+
+[[example]]
+name = "narrow"
+path = "examples/narrow.rs"
+
+[[example]]
+name = "whoami"
+path = "examples/whoami.rs"
+
+[[example]]
+name = "whoami_async"
+path = "examples/whoami_async.rs"
+
+[dependencies.anyhow]
+version = "1.0"
+
+[dependencies.downcast-rs]
+version = "1.0"
+
+[dependencies.filedescriptor]
+version = "0.8.3"
+
+[dependencies.libc]
+version = "0.2"
+
+[dependencies.log]
+version = "0.4"
+
+[dependencies.nix]
+version = "0.28"
+features = [
+    "term",
+    "fs",
+]
+
+[dependencies.serde]
+version = "1.0"
+optional = true
+
+[dependencies.serde_derive]
+version = "1.0"
+optional = true
+
+[dependencies.serial2]
+version = "0.2"
+
+[dependencies.shell-words]
+version = "1.1"
+
+[dev-dependencies.futures]
+version = "0.3"
+
+[dev-dependencies.smol]
+version = "2.0"
+
+[features]
+default = []
+serde_support = [
+    "serde",
+    "serde_derive",
+]
+
+[target."cfg(windows)".dependencies.bitflags]
+version = "1.3"
+
+[target."cfg(windows)".dependencies.lazy_static]
+version = "1.4"
+
+[target."cfg(windows)".dependencies.shared_library]
+version = "0.1"
+
+[target."cfg(windows)".dependencies.winapi]
+version = "0.3"
+features = [
+    "winuser",
+    "consoleapi",
+    "handleapi",
+    "fileapi",
+    "namedpipeapi",
+    "synchapi",
+]
+
+[target."cfg(windows)".dependencies.winreg]
+version = "0.10"
diff --git a/vendor/portable-pty/LICENSE.md b/vendor/portable-pty/LICENSE.md
new file mode 100644
index 00000000..7a93d12f
--- /dev/null
+++ b/vendor/portable-pty/LICENSE.md
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Wez Furlong
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/portable-pty/UPSTREAM.md b/vendor/portable-pty/UPSTREAM.md
new file mode 100644
index 00000000..ceacc65a
--- /dev/null
+++ b/vendor/portable-pty/UPSTREAM.md
@@ -0,0 +1,29 @@
+# portable-pty 0.9.0
+
+Source: https://crates.io/crates/portable-pty/0.9.0
+
+Archive SHA-256 (verified against MonoCode's original Cargo.lock):
+`b4a596a2b3d2752d94f51fac2d4a96737b8705dddd311a32b9af47211f08671e`
+
+Upstream commit: `f8921727a11b9f8b073e8c24821d72fd41283500` in
+https://github.com/wezterm/wezterm (the `pty/` directory).
+
+This copy preserves the published source, manifest, examples, and MIT license.
+Package-only metadata (`Cargo.lock`, `Cargo.toml.orig`, `.cargo_vcs_info.json`)
+is omitted.
+
+The local patch adds `SlavePty::spawn_command_in_job` on Windows, implemented
+by ConPTY using `PROC_THREAD_ATTRIBUTE_JOB_LIST`. Windows assigns the child
+to the supplied job during process creation, before startup scripts can create
+descendants. The borrowed job and attribute storage stay alive through
+`CreateProcessW`; failure never falls back to an unprotected spawn.
+
+Only these upstream files are modified:
+
+- `src/lib.rs`
+- `src/win/conpty.rs`
+- `src/win/procthreadattr.rs`
+- `src/win/psuedocon.rs`
+
+Remove this copy once an upstream release provides equivalent atomic job
+assignment. Existing unassigned spawns and Unix behavior are unchanged.
diff --git a/vendor/portable-pty/examples/bash.rs b/vendor/portable-pty/examples/bash.rs
new file mode 100644
index 00000000..2066b7ec
--- /dev/null
+++ b/vendor/portable-pty/examples/bash.rs
@@ -0,0 +1,85 @@
+//! This example demonstrates how to spawn a Bash shell using the `portable_pty` crate.
+//! based on pty/examples/whoami.rs
+
+use portable_pty::{CommandBuilder, NativePtySystem, PtySize, PtySystem};
+use std::io::{Read, Write};
+use std::sync::mpsc::channel;
+use std::thread;
+
+fn main() {
+    let pty_system = NativePtySystem::default();
+
+    // Open the PTY with specified size.
+    let pair = pty_system
+        .openpty(PtySize {
+            rows: 24,
+            cols: 80,
+            pixel_width: 0,
+            pixel_height: 0,
+        })
+        .unwrap();
+
+    // Set up the command to launch Bash.
+    let cmd = CommandBuilder::new("bash");
+    let mut child = pair.slave.spawn_command(cmd).unwrap();
+
+    drop(pair.slave);
+
+    // Set up channels for reading and writing.
+    let (tx, rx) = channel::<String>();
+    let mut reader = pair.master.try_clone_reader().unwrap();
+    let master_writer = pair.master.take_writer().unwrap();
+
+    // Thread to read from the PTY and send data to the main thread.
+    thread::spawn(move || {
+        let mut buffer = [0u8; 1024];
+        loop {
+            match reader.read(&mut buffer) {
+                Ok(0) => break, // EOF
+                Ok(n) => {
+                    let output = String::from_utf8_lossy(&buffer[..n]);
+                    println!("{}", output); // Print to stdout for visibility.
+                }
+                Err(e) => {
+                    eprintln!("Error reading from PTY: {}", e);
+                    break;
+                }
+            }
+        }
+    });
+
+    // Thread to write input into the PTY.
+    let tx_writer = thread::spawn(move || {
+        handle_input_stream(rx, master_writer);
+    });
+
+    println!("You can now type commands for Bash (type 'exit' to quit):");
+
+    // Main thread sends user input to the writer thread.
+    loop {
+        let mut input = String::new();
+        std::io::stdin().read_line(&mut input).unwrap();
+
+        if input.trim() == "exit" {
+            break;
+        }
+
+        tx.send(input).unwrap();
+    }
+
+    drop(tx);
+    tx_writer.join().unwrap();
+
+    println!("Waiting for Bash to exit...");
+    let status = child.wait().unwrap();
+    println!("Bash exited with status: {:?}", status);
+}
+
+fn handle_input_stream(rx: std::sync::mpsc::Receiver<String>, mut writer: Box<dyn Write + Send>) {
+    for input in rx.iter() {
+        if writer.write_all(input.as_bytes()).is_err() {
+            eprintln!("Error writing to PTY");
+            break;
+        }
+    }
+}
diff --git a/vendor/portable-pty/examples/narrow.rs b/vendor/portable-pty/examples/narrow.rs
new file mode 100644
index 00000000..5793b9b7
--- /dev/null
+++ b/vendor/portable-pty/examples/narrow.rs
@@ -0,0 +1,92 @@
+//! Runs a command with a fixed terminal size.
+//! This is used by wezterm's doc building automation to keep
+//! the --help output within a reasonable width
+use portable_pty::{CommandBuilder, NativePtySystem, PtySize, PtySystem};
+use std::sync::mpsc::channel;
+
+fn main() {
+    let pty_system = NativePtySystem::default();
+
+    let pair = pty_system
+        .openpty(PtySize {
+            rows: 24,
+            cols: 80,
+            pixel_width: 0,
+            pixel_height: 0,
+        })
+        .unwrap();
+
+    let mut args = std::env::args_os().skip(1);
+
+    let mut cmd = CommandBuilder::new(args.next().unwrap());
+    cmd.args(args);
+
+    let mut child = pair.slave.spawn_command(cmd).unwrap();
+
+    // Release any handles owned by the slave: we don't need it now
+    // that we've spawned the child.
+    drop(pair.slave);
+
+    // Read the output in another thread.
+    // This is important because it is easy to encounter a situation
+    // where read/write buffers fill and block either your process
+    // or the spawned process.
+    let (tx, rx) = channel();
+    let mut reader = pair.master.try_clone_reader().unwrap();
+    std::thread::spawn(move || {
+        // Consume the output from the child
+        let mut s = String::new();
+        reader.read_to_string(&mut s).unwrap();
+        tx.send(s).unwrap();
+    });
+
+    {
+        // Obtain the writer.
+        // When the writer is dropped, EOF will be sent to
+        // the program that was spawned.
+        // It is important to take the writer even if you don't
+        // send anything to its stdin so that EOF can be
+        // generated, otherwise you risk deadlocking yourself.
+        let mut writer = pair.master.take_writer().unwrap();
+
+        if cfg!(target_os = "macos") {
+            // macOS quirk: the child and reader must be started and
+            // allowed a brief grace period to run before we allow
+            // the writer to drop. Otherwise, the data we send to
+            // the kernel to trigger EOF is interleaved with the
+            // data read by the reader! WTF!?
+            // This appears to be a race condition for very short
+            // lived processes on macOS.
+            // I'd love to find a more deterministic solution to
+            // this than sleeping.
+            std::thread::sleep(std::time::Duration::from_millis(20));
+        }
+
+        // This example doesn't need to write anything, but if you
+        // want to send data to the child, you'd set `to_write` to
+        // that data and do it like this:
+        let to_write = "";
+        if !to_write.is_empty() {
+            // To avoid deadlock, wrt. reading and waiting, we send
+            // data to the stdin of the child in a different thread.
+            std::thread::spawn(move || {
+                writer.write_all(to_write.as_bytes()).unwrap();
+            });
+        }
+    }
+
+    // Wait for the child to complete
+    eprintln!("child status: {:?}", child.wait().unwrap());
+
+    // Take care to drop the master after our processes are
+    // done, as some platforms get unhappy if it is dropped
+    // sooner than that.
+    drop(pair.master);
+
+    // Now wait for the output to be read by our reader thread
+    let output = rx.recv().unwrap();
+
+    let output = output.replace("\r\n", "\n");
+
+    print!("{output}");
+}
diff --git a/vendor/portable-pty/examples/whoami.rs b/vendor/portable-pty/examples/whoami.rs
new file mode 100644
index 00000000..f7e9cca0
--- /dev/null
+++ b/vendor/portable-pty/examples/whoami.rs
@@ -0,0 +1,94 @@
+//! This is a conceptually simple example that spawns the `whoami` program
+//! to print your username.  It is made more complex because there are multiple
+//! pipes involved and it is easy to get blocked/deadlocked if care and attention
+//! is not paid to those pipes!
+use portable_pty::{CommandBuilder, NativePtySystem, PtySize, PtySystem};
+use std::sync::mpsc::channel;
+
+fn main() {
+    let pty_system = NativePtySystem::default();
+
+    let pair = pty_system
+        .openpty(PtySize {
+            rows: 24,
+            cols: 80,
+            pixel_width: 0,
+            pixel_height: 0,
+        })
+        .unwrap();
+
+    let cmd = CommandBuilder::new("whoami");
+    let mut child = pair.slave.spawn_command(cmd).unwrap();
+
+    // Release any handles owned by the slave: we don't need it now
+    // that we've spawned the child.
+    drop(pair.slave);
+
+    // Read the output in another thread.
+    // This is important because it is easy to encounter a situation
+    // where read/write buffers fill and block either your process
+    // or the spawned process.
+    let (tx, rx) = channel();
+    let mut reader = pair.master.try_clone_reader().unwrap();
+    std::thread::spawn(move || {
+        // Consume the output from the child
+        let mut s = String::new();
+        reader.read_to_string(&mut s).unwrap();
+        tx.send(s).unwrap();
+    });
+
+    {
+        // Obtain the writer.
+        // When the writer is dropped, EOF will be sent to
+        // the program that was spawned.
+        // It is important to take the writer even if you don't
+        // send anything to its stdin so that EOF can be
+        // generated, otherwise you risk deadlocking yourself.
+        let mut writer = pair.master.take_writer().unwrap();
+
+        if cfg!(target_os = "macos") {
+            // macOS quirk: the child and reader must be started and
+            // allowed a brief grace period to run before we allow
+            // the writer to drop. Otherwise, the data we send to
+            // the kernel to trigger EOF is interleaved with the
+            // data read by the reader! WTF!?
+            // This appears to be a race condition for very short
+            // lived processes on macOS.
+            // I'd love to find a more deterministic solution to
+            // this than sleeping.
+            std::thread::sleep(std::time::Duration::from_millis(20));
+        }
+
+        // This example doesn't need to write anything, but if you
+        // want to send data to the child, you'd set `to_write` to
+        // that data and do it like this:
+        let to_write = "";
+        if !to_write.is_empty() {
+            // To avoid deadlock, wrt. reading and waiting, we send
+            // data to the stdin of the child in a different thread.
+            std::thread::spawn(move || {
+                writer.write_all(to_write.as_bytes()).unwrap();
+            });
+        }
+    }
+
+    // Wait for the child to complete
+    println!("child status: {:?}", child.wait().unwrap());
+
+    // Take care to drop the master after our processes are
+    // done, as some platforms get unhappy if it is dropped
+    // sooner than that.
+    drop(pair.master);
+
+    // Now wait for the output to be read by our reader thread
+    let output = rx.recv().unwrap();
+
+    // We print with escapes escaped because the windows conpty
+    // implementation synthesizes title change escape sequences
+    // in the output stream and it can be confusing to see those
+    // printed out raw in another terminal.
+    print!("output: ");
+    for c in output.escape_debug() {
+        print!("{}", c);
+    }
+}
diff --git a/vendor/portable-pty/examples/whoami_async.rs b/vendor/portable-pty/examples/whoami_async.rs
new file mode 100644
index 00000000..e32b6a9c
--- /dev/null
+++ b/vendor/portable-pty/examples/whoami_async.rs
@@ -0,0 +1,73 @@
+use anyhow::anyhow;
+use futures::prelude::*;
+use portable_pty::{native_pty_system, CommandBuilder, PtySize};
+
+// This example shows how to use the `smol` crate to use portable_pty
+// in an asynchronous application.
+
+fn main() -> anyhow::Result<()> {
+    smol::block_on(async {
+        let pty_system = native_pty_system();
+
+        let pair = pty_system.openpty(PtySize {
+            rows: 24,
+            cols: 80,
+            pixel_width: 0,
+            pixel_height: 0,
+        })?;
+
+        let cmd = CommandBuilder::new("whoami");
+
+        // Move the slave to another thread to block and spawn a
+        // command.
+        // Note that this implicitly drops slave and closes out
+        // file handles which is important to avoid deadlock
+        // when waiting for the child process!
+        let slave = pair.slave;
+        let mut child = smol::unblock(move || slave.spawn_command(cmd)).await?;
+
+        {
+            // Obtain the writer.
+            // When the writer is dropped, EOF will be sent to
+            // the program that was spawned.
+            // It is important to take the writer even if you don't
+            // send anything to its stdin so that EOF can be
+            // generated, otherwise you risk deadlocking yourself.
+            let writer = pair.master.take_writer()?;
+
+            // Explicitly generate EOF
+            drop(writer);
+        }
+
+        println!(
+            "child status: {:?}",
+            smol::unblock(move || child
+                .wait()
+                .map_err(|e| anyhow!("waiting for child: {}", e)))
+            .await?
+        );
+
+        let reader = pair.master.try_clone_reader()?;
+
+        // Take care to drop the master after our processes are
+        // done, as some platforms get unhappy if it is dropped
+        // sooner than that.
+        drop(pair.master);
+
+        let mut lines = smol::io::BufReader::new(smol::Unblock::new(reader)).lines();
+        while let Some(line) = lines.next().await {
+            let line = line.map_err(|e| anyhow!("problem reading line: {}", e))?;
+            // We print with escapes escaped because the windows conpty
+            // implementation synthesizes title change escape sequences
+            // in the output stream and it can be confusing to see those
+            // printed out raw in another terminal.
+            print!("output: len={} ", line.len());
+            for c in line.escape_debug() {
+                print!("{}", c);
+            }
+            println!();
+        }
+
+        Ok(())
+    })
+}
diff --git a/vendor/portable-pty/src/cmdbuilder.rs b/vendor/portable-pty/src/cmdbuilder.rs
new file mode 100644
index 00000000..b4ce50a8
--- /dev/null
+++ b/vendor/portable-pty/src/cmdbuilder.rs
@@ -0,0 +1,823 @@
+#[cfg(unix)]
+use anyhow::Context;
+#[cfg(feature = "serde_support")]
+use serde_derive::*;
+use std::collections::BTreeMap;
+use std::ffi::{OsStr, OsString};
+#[cfg(windows)]
+use std::os::windows::ffi::OsStrExt;
+#[cfg(unix)]
+use std::path::Component;
+use std::path::Path;
+
+/// Used to deal with Windows having case-insensitive environment variables.
+#[derive(Clone, Debug, PartialEq, PartialOrd)]
+#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
+struct EnvEntry {
+    /// Whether or not this environment variable came from the base environment,
+    /// as opposed to having been explicitly set by the caller.
+    is_from_base_env: bool,
+
+    /// For case-insensitive platforms, the environment variable key in its preferred casing.
+    preferred_key: OsString,
+
+    /// The environment variable value.
+    value: OsString,
+}
+
+impl EnvEntry {
+    fn map_key(k: OsString) -> OsString {
+        if cfg!(windows) {
+            // Best-effort lowercase transformation of an os string
+            match k.to_str() {
+                Some(s) => s.to_lowercase().into(),
+                None => k,
+            }
+        } else {
+            k
+        }
+    }
+}
+
+#[cfg(unix)]
+fn get_shell() -> String {
+    use nix::unistd::{access, AccessFlags};
+    use std::ffi::CStr;
+    use std::str;
+
+    let ent = unsafe { libc::getpwuid(libc::getuid()) };
+    if !ent.is_null() {
+        let shell = unsafe { CStr::from_ptr((*ent).pw_shell) };
+        match shell.to_str().map(str::to_owned) {
+            Err(err) => {
+                log::warn!(
+                    "passwd database shell could not be \
+                     represented as utf-8: {err:#}, \
+                     falling back to /bin/sh"
+                );
+            }
+            Ok(shell) => {
+                if let Err(err) = access(Path::new(&shell), AccessFlags::X_OK) {
+                    log::warn!(
+                        "passwd database shell={shell:?} which is \
+                         not executable ({err:#}), falling back to /bin/sh"
+                    );
+                } else {
+                    return shell;
+                }
+            }
+        }
+    }
+    "/bin/sh".into()
+}
+
+fn get_base_env() -> BTreeMap<OsString, EnvEntry> {
+    let mut env: BTreeMap<OsString, EnvEntry> = std::env::vars_os()
+        .map(|(key, value)| {
+            (
+                EnvEntry::map_key(key.clone()),
+                EnvEntry {
+                    is_from_base_env: true,
+                    preferred_key: key,
+                    value,
+                },
+            )
+        })
+        .collect();
+
+    #[cfg(unix)]
+    {
+        let key = EnvEntry::map_key("SHELL".into());
+        // Only set the value of SHELL if it isn't already set
+        if !env.contains_key(&key) {
+            env.insert(
+                EnvEntry::map_key("SHELL".into()),
+                EnvEntry {
+                    is_from_base_env: true,
+                    preferred_key: "SHELL".into(),
+                    value: get_shell().into(),
+                },
+            );
+        }
+    }
+
+    #[cfg(windows)]
+    {
+        use std::os::windows::ffi::OsStringExt;
+        use winapi::um::processenv::ExpandEnvironmentStringsW;
+        use winreg::enums::{RegType, HKEY_CURRENT_USER, HKEY_LOCAL_MACHINE};
+        use winreg::types::FromRegValue;
+        use winreg::{RegKey, RegValue};
+
+        fn reg_value_to_string(value: &RegValue) -> anyhow::Result<OsString> {
+            match value.vtype {
+                RegType::REG_EXPAND_SZ => {
+                    let src = unsafe {
+                        std::slice::from_raw_parts(
+                            value.bytes.as_ptr() as *const u16,
+                            value.bytes.len() / 2,
+                        )
+                    };
+                    let size =
+                        unsafe { ExpandEnvironmentStringsW(src.as_ptr(), std::ptr::null_mut(), 0) };
+                    let mut buf = vec![0u16; size as usize + 1];
+                    unsafe {
+                        ExpandEnvironmentStringsW(src.as_ptr(), buf.as_mut_ptr(), buf.len() as u32)
+                    };
+
+                    let mut buf = buf.as_slice();
+                    while let Some(0) = buf.last() {
+                        buf = &buf[0..buf.len() - 1];
+                    }
+                    Ok(OsString::from_wide(buf))
+                }
+                _ => Ok(OsString::from_reg_value(value)?),
+            }
+        }
+
+        if let Ok(sys_env) = RegKey::predef(HKEY_LOCAL_MACHINE)
+            .open_subkey("System\\CurrentControlSet\\Control\\Session Manager\\Environment")
+        {
+            for res in sys_env.enum_values() {
+                if let Ok((name, value)) = res {
+                    if name.to_ascii_lowercase() == "username" {
+                        continue;
+                    }
+                    if let Ok(value) = reg_value_to_string(&value) {
+                        log::trace!("adding SYS env: {:?} {:?}", name, value);
+                        env.insert(
+                            EnvEntry::map_key(name.clone().into()),
+                            EnvEntry {
+                                is_from_base_env: true,
+                                preferred_key: name.into(),
+                                value,
+                            },
+                        );
+                    }
+                }
+            }
+        }
+
+        if let Ok(sys_env) = RegKey::predef(HKEY_CURRENT_USER).open_subkey("Environment") {
+            for res in sys_env.enum_values() {
+                if let Ok((name, value)) = res {
+                    if let Ok(value) = reg_value_to_string(&value) {
+                        // Merge the system and user paths together
+                        let value = if name.to_ascii_lowercase() == "path" {
+                            match env.get(&EnvEntry::map_key(name.clone().into())) {
+                                Some(entry) => {
+                                    let mut result = OsString::new();
+                                    result.push(&entry.value);
+                                    result.push(";");
+                                    result.push(&value);
+                                    result
+                                }
+                                None => value,
+                            }
+                        } else {
+                            value
+                        };
+
+                        log::trace!("adding USER env: {:?} {:?}", name, value);
+                        env.insert(
+                            EnvEntry::map_key(name.clone().into()),
+                            EnvEntry {
+                                is_from_base_env: true,
+                                preferred_key: name.into(),
+                                value,
+                            },
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    env
+}
+
+/// `CommandBuilder` is used to prepare a command to be spawned into a pty.
+/// The interface is intentionally similar to that of `std::process::Command`.
+#[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
+pub struct CommandBuilder {
+    args: Vec<OsString>,
+    envs: BTreeMap<OsString, EnvEntry>,
+    cwd: Option<OsString>,
+    #[cfg(unix)]
+    pub(crate) umask: Option<libc::mode_t>,
+    controlling_tty: bool,
+}
+
+impl CommandBuilder {
+    /// Create a new builder instance with argv\[0\] set to the specified
+    /// program.
+    pub fn new<S: AsRef<OsStr>>(program: S) -> Self {
+        Self {
+            args: vec![program.as_ref().to_owned()],
+            envs: get_base_env(),
+            cwd: None,
+            #[cfg(unix)]
+            umask: None,
+            controlling_tty: true,
+        }
+    }
+
+    /// Create a new builder instance from a pre-built argument vector
+    pub fn from_argv(args: Vec<OsString>) -> Self {
+        Self {
+            args,
+            envs: get_base_env(),
+            cwd: None,
+            #[cfg(unix)]
+            umask: None,
+            controlling_tty: true,
+        }
+    }
+
+    /// Set whether we should set the pty as the controlling terminal.
+    /// The default is true, which is usually what you want, but you
+    /// may need to set this to false if you are crossing container
+    /// boundaries (eg: flatpak) to workaround issues like:
+    /// <https://github.com/flatpak/flatpak/issues/3697>
+    /// <https://github.com/flatpak/flatpak/issues/3285>
+    pub fn set_controlling_tty(&mut self, controlling_tty: bool) {
+        self.controlling_tty = controlling_tty;
+    }
+
+    pub fn get_controlling_tty(&self) -> bool {
+        self.controlling_tty
+    }
+
+    /// Create a new builder instance that will run some idea of a default
+    /// program.  Such a builder will panic if `arg` is called on it.
+    pub fn new_default_prog() -> Self {
+        Self {
+            args: vec![],
+            envs: get_base_env(),
+            cwd: None,
+            #[cfg(unix)]
+            umask: None,
+            controlling_tty: true,
+        }
+    }
+
+    /// Returns true if this builder was created via `new_default_prog`
+    pub fn is_default_prog(&self) -> bool {
+        self.args.is_empty()
+    }
+
+    /// Append an argument to the current command line.
+    /// Will panic if called on a builder created via `new_default_prog`.
+    pub fn arg<S: AsRef<OsStr>>(&mut self, arg: S) {
+        if self.is_default_prog() {
+            panic!("attempted to add args to a default_prog builder");
+        }
+        self.args.push(arg.as_ref().to_owned());
+    }
+
+    /// Append a sequence of arguments to the current command line
+    pub fn args<I, S>(&mut self, args: I)
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<OsStr>,
+    {
+        for arg in args {
+            self.arg(arg);
+        }
+    }
+
+    pub fn get_argv(&self) -> &Vec<OsString> {
+        &self.args
+    }
+
+    pub fn get_argv_mut(&mut self) -> &mut Vec<OsString> {
+        &mut self.args
+    }
+
+    /// Override the value of an environmental variable
+    pub fn env<K, V>(&mut self, key: K, value: V)
+    where
+        K: AsRef<OsStr>,
+        V: AsRef<OsStr>,
+    {
+        let key: OsString = key.as_ref().into();
+        let value: OsString = value.as_ref().into();
+        self.envs.insert(
+            EnvEntry::map_key(key.clone()),
+            EnvEntry {
+                is_from_base_env: false,
+                preferred_key: key,
+                value: value,
+            },
+        );
+    }
+
+    pub fn env_remove<K>(&mut self, key: K)
+    where
+        K: AsRef<OsStr>,
+    {
+        let key = key.as_ref().into();
+        self.envs.remove(&EnvEntry::map_key(key));
+    }
+
+    pub fn env_clear(&mut self) {
+        self.envs.clear();
+    }
+
+    pub fn get_env<K>(&self, key: K) -> Option<&OsStr>
+    where
+        K: AsRef<OsStr>,
+    {
+        let key = key.as_ref().into();
+        self.envs.get(&EnvEntry::map_key(key)).map(
+            |EnvEntry {
+                 is_from_base_env: _,
+                 preferred_key: _,
+                 value,
+             }| value.as_os_str(),
+        )
+    }
+
+    pub fn cwd<D>(&mut self, dir: D)
+    where
+        D: AsRef<OsStr>,
+    {
+        self.cwd = Some(dir.as_ref().to_owned());
+    }
+
+    pub fn clear_cwd(&mut self) {
+        self.cwd.take();
+    }
+
+    pub fn get_cwd(&self) -> Option<&OsString> {
+        self.cwd.as_ref()
+    }
+
+    /// Iterate over the configured environment. Only includes environment
+    /// variables set by the caller via `env`, not variables set in the base
+    /// environment.
+    pub fn iter_extra_env_as_str(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.envs.values().filter_map(
+            |EnvEntry {
+                 is_from_base_env,
+                 preferred_key,
+                 value,
+             }| {
+                if *is_from_base_env {
+                    None
+                } else {
+                    let key = preferred_key.to_str()?;
+                    let value = value.to_str()?;
+                    Some((key, value))
+                }
+            },
+        )
+    }
+
+    pub fn iter_full_env_as_str(&self) -> impl Iterator<Item = (&str, &str)> {
+        self.envs.values().filter_map(
+            |EnvEntry {
+                 preferred_key,
+                 value,
+                 ..
+             }| {
+                let key = preferred_key.to_str()?;
+                let value = value.to_str()?;
+                Some((key, value))
+            },
+        )
+    }
+
+    /// Return the configured command and arguments as a single string,
+    /// quoted per the unix shell conventions.
+    pub fn as_unix_command_line(&self) -> anyhow::Result<String> {
+        let mut strs = vec![];
+        for arg in &self.args {
+            let s = arg
+                .to_str()
+                .ok_or_else(|| anyhow::anyhow!("argument cannot be represented as utf8"))?;
+            strs.push(s);
+        }
+        Ok(shell_words::join(strs))
+    }
+}
+
+#[cfg(unix)]
+impl CommandBuilder {
+    pub fn umask(&mut self, mask: Option<libc::mode_t>) {
+        self.umask = mask;
+    }
+
+    fn resolve_path(&self) -> Option<&OsStr> {
+        self.get_env("PATH")
+    }
+
+    fn search_path(&self, exe: &OsStr, cwd: &OsStr) -> anyhow::Result<OsString> {
+        use nix::unistd::{access, AccessFlags};
+
+        let exe_path: &Path = exe.as_ref();
+        if exe_path.is_relative() {
+            let cwd: &Path = cwd.as_ref();
+            let mut errors = vec![];
+
+            // If the requested executable is explicitly relative to cwd,
+            // then check only there.
+            if is_cwd_relative_path(exe_path) {
+                let abs_path = cwd.join(exe_path);
+
+                if abs_path.is_dir() {
+                    anyhow::bail!(
+                        "Unable to spawn {} because it is a directory",
+                        abs_path.display()
+                    );
+                } else if access(&abs_path, AccessFlags::X_OK).is_ok() {
+                    return Ok(abs_path.into_os_string());
+                } else if access(&abs_path, AccessFlags::F_OK).is_ok() {
+                    anyhow::bail!(
+                        "Unable to spawn {} because it is not executable",
+                        abs_path.display()
+                    );
+                }
+
+                anyhow::bail!(
+                    "Unable to spawn {} because it does not exist",
+                    abs_path.display()
+                );
+            }
+
+            if let Some(path) = self.resolve_path() {
+                for path in std::env::split_paths(&path) {
+                    let candidate = cwd.join(&path).join(&exe);
+
+                    if candidate.is_dir() {
+                        errors.push(format!("{} exists but is a directory", candidate.display()));
+                    } else if access(&candidate, AccessFlags::X_OK).is_ok() {
+                        return Ok(candidate.into_os_string());
+                    } else if access(&candidate, AccessFlags::F_OK).is_ok() {
+                        errors.push(format!(
+                            "{} exists but is not executable",
+                            candidate.display()
+                        ));
+                    }
+                }
+                errors.push(format!("No viable candidates found in PATH {path:?}"));
+            } else {
+                errors.push("Unable to resolve the PATH".to_string());
+            }
+            anyhow::bail!(
+                "Unable to spawn {} because:\n{}",
+                exe_path.display(),
+                errors.join(".\n")
+            );
+        } else if exe_path.is_dir() {
+            anyhow::bail!(
+                "Unable to spawn {} because it is a directory",
+                exe_path.display()
+            );
+        } else {
+            if let Err(err) = access(exe_path, AccessFlags::X_OK) {
+                if access(exe_path, AccessFlags::F_OK).is_ok() {
+                    anyhow::bail!(
+                        "Unable to spawn {} because it is not executable ({err:#})",
+                        exe_path.display()
+                    );
+                } else {
+                    anyhow::bail!(
+                        "Unable to spawn {} because it doesn't exist on the filesystem ({err:#})",
+                        exe_path.display()
+                    );
+                }
+            }
+
+            Ok(exe.to_owned())
+        }
+    }
+
+    /// Convert the CommandBuilder to a `std::process::Command` instance.
+    pub(crate) fn as_command(&self) -> anyhow::Result<std::process::Command> {
+        use std::os::unix::process::CommandExt;
+
+        let home = self.get_home_dir()?;
+        let dir: &OsStr = self
+            .cwd
+            .as_ref()
+            .map(|dir| dir.as_os_str())
+            .filter(|dir| std::path::Path::new(dir).is_dir())
+            .unwrap_or(home.as_ref());
+        let shell = self.get_shell();
+
+        let mut cmd = if self.is_default_prog() {
+            let mut cmd = std::process::Command::new(&shell);
+
+            // Run the shell as a login shell by prefixing the shell's
+            // basename with `-` and setting that as argv0
+            let basename = shell.rsplit('/').next().unwrap_or(&shell);
+            cmd.arg0(&format!("-{}", basename));
+            cmd
+        } else {
+            let resolved = self.search_path(&self.args[0], dir)?;
+            let mut cmd = std::process::Command::new(&resolved);
+            cmd.arg0(&self.args[0]);
+            cmd.args(&self.args[1..]);
+            cmd
+        };
+
+        cmd.current_dir(dir);
+
+        cmd.env_clear();
+        cmd.env("SHELL", shell);
+        cmd.envs(self.envs.values().map(
+            |EnvEntry {
+                 is_from_base_env: _,
+                 preferred_key,
+                 value,
+             }| (preferred_key.as_os_str(), value.as_os_str()),
+        ));
+
+        Ok(cmd)
+    }
+
+    /// Determine which shell to run.
+    /// We take the contents of the $SHELL env var first, then
+    /// fall back to looking it up from the password database.
+    pub fn get_shell(&self) -> String {
+        use nix::unistd::{access, AccessFlags};
+
+        if let Some(shell) = self.get_env("SHELL").and_then(OsStr::to_str) {
+            match access(shell, AccessFlags::X_OK) {
+                Ok(()) => return shell.into(),
+                Err(err) => log::warn!(
+                    "$SHELL -> {shell:?} which is \
+                     not executable ({err:#}), falling back to password db lookup"
+                ),
+            }
+        }
+
+        get_shell().into()
+    }
+
+    fn get_home_dir(&self) -> anyhow::Result<String> {
+        if let Some(home_dir) = self.get_env("HOME").and_then(OsStr::to_str) {
+            return Ok(home_dir.into());
+        }
+
+        let ent = unsafe { libc::getpwuid(libc::getuid()) };
+        if ent.is_null() {
+            Ok("/".into())
+        } else {
+            use std::ffi::CStr;
+            use std::str;
+            let home = unsafe { CStr::from_ptr((*ent).pw_dir) };
+            home.to_str()
+                .map(str::to_owned)
+                .context("failed to resolve home dir")
+        }
+    }
+}
+
+#[cfg(windows)]
+impl CommandBuilder {
+    fn search_path(&self, exe: &OsStr) -> OsString {
+        if let Some(path) = self.get_env("PATH") {
+            let extensions = self.get_env("PATHEXT").unwrap_or(OsStr::new(".EXE"));
+            for path in std::env::split_paths(&path) {
+                // Check for exactly the user's string in this path dir
+                let candidate = path.join(&exe);
+                if candidate.exists() {
+                    return candidate.into_os_string();
+                }
+
+                // otherwise try tacking on some extensions.
+                // Note that this really replaces the extension in the
+                // user specified path, so this is potentially wrong.
+                for ext in std::env::split_paths(&extensions) {
+                    // PATHEXT includes the leading `.`, but `with_extension`
+                    // doesn't want that
+                    let ext = ext.to_str().expect("PATHEXT entries must be utf8");
+                    let path = path.join(&exe).with_extension(&ext[1..]);
+                    if path.exists() {
+                        return path.into_os_string();
+                    }
+                }
+            }
+        }
+
+        exe.to_owned()
+    }
+
+    pub(crate) fn current_directory(&self) -> Option<Vec<u16>> {
+        let home: Option<&OsStr> = self
+            .get_env("USERPROFILE")
+            .filter(|path| Path::new(path).is_dir());
+        let cwd: Option<&OsStr> = self.cwd.as_deref().filter(|path| Path::new(path).is_dir());
+        let dir: Option<&OsStr> = cwd.or(home);
+
+        dir.map(|dir| {
+            let mut wide = vec![];
+
+            if Path::new(dir).is_relative() {
+                if let Ok(ccwd) = std::env::current_dir() {
+                    wide.extend(ccwd.join(dir).as_os_str().encode_wide());
+                } else {
+                    wide.extend(dir.encode_wide());
+                }
+            } else {
+                wide.extend(dir.encode_wide());
+            }
+
+            wide.push(0);
+            wide
+        })
+    }
+
+    /// Constructs an environment block for this spawn attempt.
+    /// Uses the current process environment as the base and then
+    /// adds/replaces the environment that was specified via the
+    /// `env` methods.
+    pub(crate) fn environment_block(&self) -> Vec<u16> {
+        // encode the environment as wide characters
+        let mut block = vec![];
+
+        for EnvEntry {
+            is_from_base_env: _,
+            preferred_key,
+            value,
+        } in self.envs.values()
+        {
+            block.extend(preferred_key.encode_wide());
+            block.push(b'=' as u16);
+            block.extend(value.encode_wide());
+            block.push(0);
+        }
+        // and a final terminator for CreateProcessW
+        block.push(0);
+
+        block
+    }
+
+    pub fn get_shell(&self) -> String {
+        let exe: OsString = self
+            .get_env("ComSpec")
+            .unwrap_or(OsStr::new("cmd.exe"))
+            .into();
+        exe.into_string()
+            .unwrap_or_else(|_| "%CompSpec%".to_string())
+    }
+
+    pub(crate) fn cmdline(&self) -> anyhow::Result<(Vec<u16>, Vec<u16>)> {
+        let mut cmdline = Vec::<u16>::new();
+
+        let exe: OsString = if self.is_default_prog() {
+            self.get_env("ComSpec")
+                .unwrap_or(OsStr::new("cmd.exe"))
+                .into()
+        } else {
+            self.search_path(&self.args[0])
+        };
+
+        Self::append_quoted(&exe, &mut cmdline);
+
+        // Ensure that we nul terminate the module name, otherwise we'll
+        // ask CreateProcessW to start something random!
+        let mut exe: Vec<u16> = exe.encode_wide().collect();
+        exe.push(0);
+
+        for arg in self.args.iter().skip(1) {
+            cmdline.push(' ' as u16);
+            anyhow::ensure!(
+                !arg.encode_wide().any(|c| c == 0),
+                "invalid encoding for command line argument {:?}",
+                arg
+            );
+            Self::append_quoted(arg, &mut cmdline);
+        }
+        // Ensure that the command line is nul terminated too!
+        cmdline.push(0);
+        Ok((exe, cmdline))
+    }
+
+    // Borrowed from https://github.com/hniksic/rust-subprocess/blob/873dfed165173e52907beb87118b2c0c05d8b8a1/src/popen.rs#L1117
+    // which in turn was translated from ArgvQuote at http://tinyurl.com/zmgtnls
+    fn append_quoted(arg: &OsStr, cmdline: &mut Vec<u16>) {
+        if !arg.is_empty()
+            && !arg.encode_wide().any(|c| {
+                c == ' ' as u16
+                    || c == '\t' as u16
+                    || c == '\n' as u16
+                    || c == '\x0b' as u16
+                    || c == '\"' as u16
+            })
+        {
+            cmdline.extend(arg.encode_wide());
+            return;
+        }
+        cmdline.push('"' as u16);
+
+        let arg: Vec<_> = arg.encode_wide().collect();
+        let mut i = 0;
+        while i < arg.len() {
+            let mut num_backslashes = 0;
+            while i < arg.len() && arg[i] == '\\' as u16 {
+                i += 1;
+                num_backslashes += 1;
+            }
+
+            if i == arg.len() {
+                for _ in 0..num_backslashes * 2 {
+                    cmdline.push('\\' as u16);
+                }
+                break;
+            } else if arg[i] == b'"' as u16 {
+                for _ in 0..num_backslashes * 2 + 1 {
+                    cmdline.push('\\' as u16);
+                }
+                cmdline.push(arg[i]);
+            } else {
+                for _ in 0..num_backslashes {
+                    cmdline.push('\\' as u16);
+                }
+                cmdline.push(arg[i]);
+            }
+            i += 1;
+        }
+        cmdline.push('"' as u16);
+    }
+}
+
+#[cfg(unix)]
+/// Returns true if the path begins with `./` or `../`
+fn is_cwd_relative_path<P: AsRef<Path>>(p: P) -> bool {
+    matches!(
+        p.as_ref().components().next(),
+        Some(Component::CurDir | Component::ParentDir)
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(unix)]
+    #[test]
+    fn test_cwd_relative() {
+        assert!(is_cwd_relative_path("."));
+        assert!(is_cwd_relative_path("./foo"));
+        assert!(is_cwd_relative_path("../foo"));
+        assert!(!is_cwd_relative_path("foo"));
+        assert!(!is_cwd_relative_path("/foo"));
+    }
+
+    #[test]
+    fn test_env() {
+        let mut cmd = CommandBuilder::new("dummy");
+        let package_authors = cmd.get_env("CARGO_PKG_AUTHORS");
+        println!("package_authors: {:?}", package_authors);
+        assert!(package_authors == Some(OsStr::new("Wez Furlong")));
+
+        cmd.env("foo key", "foo value");
+        cmd.env("bar key", "bar value");
+
+        let iterated_envs = cmd.iter_extra_env_as_str().collect::<Vec<_>>();
+        println!("iterated_envs: {:?}", iterated_envs);
+        assert!(iterated_envs == vec![("bar key", "bar value"), ("foo key", "foo value")]);
+
+        {
+            let mut cmd = cmd.clone();
+            cmd.env_remove("foo key");
+
+            let iterated_envs = cmd.iter_extra_env_as_str().collect::<Vec<_>>();
+            println!("iterated_envs: {:?}", iterated_envs);
+            assert!(iterated_envs == vec![("bar key", "bar value")]);
+        }
+
+        {
+            let mut cmd = cmd.clone();
+            cmd.env_remove("bar key");
+
+            let iterated_envs = cmd.iter_extra_env_as_str().collect::<Vec<_>>();
+            println!("iterated_envs: {:?}", iterated_envs);
+            assert!(iterated_envs == vec![("foo key", "foo value")]);
+        }
+
+        {
+            let mut cmd = cmd.clone();
+            cmd.env_clear();
+
+            let iterated_envs = cmd.iter_extra_env_as_str().collect::<Vec<_>>();
+            println!("iterated_envs: {:?}", iterated_envs);
+            assert!(iterated_envs.is_empty());
+        }
+    }
+
+    #[cfg(windows)]
+    #[test]
+    fn test_env_case_insensitive_override() {
+        let mut cmd = CommandBuilder::new("dummy");
+        cmd.env("Cargo_Pkg_Authors", "Not Wez");
+        assert!(cmd.get_env("cargo_pkg_authors") == Some(OsStr::new("Not Wez")));
+
+        cmd.env_remove("cARGO_pKG_aUTHORS");
+        assert!(cmd.get_env("CARGO_PKG_AUTHORS").is_none());
+    }
+}
diff --git a/vendor/portable-pty/src/lib.rs b/vendor/portable-pty/src/lib.rs
new file mode 100644
index 00000000..fbf85c45
--- /dev/null
+++ b/vendor/portable-pty/src/lib.rs
@@ -0,0 +1,418 @@
+//! This crate provides a cross platform API for working with the
+//! psuedo terminal (pty) interfaces provided by the system.
+//! Unlike other crates in this space, this crate provides a set
+//! of traits that allow selecting from different implementations
+//! at runtime.
+//! This crate is part of [wezterm](https://github.com/wezterm/wezterm).
+//!
+//! ```no_run
+//! use portable_pty::{CommandBuilder, PtySize, native_pty_system, PtySystem};
+//! use anyhow::Error;
+//!
+//! // Use the native pty implementation for the system
+//! let pty_system = native_pty_system();
+//!
+//! // Create a new pty
+//! let mut pair = pty_system.openpty(PtySize {
+//!     rows: 24,
+//!     cols: 80,
+//!     // Not all systems support pixel_width, pixel_height,
+//!     // but it is good practice to set it to something
+//!     // that matches the size of the selected font.  That
+//!     // is more complex than can be shown here in this
+//!     // brief example though!
+//!     pixel_width: 0,
+//!     pixel_height: 0,
+//! })?;
+//!
+//! // Spawn a shell into the pty
+//! let cmd = CommandBuilder::new("bash");
+//! let child = pair.slave.spawn_command(cmd)?;
+//!
+//! // Read and parse output from the pty with reader
+//! let mut reader = pair.master.try_clone_reader()?;
+//!
+//! // Send data to the pty by writing to the master
+//! writeln!(pair.master.take_writer()?, "ls -l\r\n")?;
+//! # Ok::<(), Error>(())
+//! ```
+//!
+use anyhow::Error;
+use downcast_rs::{impl_downcast, Downcast};
+#[cfg(unix)]
+use libc;
+#[cfg(feature = "serde_support")]
+use serde_derive::*;
+use std::io::Result as IoResult;
+#[cfg(windows)]
+use std::os::windows::prelude::{AsRawHandle, RawHandle};
+
+pub mod cmdbuilder;
+pub use cmdbuilder::CommandBuilder;
+
+#[cfg(unix)]
+pub mod unix;
+#[cfg(windows)]
+pub mod win;
+
+pub mod serial;
+
+/// Represents the size of the visible display area in the pty
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde_support", derive(Serialize, Deserialize))]
+pub struct PtySize {
+    /// The number of lines of text
+    pub rows: u16,
+    /// The number of columns of text
+    pub cols: u16,
+    /// The width of a cell in pixels.  Note that some systems never
+    /// fill this value and ignore it.
+    pub pixel_width: u16,
+    /// The height of a cell in pixels.  Note that some systems never
+    /// fill this value and ignore it.
+    pub pixel_height: u16,
+}
+
+impl Default for PtySize {
+    fn default() -> Self {
+        PtySize {
+            rows: 24,
+            cols: 80,
+            pixel_width: 0,
+            pixel_height: 0,
+        }
+    }
+}
+
+/// Represents the master/control end of the pty
+pub trait MasterPty: Downcast + Send {
+    /// Inform the kernel and thus the child process that the window resized.
+    /// It will update the winsize information maintained by the kernel,
+    /// and generate a signal for the child to notice and update its state.
+    fn resize(&self, size: PtySize) -> Result<(), Error>;
+    /// Retrieves the size of the pty as known by the kernel
+    fn get_size(&self) -> Result<PtySize, Error>;
+    /// Obtain a readable handle; output from the slave(s) is readable
+    /// via this stream.
+    fn try_clone_reader(&self) -> Result<Box<dyn std::io::Read + Send>, Error>;
+    /// Obtain a writable handle; writing to it will send data to the
+    /// slave end.
+    /// Dropping the writer will send EOF to the slave end.
+    /// It is invalid to take the writer more than once.
+    fn take_writer(&self) -> Result<Box<dyn std::io::Write + Send>, Error>;
+
+    /// If applicable to the type of the tty, return the local process id
+    /// of the process group or session leader
+    #[cfg(unix)]
+    fn process_group_leader(&self) -> Option<libc::pid_t>;
+
+    /// If get_termios() and process_group_leader() are both implemented and
+    /// return Some, then as_raw_fd() should return the same underlying fd
+    /// associated with the stream. This is to enable applications that
+    /// "know things" to query similar information for themselves.
+    #[cfg(unix)]
+    fn as_raw_fd(&self) -> Option<unix::RawFd>;
+
+    #[cfg(unix)]
+    fn tty_name(&self) -> Option<std::path::PathBuf>;
+
+    /// If applicable to the type of the tty, return the termios
+    /// associated with the stream
+    #[cfg(unix)]
+    fn get_termios(&self) -> Option<nix::sys::termios::Termios> {
+        None
+    }
+}
+impl_downcast!(MasterPty);
+
+/// Represents a child process spawned into the pty.
+/// This handle can be used to wait for or terminate that child process.
+pub trait Child: std::fmt::Debug + ChildKiller + Downcast + Send {
+    /// Poll the child to see if it has completed.
+    /// Does not block.
+    /// Returns None if the child has not yet terminated,
+    /// else returns its exit status.
+    fn try_wait(&mut self) -> IoResult<Option<ExitStatus>>;
+    /// Blocks execution until the child process has completed,
+    /// yielding its exit status.
+    fn wait(&mut self) -> IoResult<ExitStatus>;
+    /// Returns the process identifier of the child process,
+    /// if applicable
+    fn process_id(&self) -> Option<u32>;
+    /// Returns the process handle of the child process, if applicable.
+    /// Only available on Windows.
+    #[cfg(windows)]
+    fn as_raw_handle(&self) -> Option<std::os::windows::io::RawHandle>;
+}
+impl_downcast!(Child);
+
+/// Represents the ability to signal a Child to terminate
+pub trait ChildKiller: std::fmt::Debug + Downcast + Send {
+    /// Terminate the child process
+    fn kill(&mut self) -> IoResult<()>;
+
+    /// Clone an object that can be split out from the Child in order
+    /// to send it signals independently from a thread that may be
+    /// blocked in `.wait`.
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync>;
+}
+impl_downcast!(ChildKiller);
+
+/// Represents the slave side of a pty.
+/// Can be used to spawn processes into the pty.
+pub trait SlavePty {
+    /// Spawns the command specified by the provided CommandBuilder
+    fn spawn_command(&self, cmd: CommandBuilder) -> Result<Box<dyn Child + Send + Sync>, Error>;
+
+    /// Spawns a Windows child in the supplied job before any child code runs.
+    /// Returns an error if this PTY implementation cannot assign a job atomically.
+    #[cfg(windows)]
+    fn spawn_command_in_job(
+        &self,
+        _cmd: CommandBuilder,
+        _job: std::os::windows::io::BorrowedHandle<'_>,
+    ) -> Result<Box<dyn Child + Send + Sync>, Error> {
+        anyhow::bail!("This PTY does not support atomic Windows job assignment")
+    }
+}
+
+/// Represents the exit status of a child process.
+#[derive(Debug, Clone)]
+pub struct ExitStatus {
+    code: u32,
+    signal: Option<String>,
+}
+
+impl ExitStatus {
+    /// Construct an ExitStatus from a process return code
+    pub fn with_exit_code(code: u32) -> Self {
+        Self { code, signal: None }
+    }
+
+    /// Construct an ExitStatus from a signal name
+    pub fn with_signal(signal: &str) -> Self {
+        Self {
+            code: 1,
+            signal: Some(signal.to_string()),
+        }
+    }
+
+    /// Returns true if the status indicates successful completion
+    pub fn success(&self) -> bool {
+        match self.signal {
+            None => self.code == 0,
+            Some(_) => false,
+        }
+    }
+
+    /// Returns the exit code that this ExitStatus was constructed with
+    pub fn exit_code(&self) -> u32 {
+        self.code
+    }
+
+    /// Returns the signal if present that this ExitStatus was constructed with
+    pub fn signal(&self) -> Option<&str> {
+        self.signal.as_deref()
+    }
+}
+
+impl From<std::process::ExitStatus> for ExitStatus {
+    fn from(status: std::process::ExitStatus) -> ExitStatus {
+        #[cfg(unix)]
+        {
+            use std::os::unix::process::ExitStatusExt;
+
+            if let Some(signal) = status.signal() {
+                let signame = unsafe { libc::strsignal(signal) };
+                let signal = if signame.is_null() {
+                    format!("Signal {}", signal)
+                } else {
+                    let signame = unsafe { std::ffi::CStr::from_ptr(signame) };
+                    signame.to_string_lossy().to_string()
+                };
+
+                return ExitStatus {
+                    code: status.code().map(|c| c as u32).unwrap_or(1),
+                    signal: Some(signal),
+                };
+            }
+        }
+
+        let code =
+            status
+                .code()
+                .map(|c| c as u32)
+                .unwrap_or_else(|| if status.success() { 0 } else { 1 });
+
+        ExitStatus { code, signal: None }
+    }
+}
+
+impl std::fmt::Display for ExitStatus {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+        if self.success() {
+            write!(fmt, "Success")
+        } else {
+            match &self.signal {
+                Some(sig) => write!(fmt, "Terminated by {}", sig),
+                None => write!(fmt, "Exited with code {}", self.code),
+            }
+        }
+    }
+}
+
+pub struct PtyPair {
+    // slave is listed first so that it is dropped first.
+    // The drop order is stable and specified by rust rfc 1857
+    pub slave: Box<dyn SlavePty + Send>,
+    pub master: Box<dyn MasterPty + Send>,
+}
+
+/// The `PtySystem` trait allows an application to work with multiple
+/// possible Pty implementations at runtime.  This is important on
+/// Windows systems which have a variety of implementations.
+pub trait PtySystem: Downcast {
+    /// Create a new Pty instance with the window size set to the specified
+    /// dimensions.  Returns a (master, slave) Pty pair.  The master side
+    /// is used to drive the slave side.
+    fn openpty(&self, size: PtySize) -> anyhow::Result<PtyPair>;
+}
+impl_downcast!(PtySystem);
+
+impl Child for std::process::Child {
+    fn try_wait(&mut self) -> IoResult<Option<ExitStatus>> {
+        std::process::Child::try_wait(self).map(|s| match s {
+            Some(s) => Some(s.into()),
+            None => None,
+        })
+    }
+
+    fn wait(&mut self) -> IoResult<ExitStatus> {
+        std::process::Child::wait(self).map(Into::into)
+    }
+
+    fn process_id(&self) -> Option<u32> {
+        Some(self.id())
+    }
+
+    #[cfg(windows)]
+    fn as_raw_handle(&self) -> Option<std::os::windows::io::RawHandle> {
+        Some(std::os::windows::io::AsRawHandle::as_raw_handle(self))
+    }
+}
+
+#[derive(Debug)]
+struct ProcessSignaller {
+    pid: Option<u32>,
+
+    #[cfg(windows)]
+    handle: Option<filedescriptor::OwnedHandle>,
+}
+
+#[cfg(windows)]
+impl ChildKiller for ProcessSignaller {
+    fn kill(&mut self) -> IoResult<()> {
+        if let Some(handle) = &self.handle {
+            unsafe {
+                if winapi::um::processthreadsapi::TerminateProcess(handle.as_raw_handle() as _, 127)
+                    == 0
+                {
+                    return Err(std::io::Error::last_os_error());
+                }
+            }
+        }
+        Ok(())
+    }
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        Box::new(Self {
+            pid: self.pid,
+            handle: self.handle.as_ref().and_then(|h| h.try_clone().ok()),
+        })
+    }
+}
+
+#[cfg(unix)]
+impl ChildKiller for ProcessSignaller {
+    fn kill(&mut self) -> IoResult<()> {
+        if let Some(pid) = self.pid {
+            let result = unsafe { libc::kill(pid as i32, libc::SIGHUP) };
+            if result != 0 {
+                return Err(std::io::Error::last_os_error());
+            }
+        }
+        Ok(())
+    }
+
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        Box::new(Self { pid: self.pid })
+    }
+}
+
+impl ChildKiller for std::process::Child {
+    fn kill(&mut self) -> IoResult<()> {
+        #[cfg(unix)]
+        {
+            // On unix, we send the SIGHUP signal instead of trying to kill
+            // the process. The default behavior of a process receiving this
+            // signal is to be killed unless it configured a signal handler.
+            let result = unsafe { libc::kill(self.id() as i32, libc::SIGHUP) };
+            if result != 0 {
+                return Err(std::io::Error::last_os_error());
+            }
+
+            // We successfully delivered SIGHUP, but the semantics of Child::kill
+            // are that on success the process is dead or shortly about to
+            // terminate.  Since SIGUP doesn't guarantee termination, we
+            // give the process a bit of a grace period to shutdown or do whatever
+            // it is doing in its signal handler befre we proceed with the
+            // full on kill.
+            for attempt in 0..5 {
+                if attempt > 0 {
+                    std::thread::sleep(std::time::Duration::from_millis(50));
+                }
+
+                if let Ok(Some(_)) = self.try_wait() {
+                    // It completed, so report success!
+                    return Ok(());
+                }
+            }
+
+            // it's still alive after a grace period, so proceed with a kill
+        }
+
+        std::process::Child::kill(self)
+    }
+
+    #[cfg(windows)]
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        struct RawDup(RawHandle);
+        impl AsRawHandle for RawDup {
+            fn as_raw_handle(&self) -> RawHandle {
+                self.0
+            }
+        }
+
+        Box::new(ProcessSignaller {
+            pid: self.process_id(),
+            handle: Child::as_raw_handle(self)
+                .as_ref()
+                .and_then(|h| filedescriptor::OwnedHandle::dup(&RawDup(*h)).ok()),
+        })
+    }
+
+    #[cfg(unix)]
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        Box::new(ProcessSignaller {
+            pid: self.process_id(),
+        })
+    }
+}
+
+pub fn native_pty_system() -> Box<dyn PtySystem + Send> {
+    Box::new(NativePtySystem::default())
+}
+
+#[cfg(unix)]
+pub type NativePtySystem = unix::UnixPtySystem;
+#[cfg(windows)]
+pub type NativePtySystem = win::conpty::ConPtySystem;
diff --git a/vendor/portable-pty/src/serial.rs b/vendor/portable-pty/src/serial.rs
new file mode 100644
index 00000000..948ba108
--- /dev/null
+++ b/vendor/portable-pty/src/serial.rs
@@ -0,0 +1,305 @@
+//! This module implements a serial port based tty.
+//! This is a bit different from the other implementations in that
+//! we cannot explicitly spawn a process into the serial connection,
+//! so we can only use a `CommandBuilder::new_default_prog` with the
+//! `openpty` method.
+//! On most (all?) systems, attempting to open multiple instances of
+//! the same serial port will fail.
+use crate::{
+    Child, ChildKiller, CommandBuilder, ExitStatus, MasterPty, PtyPair, PtySize, PtySystem,
+    SlavePty,
+};
+use anyhow::{ensure, Context};
+use filedescriptor::FileDescriptor;
+use serial2::{CharSize, FlowControl, Parity, SerialPort, StopBits};
+use std::cell::RefCell;
+use std::ffi::{OsStr, OsString};
+use std::io::{Read, Result as IoResult, Write};
+#[cfg(unix)]
+use std::path::PathBuf;
+use std::sync::Arc;
+use std::time::Duration;
+
+type Handle = Arc<SerialPort>;
+
+pub struct SerialTty {
+    port: OsString,
+    baud: u32,
+    char_size: CharSize,
+    parity: Parity,
+    stop_bits: StopBits,
+    flow_control: FlowControl,
+}
+
+impl SerialTty {
+    pub fn new<T: AsRef<OsStr> + ?Sized>(port: &T) -> Self {
+        Self {
+            port: port.as_ref().to_owned(),
+            baud: 9600,
+            char_size: CharSize::Bits8,
+            parity: Parity::None,
+            stop_bits: StopBits::One,
+            flow_control: FlowControl::XonXoff,
+        }
+    }
+
+    pub fn set_baud_rate(&mut self, baud: u32) {
+        self.baud = baud;
+    }
+
+    pub fn set_char_size(&mut self, char_size: CharSize) {
+        self.char_size = char_size;
+    }
+
+    pub fn set_parity(&mut self, parity: Parity) {
+        self.parity = parity;
+    }
+
+    pub fn set_stop_bits(&mut self, stop_bits: StopBits) {
+        self.stop_bits = stop_bits;
+    }
+
+    pub fn set_flow_control(&mut self, flow_control: FlowControl) {
+        self.flow_control = flow_control;
+    }
+}
+
+impl PtySystem for SerialTty {
+    fn openpty(&self, _size: PtySize) -> anyhow::Result<PtyPair> {
+        let mut port = SerialPort::open(&self.port, self.baud)
+            .with_context(|| format!("openpty on serial port {:?}", self.port))?;
+
+        let mut settings = port.get_configuration()?;
+        settings.set_raw();
+        settings.set_baud_rate(self.baud)?;
+        settings.set_char_size(self.char_size);
+        settings.set_flow_control(self.flow_control);
+        settings.set_parity(self.parity);
+        settings.set_stop_bits(self.stop_bits);
+        log::debug!("serial settings: {:#?}", port.get_configuration());
+        port.set_configuration(&settings)?;
+
+        // The timeout needs to be rather short because, at least on Windows,
+        // a read with a long timeout will block a concurrent write from
+        // happening.  In wezterm we tend to have a thread looping on read
+        // while writes happen occasionally from the gui thread, and if we
+        // make this timeout too long we can block the gui thread.
+        port.set_read_timeout(Duration::from_millis(50))?;
+        port.set_write_timeout(Duration::from_millis(50))?;
+
+        let port: Handle = Arc::new(port);
+
+        Ok(PtyPair {
+            slave: Box::new(Slave {
+                port: Arc::clone(&port),
+            }),
+            master: Box::new(Master {
+                port,
+                took_writer: RefCell::new(false),
+            }),
+        })
+    }
+}
+
+struct Slave {
+    port: Handle,
+}
+
+impl SlavePty for Slave {
+    fn spawn_command(&self, cmd: CommandBuilder) -> anyhow::Result<Box<dyn Child + Send + Sync>> {
+        ensure!(
+            cmd.is_default_prog(),
+            "can only use default prog commands with serial tty implementations"
+        );
+        Ok(Box::new(SerialChild {
+            port: Arc::clone(&self.port),
+        }))
+    }
+}
+
+/// There isn't really a child process on the end of the serial connection,
+/// so all of the Child trait impls are NOP
+struct SerialChild {
+    port: Handle,
+}
+
+// An anemic impl of Debug to satisfy some indirect trait bounds
+impl std::fmt::Debug for SerialChild {
+    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        fmt.debug_struct("SerialChild").finish()
+    }
+}
+
+impl Child for SerialChild {
+    fn try_wait(&mut self) -> IoResult<Option<ExitStatus>> {
+        Ok(None)
+    }
+
+    fn wait(&mut self) -> IoResult<ExitStatus> {
+        // There isn't really a child process to wait for,
+        // as the serial connection never really "dies",
+        // however, for something like a USB serial port,
+        // if it is unplugged then it logically is terminated.
+        // We read the CD (carrier detect) signal periodically
+        // to see if the device has gone away: we actually discard
+        // the CD value itself and just look for an error state.
+        // We could potentially also decide to call CD==false the
+        // same thing as the "child" completing.
+        loop {
+            std::thread::sleep(Duration::from_secs(5));
+
+            let port = &self.port;
+            if let Err(err) = port.read_cd() {
+                log::error!("Error reading carrier detect: {:#}", err);
+                return Ok(ExitStatus::with_exit_code(1));
+            }
+        }
+    }
+
+    fn process_id(&self) -> Option<u32> {
+        None
+    }
+
+    #[cfg(windows)]
+    fn as_raw_handle(&self) -> Option<std::os::windows::io::RawHandle> {
+        None
+    }
+}
+
+impl ChildKiller for SerialChild {
+    fn kill(&mut self) -> IoResult<()> {
+        Ok(())
+    }
+
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        Box::new(SerialChildKiller)
+    }
+}
+
+#[derive(Debug)]
+struct SerialChildKiller;
+
+impl ChildKiller for SerialChildKiller {
+    fn kill(&mut self) -> IoResult<()> {
+        Ok(())
+    }
+
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        Box::new(SerialChildKiller)
+    }
+}
+
+struct Master {
+    port: Handle,
+    took_writer: RefCell<bool>,
+}
+
+struct MasterWriter {
+    port: Handle,
+}
+
+impl Write for MasterWriter {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, std::io::Error> {
+        self.port.write(buf)
+    }
+
+    fn flush(&mut self) -> Result<(), std::io::Error> {
+        self.port.flush()
+    }
+}
+
+impl MasterPty for Master {
+    fn resize(&self, _size: PtySize) -> anyhow::Result<()> {
+        // Serial ports have no concept of size
+        Ok(())
+    }
+
+    fn get_size(&self) -> anyhow::Result<PtySize> {
+        // Serial ports have no concept of size
+        Ok(PtySize::default())
+    }
+
+    fn try_clone_reader(&self) -> anyhow::Result<Box<dyn std::io::Read + Send>> {
+        // We rely on the fact that SystemPort implements the traits
+        // that expose the underlying file descriptor, and that direct
+        // reads from that return the raw data that we want
+        let fd = FileDescriptor::dup(&*self.port)?;
+        Ok(Box::new(Reader { fd }))
+    }
+
+    fn take_writer(&self) -> anyhow::Result<Box<dyn std::io::Write + Send>> {
+        if *self.took_writer.borrow() {
+            anyhow::bail!("cannot take writer more than once");
+        }
+        *self.took_writer.borrow_mut() = true;
+        let port = Arc::clone(&self.port);
+        Ok(Box::new(MasterWriter { port }))
+    }
+
+    #[cfg(unix)]
+    fn process_group_leader(&self) -> Option<libc::pid_t> {
+        // N/A: there is no local process
+        None
+    }
+
+    #[cfg(unix)]
+    fn as_raw_fd(&self) -> Option<crate::unix::RawFd> {
+        None
+    }
+
+    #[cfg(unix)]
+    fn tty_name(&self) -> Option<PathBuf> {
+        None
+    }
+}
+
+struct Reader {
+    fd: FileDescriptor,
+}
+
+impl Read for Reader {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
+        // On windows, this self.fd.read will block for up to the time we set
+        // as the timeout when we set up the port, but on unix it will
+        // never block.
+        loop {
+            #[cfg(unix)]
+            {
+                use filedescriptor::{poll, pollfd, AsRawSocketDescriptor, POLLIN};
+                // The serial crate puts the serial port in non-blocking mode,
+                // so we must explicitly poll for ourselves here to avoid a
+                // busy loop.
+                let mut poll_array = [pollfd {
+                    fd: self.fd.as_socket_descriptor(),
+                    events: POLLIN,
+                    revents: 0,
+                }];
+                let _ = poll(&mut poll_array, None);
+            }
+
+            match self.fd.read(buf) {
+                Ok(0) => {
+                    if cfg!(windows) {
+                        // Read timeout with no data available yet;
+                        // loop and try again.
+                        continue;
+                    }
+                    return Err(std::io::Error::new(
+                        std::io::ErrorKind::UnexpectedEof,
+                        "EOF on serial port",
+                    ));
+                }
+                Ok(size) => {
+                    return Ok(size);
+                }
+                Err(e) => {
+                    if e.kind() == std::io::ErrorKind::WouldBlock {
+                        continue;
+                    }
+                    log::error!("serial read error: {}", e);
+                    return Err(e);
+                }
+            }
+        }
+    }
+}
diff --git a/vendor/portable-pty/src/unix.rs b/vendor/portable-pty/src/unix.rs
new file mode 100644
index 00000000..cc458ce9
--- /dev/null
+++ b/vendor/portable-pty/src/unix.rs
@@ -0,0 +1,414 @@
+//! Working with pseudo-terminals
+
+use crate::{Child, CommandBuilder, MasterPty, PtyPair, PtySize, PtySystem, SlavePty};
+use anyhow::{bail, Error};
+use filedescriptor::FileDescriptor;
+use libc::{self, winsize};
+use std::cell::RefCell;
+use std::ffi::OsStr;
+use std::io::{Read, Write};
+use std::os::fd::AsFd;
+use std::os::unix::ffi::OsStrExt;
+use std::os::unix::io::{AsRawFd, FromRawFd};
+use std::os::unix::process::CommandExt;
+use std::path::PathBuf;
+use std::{io, mem, ptr};
+
+pub use std::os::unix::io::RawFd;
+
+#[derive(Default)]
+pub struct UnixPtySystem {}
+
+fn openpty(size: PtySize) -> anyhow::Result<(UnixMasterPty, UnixSlavePty)> {
+    let mut master: RawFd = -1;
+    let mut slave: RawFd = -1;
+
+    let mut size = winsize {
+        ws_row: size.rows,
+        ws_col: size.cols,
+        ws_xpixel: size.pixel_width,
+        ws_ypixel: size.pixel_height,
+    };
+
+    let result = unsafe {
+        // BSDish systems may require mut pointers to some args
+        #[allow(clippy::unnecessary_mut_passed)]
+        libc::openpty(
+            &mut master,
+            &mut slave,
+            ptr::null_mut(),
+            ptr::null_mut(),
+            &mut size,
+        )
+    };
+
+    if result != 0 {
+        bail!("failed to openpty: {:?}", io::Error::last_os_error());
+    }
+
+    let tty_name = tty_name(slave);
+
+    let master = UnixMasterPty {
+        fd: PtyFd(unsafe { FileDescriptor::from_raw_fd(master) }),
+        took_writer: RefCell::new(false),
+        tty_name,
+    };
+    let slave = UnixSlavePty {
+        fd: PtyFd(unsafe { FileDescriptor::from_raw_fd(slave) }),
+    };
+
+    // Ensure that these descriptors will get closed when we execute
+    // the child process.  This is done after constructing the Pty
+    // instances so that we ensure that the Ptys get drop()'d if
+    // the cloexec() functions fail (unlikely!).
+    cloexec(master.fd.as_raw_fd())?;
+    cloexec(slave.fd.as_raw_fd())?;
+
+    Ok((master, slave))
+}
+
+impl PtySystem for UnixPtySystem {
+    fn openpty(&self, size: PtySize) -> anyhow::Result<PtyPair> {
+        let (master, slave) = openpty(size)?;
+        Ok(PtyPair {
+            master: Box::new(master),
+            slave: Box::new(slave),
+        })
+    }
+}
+
+struct PtyFd(pub FileDescriptor);
+impl std::ops::Deref for PtyFd {
+    type Target = FileDescriptor;
+    fn deref(&self) -> &FileDescriptor {
+        &self.0
+    }
+}
+impl std::ops::DerefMut for PtyFd {
+    fn deref_mut(&mut self) -> &mut FileDescriptor {
+        &mut self.0
+    }
+}
+
+impl Read for PtyFd {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize, io::Error> {
+        match self.0.read(buf) {
+            Err(ref e) if e.raw_os_error() == Some(libc::EIO) => {
+                // EIO indicates that the slave pty has been closed.
+                // Treat this as EOF so that std::io::Read::read_to_string
+                // and similar functions gracefully terminate when they
+                // encounter this condition
+                Ok(0)
+            }
+            x => x,
+        }
+    }
+}
+
+fn tty_name(fd: RawFd) -> Option<PathBuf> {
+    let mut buf = vec![0 as std::ffi::c_char; 128];
+
+    loop {
+        let res = unsafe { libc::ttyname_r(fd, buf.as_mut_ptr(), buf.len()) };
+
+        if res == libc::ERANGE {
+            if buf.len() > 64 * 1024 {
+                // on macOS, if the buf is "too big", ttyname_r can
+                // return ERANGE, even though that is supposed to
+                // indicate buf is "too small".
+                return None;
+            }
+            buf.resize(buf.len() * 2, 0 as std::ffi::c_char);
+            continue;
+        }
+
+        return if res == 0 {
+            let cstr = unsafe { std::ffi::CStr::from_ptr(buf.as_ptr()) };
+            let osstr = OsStr::from_bytes(cstr.to_bytes());
+            Some(PathBuf::from(osstr))
+        } else {
+            None
+        };
+    }
+}
+
+/// On Big Sur, Cocoa leaks various file descriptors to child processes,
+/// so we need to make a pass through the open descriptors beyond just the
+/// stdio descriptors and close them all out.
+/// This is approximately equivalent to the darwin `posix_spawnattr_setflags`
+/// option POSIX_SPAWN_CLOEXEC_DEFAULT which is used as a bit of a cheat
+/// on macOS.
+/// On Linux, gnome/mutter leak shell extension fds to wezterm too, so we
+/// also need to make an effort to clean up the mess.
+///
+/// This function enumerates the open filedescriptors in the current process
+/// and then will forcibly call close(2) on each open fd that is numbered
+/// 3 or higher, effectively closing all descriptors except for the stdio
+/// streams.
+///
+/// The implementation of this function relies on `/dev/fd` being available
+/// to provide the list of open fds.  Any errors in enumerating or closing
+/// the fds are silently ignored.
+pub fn close_random_fds() {
+    // FreeBSD, macOS and presumably other BSDish systems have /dev/fd as
+    // a directory listing the current fd numbers for the process.
+    //
+    // On Linux, /dev/fd is a symlink to /proc/self/fd
+    if let Ok(dir) = std::fs::read_dir("/dev/fd") {
+        let mut fds = vec![];
+        for entry in dir {
+            if let Some(num) = entry
+                .ok()
+                .map(|e| e.file_name())
+                .and_then(|s| s.into_string().ok())
+                .and_then(|n| n.parse::<libc::c_int>().ok())
+            {
+                if num > 2 {
+                    fds.push(num);
+                }
+            }
+        }
+        for fd in fds {
+            unsafe {
+                libc::close(fd);
+            }
+        }
+    }
+}
+
+impl PtyFd {
+    fn resize(&self, size: PtySize) -> Result<(), Error> {
+        let ws_size = winsize {
+            ws_row: size.rows,
+            ws_col: size.cols,
+            ws_xpixel: size.pixel_width,
+            ws_ypixel: size.pixel_height,
+        };
+
+        if unsafe {
+            libc::ioctl(
+                self.0.as_raw_fd(),
+                libc::TIOCSWINSZ as _,
+                &ws_size as *const _,
+            )
+        } != 0
+        {
+            bail!(
+                "failed to ioctl(TIOCSWINSZ): {:?}",
+                io::Error::last_os_error()
+            );
+        }
+
+        Ok(())
+    }
+
+    fn get_size(&self) -> Result<PtySize, Error> {
+        let mut size: winsize = unsafe { mem::zeroed() };
+        if unsafe {
+            libc::ioctl(
+                self.0.as_raw_fd(),
+                libc::TIOCGWINSZ as _,
+                &mut size as *mut _,
+            )
+        } != 0
+        {
+            bail!(
+                "failed to ioctl(TIOCGWINSZ): {:?}",
+                io::Error::last_os_error()
+            );
+        }
+        Ok(PtySize {
+            rows: size.ws_row,
+            cols: size.ws_col,
+            pixel_width: size.ws_xpixel,
+            pixel_height: size.ws_ypixel,
+        })
+    }
+
+    fn spawn_command(&self, builder: CommandBuilder) -> anyhow::Result<std::process::Child> {
+        let configured_umask = builder.umask;
+
+        let mut cmd = builder.as_command()?;
+        let controlling_tty = builder.get_controlling_tty();
+
+        unsafe {
+            cmd.stdin(self.as_stdio()?)
+                .stdout(self.as_stdio()?)
+                .stderr(self.as_stdio()?)
+                .pre_exec(move || {
+                    // Clean up a few things before we exec the program
+                    // Clear out any potentially problematic signal
+                    // dispositions that we might have inherited
+                    for signo in &[
+                        libc::SIGCHLD,
+                        libc::SIGHUP,
+                        libc::SIGINT,
+                        libc::SIGQUIT,
+                        libc::SIGTERM,
+                        libc::SIGALRM,
+                    ] {
+                        libc::signal(*signo, libc::SIG_DFL);
+                    }
+
+                    let empty_set: libc::sigset_t = std::mem::zeroed();
+                    libc::sigprocmask(libc::SIG_SETMASK, &empty_set, std::ptr::null_mut());
+
+                    // Establish ourselves as a session leader.
+                    if libc::setsid() == -1 {
+                        return Err(io::Error::last_os_error());
+                    }
+
+                    // Clippy wants us to explicitly cast TIOCSCTTY using
+                    // type::from(), but the size and potentially signedness
+                    // are system dependent, which is why we're using `as _`.
+                    // Suppress this lint for this section of code.
+                    #[allow(clippy::cast_lossless)]
+                    if controlling_tty {
+                        // Set the pty as the controlling terminal.
+                        // Failure to do this means that delivery of
+                        // SIGWINCH won't happen when we resize the
+                        // terminal, among other undesirable effects.
+                        if libc::ioctl(0, libc::TIOCSCTTY as _, 0) == -1 {
+                            return Err(io::Error::last_os_error());
+                        }
+                    }
+
+                    close_random_fds();
+
+                    if let Some(mask) = configured_umask {
+                        libc::umask(mask);
+                    }
+
+                    Ok(())
+                })
+        };
+
+        let mut child = cmd.spawn()?;
+
+        // Ensure that we close out the slave fds that Child retains;
+        // they are not what we need (we need the master side to reference
+        // them) and won't work in the usual way anyway.
+        // In practice these are None, but it seems best to be move them
+        // out in case the behavior of Command changes in the future.
+        child.stdin.take();
+        child.stdout.take();
+        child.stderr.take();
+
+        Ok(child)
+    }
+}
+
+/// Represents the master end of a pty.
+/// The file descriptor will be closed when the Pty is dropped.
+struct UnixMasterPty {
+    fd: PtyFd,
+    took_writer: RefCell<bool>,
+    tty_name: Option<PathBuf>,
+}
+
+/// Represents the slave end of a pty.
+/// The file descriptor will be closed when the Pty is dropped.
+struct UnixSlavePty {
+    fd: PtyFd,
+}
+
+/// Helper function to set the close-on-exec flag for a raw descriptor
+fn cloexec(fd: RawFd) -> Result<(), Error> {
+    let flags = unsafe { libc::fcntl(fd, libc::F_GETFD) };
+    if flags == -1 {
+        bail!(
+            "fcntl to read flags failed: {:?}",
+            io::Error::last_os_error()
+        );
+    }
+    let result = unsafe { libc::fcntl(fd, libc::F_SETFD, flags | libc::FD_CLOEXEC) };
+    if result == -1 {
+        bail!(
+            "fcntl to set CLOEXEC failed: {:?}",
+            io::Error::last_os_error()
+        );
+    }
+    Ok(())
+}
+
+impl SlavePty for UnixSlavePty {
+    fn spawn_command(
+        &self,
+        builder: CommandBuilder,
+    ) -> Result<Box<dyn Child + Send + Sync>, Error> {
+        Ok(Box::new(self.fd.spawn_command(builder)?))
+    }
+}
+
+impl MasterPty for UnixMasterPty {
+    fn resize(&self, size: PtySize) -> Result<(), Error> {
+        self.fd.resize(size)
+    }
+
+    fn get_size(&self) -> Result<PtySize, Error> {
+        self.fd.get_size()
+    }
+
+    fn try_clone_reader(&self) -> Result<Box<dyn Read + Send>, Error> {
+        let fd = PtyFd(self.fd.try_clone()?);
+        Ok(Box::new(fd))
+    }
+
+    fn take_writer(&self) -> Result<Box<dyn Write + Send>, Error> {
+        if *self.took_writer.borrow() {
+            anyhow::bail!("cannot take writer more than once");
+        }
+        *self.took_writer.borrow_mut() = true;
+        let fd = PtyFd(self.fd.try_clone()?);
+        Ok(Box::new(UnixMasterWriter { fd }))
+    }
+
+    fn as_raw_fd(&self) -> Option<RawFd> {
+        Some(self.fd.0.as_raw_fd())
+    }
+
+    fn tty_name(&self) -> Option<PathBuf> {
+        self.tty_name.clone()
+    }
+
+    fn process_group_leader(&self) -> Option<libc::pid_t> {
+        match unsafe { libc::tcgetpgrp(self.fd.0.as_raw_fd()) } {
+            pid if pid > 0 => Some(pid),
+            _ => None,
+        }
+    }
+
+    fn get_termios(&self) -> Option<nix::sys::termios::Termios> {
+        nix::sys::termios::tcgetattr(self.fd.0.as_fd()).ok()
+    }
+}
+
+/// Represents the master end of a pty.
+/// EOT will be sent, and then the file descriptor will be closed when
+/// the Pty is dropped.
+struct UnixMasterWriter {
+    fd: PtyFd,
+}
+
+impl Drop for UnixMasterWriter {
+    fn drop(&mut self) {
+        let mut t: libc::termios = unsafe { std::mem::MaybeUninit::zeroed().assume_init() };
+        if unsafe { libc::tcgetattr(self.fd.0.as_raw_fd(), &mut t) } == 0 {
+            // EOF is only interpreted after a newline, so if it is set,
+            // we send a newline followed by EOF.
+            let eot = t.c_cc[libc::VEOF];
+            if eot != 0 {
+                let _ = self.fd.0.write_all(&[b'\n', eot]);
+            }
+        }
+    }
+}
+
+impl Write for UnixMasterWriter {
+    fn write(&mut self, buf: &[u8]) -> Result<usize, io::Error> {
+        self.fd.write(buf)
+    }
+    fn flush(&mut self) -> Result<(), io::Error> {
+        self.fd.flush()
+    }
+}
diff --git a/vendor/portable-pty/src/win/conpty.rs b/vendor/portable-pty/src/win/conpty.rs
new file mode 100644
index 00000000..51cbf9e5
--- /dev/null
+++ b/vendor/portable-pty/src/win/conpty.rs
@@ -0,0 +1,127 @@
+use crate::cmdbuilder::CommandBuilder;
+use crate::win::psuedocon::PsuedoCon;
+use crate::{Child, MasterPty, PtyPair, PtySize, PtySystem, SlavePty};
+use anyhow::Error;
+use filedescriptor::{FileDescriptor, Pipe};
+use std::sync::{Arc, Mutex};
+use winapi::um::wincon::COORD;
+
+#[derive(Default)]
+pub struct ConPtySystem {}
+
+impl PtySystem for ConPtySystem {
+    fn openpty(&self, size: PtySize) -> anyhow::Result<PtyPair> {
+        let stdin = Pipe::new()?;
+        let stdout = Pipe::new()?;
+
+        let con = PsuedoCon::new(
+            COORD {
+                X: size.cols as i16,
+                Y: size.rows as i16,
+            },
+            stdin.read,
+            stdout.write,
+        )?;
+
+        let master = ConPtyMasterPty {
+            inner: Arc::new(Mutex::new(Inner {
+                con,
+                readable: stdout.read,
+                writable: Some(stdin.write),
+                size,
+            })),
+        };
+
+        let slave = ConPtySlavePty {
+            inner: master.inner.clone(),
+        };
+
+        Ok(PtyPair {
+            master: Box::new(master),
+            slave: Box::new(slave),
+        })
+    }
+}
+
+struct Inner {
+    con: PsuedoCon,
+    readable: FileDescriptor,
+    writable: Option<FileDescriptor>,
+    size: PtySize,
+}
+
+impl Inner {
+    pub fn resize(
+        &mut self,
+        num_rows: u16,
+        num_cols: u16,
+        pixel_width: u16,
+        pixel_height: u16,
+    ) -> Result<(), Error> {
+        self.con.resize(COORD {
+            X: num_cols as i16,
+            Y: num_rows as i16,
+        })?;
+        self.size = PtySize {
+            rows: num_rows,
+            cols: num_cols,
+            pixel_width,
+            pixel_height,
+        };
+        Ok(())
+    }
+}
+
+#[derive(Clone)]
+pub struct ConPtyMasterPty {
+    inner: Arc<Mutex<Inner>>,
+}
+
+pub struct ConPtySlavePty {
+    inner: Arc<Mutex<Inner>>,
+}
+
+impl MasterPty for ConPtyMasterPty {
+    fn resize(&self, size: PtySize) -> anyhow::Result<()> {
+        let mut inner = self.inner.lock().unwrap();
+        inner.resize(size.rows, size.cols, size.pixel_width, size.pixel_height)
+    }
+
+    fn get_size(&self) -> Result<PtySize, Error> {
+        let inner = self.inner.lock().unwrap();
+        Ok(inner.size.clone())
+    }
+
+    fn try_clone_reader(&self) -> anyhow::Result<Box<dyn std::io::Read + Send>> {
+        Ok(Box::new(self.inner.lock().unwrap().readable.try_clone()?))
+    }
+
+    fn take_writer(&self) -> anyhow::Result<Box<dyn std::io::Write + Send>> {
+        Ok(Box::new(
+            self.inner
+                .lock()
+                .unwrap()
+                .writable
+                .take()
+                .ok_or_else(|| anyhow::anyhow!("writer already taken"))?,
+        ))
+    }
+}
+
+impl SlavePty for ConPtySlavePty {
+    fn spawn_command(&self, cmd: CommandBuilder) -> anyhow::Result<Box<dyn Child + Send + Sync>> {
+        let inner = self.inner.lock().unwrap();
+        let child = inner.con.spawn_command(cmd, None)?;
+        Ok(Box::new(child))
+    }
+
+    fn spawn_command_in_job(
+        &self,
+        cmd: CommandBuilder,
+        job: std::os::windows::io::BorrowedHandle<'_>,
+    ) -> anyhow::Result<Box<dyn Child + Send + Sync>> {
+        let inner = self.inner.lock().unwrap();
+        let child = inner.con.spawn_command(cmd, Some(job))?;
+        Ok(Box::new(child))
+    }
+}
diff --git a/vendor/portable-pty/src/win/mod.rs b/vendor/portable-pty/src/win/mod.rs
new file mode 100644
index 00000000..24f8f536
--- /dev/null
+++ b/vendor/portable-pty/src/win/mod.rs
@@ -0,0 +1,149 @@
+use crate::{Child, ChildKiller, ExitStatus};
+use anyhow::Context as _;
+use std::io::{Error as IoError, Result as IoResult};
+use std::os::windows::io::{AsRawHandle, RawHandle};
+use std::pin::Pin;
+use std::sync::Mutex;
+use std::task::{Context, Poll};
+use winapi::shared::minwindef::DWORD;
+use winapi::um::minwinbase::STILL_ACTIVE;
+use winapi::um::processthreadsapi::*;
+use winapi::um::synchapi::WaitForSingleObject;
+use winapi::um::winbase::INFINITE;
+
+pub mod conpty;
+mod procthreadattr;
+mod psuedocon;
+
+use filedescriptor::OwnedHandle;
+
+#[derive(Debug)]
+pub struct WinChild {
+    proc: Mutex<OwnedHandle>,
+}
+
+impl WinChild {
+    fn is_complete(&mut self) -> IoResult<Option<ExitStatus>> {
+        let mut status: DWORD = 0;
+        let proc = self.proc.lock().unwrap().try_clone().unwrap();
+        let res = unsafe { GetExitCodeProcess(proc.as_raw_handle() as _, &mut status) };
+        if res != 0 {
+            if status == STILL_ACTIVE {
+                Ok(None)
+            } else {
+                Ok(Some(ExitStatus::with_exit_code(status)))
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn do_kill(&mut self) -> IoResult<()> {
+        let proc = self.proc.lock().unwrap().try_clone().unwrap();
+        let res = unsafe { TerminateProcess(proc.as_raw_handle() as _, 1) };
+        let err = IoError::last_os_error();
+        if res != 0 {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+}
+
+impl ChildKiller for WinChild {
+    fn kill(&mut self) -> IoResult<()> {
+        self.do_kill().ok();
+        Ok(())
+    }
+
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        let proc = self.proc.lock().unwrap().try_clone().unwrap();
+        Box::new(WinChildKiller { proc })
+    }
+}
+
+#[derive(Debug)]
+pub struct WinChildKiller {
+    proc: OwnedHandle,
+}
+
+impl ChildKiller for WinChildKiller {
+    fn kill(&mut self) -> IoResult<()> {
+        let res = unsafe { TerminateProcess(self.proc.as_raw_handle() as _, 1) };
+        let err = IoError::last_os_error();
+        if res != 0 {
+            Err(err)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn clone_killer(&self) -> Box<dyn ChildKiller + Send + Sync> {
+        let proc = self.proc.try_clone().unwrap();
+        Box::new(WinChildKiller { proc })
+    }
+}
+
+impl Child for WinChild {
+    fn try_wait(&mut self) -> IoResult<Option<ExitStatus>> {
+        self.is_complete()
+    }
+
+    fn wait(&mut self) -> IoResult<ExitStatus> {
+        if let Ok(Some(status)) = self.try_wait() {
+            return Ok(status);
+        }
+        let proc = self.proc.lock().unwrap().try_clone().unwrap();
+        unsafe {
+            WaitForSingleObject(proc.as_raw_handle() as _, INFINITE);
+        }
+        let mut status: DWORD = 0;
+        let res = unsafe { GetExitCodeProcess(proc.as_raw_handle() as _, &mut status) };
+        if res != 0 {
+            Ok(ExitStatus::with_exit_code(status))
+        } else {
+            Err(IoError::last_os_error())
+        }
+    }
+
+    fn process_id(&self) -> Option<u32> {
+        let res = unsafe { GetProcessId(self.proc.lock().unwrap().as_raw_handle() as _) };
+        if res == 0 {
+            None
+        } else {
+            Some(res)
+        }
+    }
+
+    fn as_raw_handle(&self) -> Option<std::os::windows::io::RawHandle> {
+        let proc = self.proc.lock().unwrap();
+        Some(proc.as_raw_handle())
+    }
+}
+
+impl std::future::Future for WinChild {
+    type Output = anyhow::Result<ExitStatus>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<anyhow::Result<ExitStatus>> {
+        match self.is_complete() {
+            Ok(Some(status)) => Poll::Ready(Ok(status)),
+            Err(err) => Poll::Ready(Err(err).context("Failed to retrieve process exit status")),
+            Ok(None) => {
+                struct PassRawHandleToWaiterThread(pub RawHandle);
+                unsafe impl Send for PassRawHandleToWaiterThread {}
+
+                let proc = self.proc.lock().unwrap().try_clone()?;
+                let handle = PassRawHandleToWaiterThread(proc.as_raw_handle());
+
+                let waker = cx.waker().clone();
+                std::thread::spawn(move || {
+                    unsafe {
+                        WaitForSingleObject(handle.0 as _, INFINITE);
+                    }
+                    waker.wake();
+                });
+                Poll::Pending
+            }
+        }
+    }
+}
diff --git a/vendor/portable-pty/src/win/procthreadattr.rs b/vendor/portable-pty/src/win/procthreadattr.rs
new file mode 100644
index 00000000..05c9c423
--- /dev/null
+++ b/vendor/portable-pty/src/win/procthreadattr.rs
@@ -0,0 +1,99 @@
+use crate::win::psuedocon::HPCON;
+use anyhow::{ensure, Error};
+use std::io::Error as IoError;
+use std::{mem, ptr};
+use winapi::shared::minwindef::DWORD;
+use winapi::um::processthreadsapi::*;
+use winapi::um::winnt::HANDLE;
+
+const PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE: usize = 0x00020016;
+// Available since Windows 10, before the minimum ConPTY-supported version.
+const PROC_THREAD_ATTRIBUTE_JOB_LIST: usize = 0x0002000d;
+
+pub struct ProcThreadAttributeList<'a> {
+    data: Vec<u8>,
+    jobs: std::marker::PhantomData<&'a [HANDLE]>,
+}
+
+impl<'a> ProcThreadAttributeList<'a> {
+    pub fn with_capacity(num_attributes: DWORD) -> Result<Self, Error> {
+        let mut bytes_required: usize = 0;
+        unsafe {
+            InitializeProcThreadAttributeList(
+                ptr::null_mut(),
+                num_attributes,
+                0,
+                &mut bytes_required,
+            )
+        };
+        let mut data = Vec::with_capacity(bytes_required);
+        // We have the right capacity, so force the vec to consider itself
+        // that length.  The contents of those bytes will be maintained
+        // by the win32 apis used in this impl.
+        unsafe { data.set_len(bytes_required) };
+
+        let attr_ptr = data.as_mut_slice().as_mut_ptr() as *mut _;
+        let res = unsafe {
+            InitializeProcThreadAttributeList(attr_ptr, num_attributes, 0, &mut bytes_required)
+        };
+        ensure!(
+            res != 0,
+            "InitializeProcThreadAttributeList failed: {}",
+            IoError::last_os_error()
+        );
+        Ok(Self {
+            data,
+            jobs: std::marker::PhantomData,
+        })
+    }
+
+    pub fn as_mut_ptr(&mut self) -> LPPROC_THREAD_ATTRIBUTE_LIST {
+        self.data.as_mut_slice().as_mut_ptr() as *mut _
+    }
+
+    pub fn set_job_list(&mut self, jobs: &'a [HANDLE]) -> Result<(), Error> {
+        let res = unsafe {
+            UpdateProcThreadAttribute(
+                self.as_mut_ptr(),
+                0,
+                PROC_THREAD_ATTRIBUTE_JOB_LIST,
+                jobs.as_ptr() as *mut _,
+                mem::size_of_val(jobs),
+                ptr::null_mut(),
+                ptr::null_mut(),
+            )
+        };
+        ensure!(
+            res != 0,
+            "UpdateProcThreadAttribute(JOB_LIST) failed: {}",
+            IoError::last_os_error()
+        );
+        Ok(())
+    }
+
+    pub fn set_pty(&mut self, con: HPCON) -> Result<(), Error> {
+        let res = unsafe {
+            UpdateProcThreadAttribute(
+                self.as_mut_ptr(),
+                0,
+                PROC_THREAD_ATTRIBUTE_PSEUDOCONSOLE,
+                con,
+                mem::size_of::<HPCON>(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+            )
+        };
+        ensure!(
+            res != 0,
+            "UpdateProcThreadAttribute failed: {}",
+            IoError::last_os_error()
+        );
+        Ok(())
+    }
+}
+
+impl Drop for ProcThreadAttributeList<'_> {
+    fn drop(&mut self) {
+        unsafe { DeleteProcThreadAttributeList(self.as_mut_ptr()) };
+    }
+}
diff --git a/vendor/portable-pty/src/win/psuedocon.rs b/vendor/portable-pty/src/win/psuedocon.rs
new file mode 100644
index 00000000..0fa240e8
--- /dev/null
+++ b/vendor/portable-pty/src/win/psuedocon.rs
@@ -0,0 +1,186 @@
+use super::WinChild;
+use crate::cmdbuilder::CommandBuilder;
+use crate::win::procthreadattr::ProcThreadAttributeList;
+use anyhow::{bail, ensure, Error};
+use filedescriptor::{FileDescriptor, OwnedHandle};
+use lazy_static::lazy_static;
+use shared_library::shared_library;
+use std::ffi::OsString;
+use std::io::Error as IoError;
+use std::os::windows::ffi::OsStringExt;
+use std::os::windows::io::{AsRawHandle, BorrowedHandle, FromRawHandle};
+use std::path::Path;
+use std::sync::Mutex;
+use std::{mem, ptr};
+use winapi::shared::minwindef::DWORD;
+use winapi::shared::winerror::{HRESULT, S_OK};
+use winapi::um::handleapi::*;
+use winapi::um::processthreadsapi::*;
+use winapi::um::winbase::{
+    CREATE_UNICODE_ENVIRONMENT, EXTENDED_STARTUPINFO_PRESENT, STARTF_USESTDHANDLES, STARTUPINFOEXW,
+};
+use winapi::um::wincon::COORD;
+use winapi::um::winnt::HANDLE;
+
+pub type HPCON = HANDLE;
+
+pub const PSUEDOCONSOLE_INHERIT_CURSOR: DWORD = 0x1;
+pub const PSEUDOCONSOLE_RESIZE_QUIRK: DWORD = 0x2;
+pub const PSEUDOCONSOLE_WIN32_INPUT_MODE: DWORD = 0x4;
+#[allow(dead_code)]
+pub const PSEUDOCONSOLE_PASSTHROUGH_MODE: DWORD = 0x8;
+
+shared_library!(ConPtyFuncs,
+    pub fn CreatePseudoConsole(
+        size: COORD,
+        hInput: HANDLE,
+        hOutput: HANDLE,
+        flags: DWORD,
+        hpc: *mut HPCON
+    ) -> HRESULT,
+    pub fn ResizePseudoConsole(hpc: HPCON, size: COORD) -> HRESULT,
+    pub fn ClosePseudoConsole(hpc: HPCON),
+);
+
+fn load_conpty() -> ConPtyFuncs {
+    // If the kernel doesn't export these functions then their system is
+    // too old and we cannot run.
+    let kernel = ConPtyFuncs::open(Path::new("kernel32.dll")).expect(
+        "this system does not support conpty.  Windows 10 October 2018 or newer is required",
+    );
+
+    // We prefer to use a sideloaded conpty.dll and openconsole.exe host deployed
+    // alongside the application.  We check for this after checking for kernel
+    // support so that we don't try to proceed and do something crazy.
+    if let Ok(sideloaded) = ConPtyFuncs::open(Path::new("conpty.dll")) {
+        sideloaded
+    } else {
+        kernel
+    }
+}
+
+lazy_static! {
+    static ref CONPTY: ConPtyFuncs = load_conpty();
+}
+
+pub struct PsuedoCon {
+    con: HPCON,
+}
+
+unsafe impl Send for PsuedoCon {}
+unsafe impl Sync for PsuedoCon {}
+
+impl Drop for PsuedoCon {
+    fn drop(&mut self) {
+        unsafe { (CONPTY.ClosePseudoConsole)(self.con) };
+    }
+}
+
+impl PsuedoCon {
+    pub fn new(size: COORD, input: FileDescriptor, output: FileDescriptor) -> Result<Self, Error> {
+        let mut con: HPCON = INVALID_HANDLE_VALUE;
+        let result = unsafe {
+            (CONPTY.CreatePseudoConsole)(
+                size,
+                input.as_raw_handle() as _,
+                output.as_raw_handle() as _,
+                PSUEDOCONSOLE_INHERIT_CURSOR
+                    | PSEUDOCONSOLE_RESIZE_QUIRK
+                    | PSEUDOCONSOLE_WIN32_INPUT_MODE,
+                &mut con,
+            )
+        };
+        ensure!(
+            result == S_OK,
+            "failed to create psuedo console: HRESULT {}",
+            result
+        );
+        Ok(Self { con })
+    }
+
+    pub fn resize(&self, size: COORD) -> Result<(), Error> {
+        let result = unsafe { (CONPTY.ResizePseudoConsole)(self.con, size) };
+        ensure!(
+            result == S_OK,
+            "failed to resize console to {}x{}: HRESULT: {}",
+            size.X,
+            size.Y,
+            result
+        );
+        Ok(())
+    }
+
+    pub fn spawn_command(
+        &self,
+        cmd: CommandBuilder,
+        job: Option<BorrowedHandle<'_>>,
+    ) -> anyhow::Result<WinChild> {
+        let mut si: STARTUPINFOEXW = unsafe { mem::zeroed() };
+        si.StartupInfo.cb = mem::size_of::<STARTUPINFOEXW>() as u32;
+        // Explicitly set the stdio handles as invalid handles otherwise
+        // we can end up with a weird state where the spawned process can
+        // inherit the explicitly redirected output handles from its parent.
+        // For example, when daemonizing wezterm-mux-server, the stdio handles
+        // are redirected to a log file and the spawned process would end up
+        // writing its output there instead of to the pty we just created.
+        si.StartupInfo.dwFlags = STARTF_USESTDHANDLES;
+        si.StartupInfo.hStdInput = INVALID_HANDLE_VALUE;
+        si.StartupInfo.hStdOutput = INVALID_HANDLE_VALUE;
+        si.StartupInfo.hStdError = INVALID_HANDLE_VALUE;
+
+        // Keep the array and borrowed job alive until after the attribute list.
+        // CreateProcessW assigns the job before running the child, and fails
+        // without starting an unprotected child if the assignment is invalid.
+        let jobs = job.map(|job| [job.as_raw_handle() as HANDLE]);
+        let mut attrs = ProcThreadAttributeList::with_capacity(if jobs.is_some() { 2 } else { 1 })?;
+        attrs.set_pty(self.con)?;
+        if let Some(jobs) = jobs.as_ref() {
+            attrs.set_job_list(jobs)?;
+        }
+        si.lpAttributeList = attrs.as_mut_ptr();
+
+        let mut pi: PROCESS_INFORMATION = unsafe { mem::zeroed() };
+
+        let (mut exe, mut cmdline) = cmd.cmdline()?;
+        let cmd_os = OsString::from_wide(&cmdline);
+
+        let cwd = cmd.current_directory();
+
+        let res = unsafe {
+            CreateProcessW(
+                exe.as_mut_slice().as_mut_ptr(),
+                cmdline.as_mut_slice().as_mut_ptr(),
+                ptr::null_mut(),
+                ptr::null_mut(),
+                0,
+                EXTENDED_STARTUPINFO_PRESENT | CREATE_UNICODE_ENVIRONMENT,
+                cmd.environment_block().as_mut_slice().as_mut_ptr() as *mut _,
+                cwd.as_ref()
+                    .map(|c| c.as_slice().as_ptr())
+                    .unwrap_or(ptr::null()),
+                &mut si.StartupInfo,
+                &mut pi,
+            )
+        };
+        if res == 0 {
+            let err = IoError::last_os_error();
+            let msg = format!(
+                "CreateProcessW `{:?}` in cwd `{:?}` failed: {}",
+                cmd_os,
+                cwd.as_ref().map(|c| OsString::from_wide(c)),
+                err
+            );
+            log::error!("{}", msg);
+            bail!("{}", msg);
+        }
+
+        // Make sure we close out the thread handle so we don't leak it;
+        // we do this simply by making it owned
+        let _main_thread = unsafe { OwnedHandle::from_raw_handle(pi.hThread as _) };
+        let proc = unsafe { OwnedHandle::from_raw_handle(pi.hProcess as _) };
+
+        Ok(WinChild {
+            proc: Mutex::new(proc),
+        })
+    }
+}

From d6e8a4e9be0b26393350a54fa7dc6c21c056e37c Mon Sep 17 00:00:00 2001
From: Nick <60738984+hardbeat920@users.noreply.github.com>
Date: Sat, 5 Sep 2026 15:22:51 +0100
Subject: [PATCH 6/6] Handle ConPTY cursor requests in the crash cleanup test

---
 src-tauri/src/windows.rs | 42 +++++++++++++++++++++++++++++++++-------
 1 file changed, 35 insertions(+), 7 deletions(-)

diff --git a/src-tauri/src/windows.rs b/src-tauri/src/windows.rs
index 331876bb..0673aa19 100644
--- a/src-tauri/src/windows.rs
+++ b/src-tauri/src/windows.rs
@@ -136,8 +136,9 @@ fn resume_child(pid: u32) -> io::Result<()> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::io::{BufRead, BufReader, Write};
+    use std::io::{BufRead, BufReader, Read, Write};
     use std::process::{Command, Stdio};
+    use std::sync::{Arc, Mutex};
     use windows_sys::Win32::System::Threading::{
         GetCurrentProcess, OpenProcess, TerminateProcess, WaitForSingleObject,
         PROCESS_QUERY_INFORMATION,
@@ -200,8 +201,6 @@ mod tests {
                 .stdout(Stdio::null())
                 .stderr(Stdio::null());
             let child = spawn_managed(&mut command).unwrap();
-            crate::hide_window_console(&mut command);
-            let external = command.spawn().unwrap();
             let pair = portable_pty::native_pty_system()
                 .openpty(portable_pty::PtySize::default())
                 .unwrap();
@@ -218,11 +217,37 @@ mod tests {
             ]);
             terminal.env(MARKER, "terminal");
             terminal.env(PID_FILE, &pid_file);
-            // Drain output even when no UI is present; ConPTY shutdown on older
-            // Windows versions can otherwise wait for its output pipe forever.
+            // Act as the missing terminal UI: answer ConPTY's cursor query and
+            // drain output so startup and shutdown cannot block on these pipes.
             let mut reader = pair.master.try_clone_reader().unwrap();
+            let mut writer = pair.master.take_writer().unwrap();
+            let terminal_output = Arc::new(Mutex::new(Vec::new()));
+            let captured = terminal_output.clone();
             std::thread::spawn(move || {
-                let _ = std::io::copy(&mut reader, &mut std::io::sink());
+                let mut buf = [0_u8; 1024];
+                let query = b"\x1b[6n";
+                let mut matched = 0;
+                while let Ok(n) = reader.read(&mut buf) {
+                    if n == 0 {
+                        break;
+                    }
+                    let mut output = captured.lock().unwrap();
+                    if output.len() < 16 * 1024 {
+                        output.extend_from_slice(&buf[..n]);
+                    }
+                    drop(output);
+                    for &byte in &buf[..n] {
+                        matched = if byte == query[matched] {
+                            matched + 1
+                        } else {
+                            usize::from(byte == query[0])
+                        };
+                        if matched == query.len() {
+                            let _ = writer.write_all(b"\x1b[1;1R");
+                            matched = 0;
+                        }
+                    }
+                }
             });
             let terminal = spawn_pty(pair.slave.as_ref(), terminal).unwrap();
             let deadline = std::time::Instant::now() + std::time::Duration::from_secs(15);
@@ -235,7 +260,8 @@ mod tests {
                 }
                 assert!(
                     std::time::Instant::now() < deadline,
-                    "terminal startup timed out"
+                    "terminal startup timed out; output: {:?}",
+                    String::from_utf8_lossy(&terminal_output.lock().unwrap())
                 );
                 std::thread::sleep(std::time::Duration::from_millis(10));
             };
@@ -256,6 +282,8 @@ mod tests {
                 );
                 assert_ne!(in_job, 0, "startup descendant escaped the managed job");
             }
+            crate::hide_window_console(&mut command);
+            let external = command.spawn().unwrap();
             println!("CHILD_PID={}", child.id());
             println!("TERMINAL_PID={}", terminal.process_id().unwrap());
             println!("DESCENDANT_PID={descendant_pid}");