Rebase to Cygwin runtime v3.6.9

[dscho]

This is quite a big one:

• We backported many Pseudo Console fixes,
• Tons of updates to the AGENTS.md (also because the original contribution was structured into a basic commit followed by a couple of fixup!s for easier review)
• Tons of squashed fixes to the UI tests.
• ee961da (Use MB_CUR_MAX == 6 by default, 2019-11-21) was dropped (as per 4c22b03 (fixup! Use MB_CUR_MAX == 6 by default, 2026-03-04))
• The GitHub Actions updates squashed fixes targeting MSYS2 and Cygwin into the same commit, which is now fixed.

Range-diff

• 1: 90c6e2f = 1: 8ff94c8 Fix msys library name in import libraries

• 2: eb0623c = 2: 53bb5e0 Rename dll from cygwin to msys

• 3: 2d57400 = 3: 11aaade Add functionality for converting UNIX paths in arguments and environment variables to Windows form for native Win32 applications.

• 4: 3e3b14f = 4: e848126 Add functionality for changing OS name via MSYSTEM environment variables.

• 5: 019fb8c = 5: 95031f0 - Move root to /usr. - Change sorting mount points. - By default mount without ACLs. - Can read /etc/fstab with short mount point format.

• 6: 025bc50 = 6: e3afe9b Instead of creating Cygwin symlinks, use deep copy by default

• 7: 384856e = 7: 04cef96 Automatically rewrite TERM=msys to TERM=cygwin

• 8: add7911 = 8: 191e1b8 Do not convert environment for strace

• 9: 34d346c = 9: d95ef8a strace.cc: Don't set MSYS=noglob

• 10: e36f87e = 10: d515963 Add debugging for strace make_command_line

• 11: 42b2b9f = 11: 0f379db strace --quiet: be really quiet

• 12: 9dd7fc9 = 12: c260ea2 path_conv: special-case root directory to have trailing slash

• 13: a5545b3 = 13: 2a753ad When converting to a Unix path, avoid double trailing slashes

• 14: 4774fb2 = 14: ce71ac2 msys2_path_conv: pass PC_NOFULL to path_conv

• 15: 793bb2a = 15: b2b3e79 path-conversion: Introduce ability to switch off conversion.

• 16: 0fe7d40 = 16: 3b74813 dcrt0.cc: Untangle allow_glob from winshell

• 17: da4617d = 17: b58ab85 dcrt0.cc (globify): Don't quote literal strings differently when dos_spec

• 18: 17bfb25 = 18: ec43e0c Add debugging for build_argv

• 19: 3d7efd8 = 19: fb2eb43 environ.cc: New facility/environment variable MSYS2_ENV_CONV_EXCL

• 20: a7b6522 = 20: ca37d02 Introduce the enable_pcon value for MSYS

• 21: f6c8e15 = 21: 33b14c0 popen: call /usr/bin/sh instead of /bin/sh

• 22: 4c0a1a8 = 22: d2263a9 Disable the 'cygwin' GitHub workflow

• 23: 79bf3a1 = 23: cd14361 CI: add a GHA for doing a basic build test

• 24: 54cf1de = 24: 1f25400 Set up a GitHub Action to keep in sync with Cygwin

• 25: 4b6770b = 25: 7a40bbe Expose full command-lines to other Win32 processes by default

• 26: a0c3117 = 26: 9abc090 Add a helper to obtain a function's address in kernel32.dll

• 27: 752cf15 ! 27: b2413eb Emulate GenerateConsoleCtrlEvent() upon Ctrl+C

  @@ winsup/cygwin/exceptions.cc: details. */
       macros are for access into CONTEXT, the _MC_foo ones for access into
   @@ winsup/cygwin/exceptions.cc: exit_sig:
    dosig:
  -   if (have_execed)
  +   if (have_execed && (ch_spawn.iscygwin () || !is_stop_or_cont (si.si_signo)))
        {
   -      sigproc_printf ("terminating captive process");
   -      if (::cygheap->ctty)

• 28: e841010 = 28: 5e19738 kill: kill Win32 processes more gently

• 29: 488d8d8 = 29: 450800b Cygwin: make option for native inner link handling.

• 30: b89a0ae = 30: a0d53e4 docs: skip building texinfo and PDF files

• 31: c3d121f = 31: b0fcf02 install-libs: depend on the "toollibs"

• 32: bbe177f = 32: 4e9612f POSIX-ify the SHELL variable

• 33: a0f611a = 33: 79885de Handle ORIGINAL_PATH just like PATH

• 34: 370a8b4 = 34: 2f1036a uname: allow setting the system name to CYGWIN

• 35: 871d236 = 35: 8fdf344 Pass environment variables with empty values

• 36: f29cf3d = 36: d064b00 Optionally disallow empty environment values again

• 37: 443ed30 = 37: 9c78766 build_env(): respect the MSYS environment variable

• 38: 306baf5 = 38: 66cfb0c Revert "Cygwin: Enable dynamicbase on the Cygwin DLL by default"

• 39: 35c1c7c = 39: 546c331 Avoid sharing cygheaps across Cygwin versions

• 40: c9aee64 = 40: adee13c uname: report msys2-runtime commit hash, too

• 41: 6e9c4de = 41: cb25225 Cygwin: Adjust CWD magic to accommodate for the latest Windows previews

• -: ------- > 42: aa532e7 Cygwin: Fix segfault when XSAVE area sizes are unaligned

• 45: 520e5c9 = 43: d399a0d fixup! Add functionality for converting UNIX paths in arguments and environment variables to Windows form for native Win32 applications.

• 46: ea6fb84 = 44: 1c925ce Mention the extremely useful small_printf() function

• 47: 37e7445 = 45: 23d0d08 Allow native symlinks to non-existing targets in 'nativestrict' mode

• 48: 0ee34fb = 46: 38393ae WIP Handle 8-bit characters under LOCALE=C

• 43: 74ca85b = 47: 18a5a8a Make paths' WCS->MBS conversion explicit

• 50: 143d323 = 48: 28130fd msys2-runtime: restore fast path for current user primary group

• 51: 3502563 = 49: 5e1d3bf Change the default base address for x86_64

• 73: 1e0ff37 ! 50: 53b3656 Add AGENTS.md with comprehensive project context for AI agents

  @@ AGENTS.md (new)
   +- Commit messages should explain context, intent, and justification in prose (not bullet points)
   +- For the rebase workflow, commit messages follow specific patterns (e.g., `Start the merging-rebase to ...`) that tooling depends on — do not alter these patterns
   +
  ++### Cygwin Commit Message Format
  ++
  ++Commits that modify code under `winsup/cygwin/` should follow the Cygwin project's commit message conventions, as established by the upstream maintainers (Corinna Vinschen, Takashi Yano, et al.):
  ++
  ++- **Subject prefix**: `Cygwin: <area>: <description>`, where `<area>` is the subsystem (e.g. `pty`, `flock`, `termios`, `uinfo`, `path`, `spawn`). Example: `Cygwin: pty: Fix jumbled keystrokes by removing the per-keystroke pipe transfer`. Both upper-case and lower-case after the prefix are used upstream; there is no strict rule.
  ++- **`Fixes:` trailer**: When a commit fixes a bug introduced by a specific earlier commit, reference it with `Fixes: <12-char-hash> ("<original subject>")`. Example: `Fixes: acc44e09d1d0 ("Cygwin: pty: Add missing input transfer when switch_to_pcon_in state.")`
  ++- **`Addresses:` trailer**: Reference the user-visible bug report URL. Example: `Addresses: https://github.com/git-for-windows/git/issues/5632`
  ++- **Trailer ordering**: `Addresses:`, then `Fixes:`, then `Assisted-by:` / `Reviewed-by:` / `Reported-by:`, then `Signed-off-by:` last — following the pattern seen in upstream Cygwin commits.
  ++
   +## PTY Architecture — Pipes, State Machine, and Input Routing
   +
   +This section documents the internal architecture of the pseudo-terminal (PTY) implementation in `winsup/cygwin/fhandler/pty.cc`. Understanding this is essential for debugging any issue involving terminal input/output, keystroke handling, signal delivery, and process foreground/background transitions.
  @@ AGENTS.md (new)
   +
   +For **output**, there is a corresponding pair (`to_master` / `to_master_nat`) plus a forwarding thread (`master_fwd_thread`) that copies output from the nat pipe's slave side (`from_slave_nat`) to the cyg pipe's master side (`to_master`), so the terminal emulator (mintty) always reads from one place.
   +
  ++### The Designed Keystroke Lifecycle
  ++
  ++Understanding the full lifecycle of a keystroke is essential. The design intent is that **no keystroke is ever lost**, regardless of what the foreground process does with it. The lifecycle differs between Cygwin and native foreground processes:
  ++
  ++**When a Cygwin process is in the foreground (e.g., bash):**
  ++1. Terminal emulator writes keystroke via `master::write()`
  ++2. `master::write()` calls `line_edit()` which applies POSIX line discipline
  ++3. `accept_input()` writes processed bytes to the cyg pipe
  ++4. The Cygwin slave (bash) reads from the cyg pipe
  ++
  ++**When a native process is in the foreground with pcon active:**
  ++1. Terminal emulator writes keystroke via `master::write()`
  ++2. `master::write()` fast path writes directly to `to_slave_nat` (nat pipe)
  ++3. Conhost (the pseudo console host) reads from the nat pipe, converts the byte stream to `INPUT_RECORD` events, and stores them in its console input buffer
  ++4. If the native process reads stdin: it gets `INPUT_RECORD` events via `ReadConsoleInput()`
  ++5. If the native process does NOT read stdin (common for background tasks): the `INPUT_RECORD` events accumulate in conhost's buffer
  ++6. When the native process exits: `cleanup_for_non_cygwin_app()` calls `transfer_input(to_cyg)`, which reads all pending `INPUT_RECORD` events from the console buffer via `ReadConsoleInputA()`, converts them back to bytes, and writes them to the cyg pipe
  ++7. Bash's readline then receives these bytes as if they had been typed directly
  ++
  ++**Step 6 is critical and easy to overlook.** Keystrokes that go to the nat pipe during a native process's lifetime are NOT consumed by the native app (unless it explicitly reads them). They accumulate in conhost's input buffer and are transferred back to bash at cleanup. The transfer happens via `ReadConsoleInputA()` (raw event reads, not cooked/line-edited), so backspaces, escape sequences, and control characters are preserved as-is.
  ++
  ++**Consequence for debugging:** If keystrokes appear reordered at bash's readline after a native process exits, the problem is that some bytes went to the cyg pipe (directly to readline) while others went to the nat pipe (and were transferred back later). The bytes that went directly arrive first; the transferred bytes arrive second. This split delivery causes reordering. The fix must ensure that ALL keystrokes go through the same pipe during the native process's lifetime.
  ++
   +### The Pseudo Console (pcon)
   +
   +When `MSYS=disable_pcon` is NOT set (the default), the runtime uses Windows' `CreatePseudoConsole()` API to give native console applications a real console to talk to. The pseudo console is created on demand when a non-Cygwin process becomes the foreground process, and torn down when it exits. This is what allows programs like `cmd.exe`, `powershell.exe`, or any MinGW-built program to work correctly inside a mintty terminal, which has no native Win32 console of its own.
  @@ AGENTS.md (new)
   +Key state fields in the `tty` structure (shared memory, in `tty.h`):
   +
   +- **`pcon_activated`** (`bool`): True when a pseudo console is currently active.
  -+- **`pcon_start`** (`bool`): True during pseudo console initialization.
  ++- **`pcon_start`** (`bool`): True during pseudo console initialization (CSI6n exchange).
   +- **`pcon_start_pid`** (`pid_t`): PID of the process that initiated pcon setup.
   +
   +### The Input State Machine
   +
   +The field **`pty_input_state`** (type `xfer_dir`, in `tty.h:137`) tracks which pipe pair currently "owns" the input. It has two values:
   +
  -+- **`to_cyg`**: Input is flowing to the Cygwin pipe. The master's `write()` uses the `line_edit()` → `accept_input()` path, which writes to `to_slave` (cyg pipe).
  ++- **`to_cyg`**: Input is flowing to the Cygwin pipe. The master's `write()` uses the `line_edit()` -> `accept_input()` path, which writes to `to_slave` (cyg pipe).
   +- **`to_nat`**: Input is flowing to the native pipe. The master's `write()` writes directly to `to_slave_nat` (nat pipe), or through the pseudo console.
   +
  -+The state transitions happen via **`transfer_input()`** (pty.cc, around line 3905), which:
  ++The state transitions happen via **`transfer_input()`**, which:
   +1. Reads all pending data from the "source" pipe (the one being abandoned).
   +2. Writes that data into the "destination" pipe (the one being switched to).
   +3. Sets `pty_input_state` to the new direction.
   +
  -+This ensures data already buffered in one pipe is not lost when switching. **Any code that changes `pty_input_state` without calling `transfer_input()` risks losing or reordering data.** This invariant is critical and has been the root cause of past bugs.
  ++This ensures data already buffered in one pipe is not lost when switching.
  ++
  ++**When transferred input goes to the cyg pipe (to_cyg direction),** it must pass through `line_edit()` to apply POSIX line discipline. This is handled by the `input_transferred_to_cyg` event: the slave signals this event after the transfer, and the master's forward thread wakes up, reads the transferred bytes from the cyg pipe, and processes them through `line_edit()`. This ensures consistent line discipline regardless of whether input arrived via direct typing or via transfer.
   +
   +### Related State Fields
   +
  -+- **`switch_to_nat_pipe`** (`bool`): Set to true when a non-Cygwin process is detected in the foreground. This is a prerequisite for `to_be_read_from_nat_pipe()` returning true.
  ++- **`switch_to_nat_pipe`** (`bool`): Set to true when a non-Cygwin process is detected in the foreground. This is a prerequisite for `to_be_read_from_nat_pipe()` returning true. It stays true for the entire duration of the native session, including during brief transitions when `pcon_activated` may flicker.
   +- **`nat_pipe_owner_pid`** (`DWORD`): PID of the process that "owns" the nat pipe setup. Used to detect when the owner has exited (for cleanup).
   +
   +### The `to_be_read_from_nat_pipe()` Function
   +
  -+This function (pty.cc, around line 1288) determines whether the current foreground process is a native (non-Cygwin) app. It checks:
  ++This function determines whether keystroke input should go to the nat pipe. Its design intent is simple: return true whenever a native process session is active (`switch_to_nat_pipe` is set) and no Cygwin process is actively reading from the slave (the `TTY_SLAVE_READING` event does not exist).
   +
  -+1. `switch_to_nat_pipe` must be true.
  -+2. A named event `TTY_SLAVE_READING` must NOT exist (its existence means a Cygwin process is actively reading from the slave, indicating a Cygwin foreground).
  -+3. `nat_fg(pgid)` returns true (the foreground process group contains a native process).
  ++The function is synchronized with `pipe_sw_mutex` to avoid reading inconsistent state during pipe switching. If the mutex cannot be acquired and `pcon_start` is set (meaning pseudo console initialization is in progress), the function returns false so that the CSI6n response bytes go through `line_edit()` to the cyg pipe where the initialization code expects them.
   +
  -+**This function reads shared state without holding any mutex.** Its return value can therefore change between consecutive calls within the same function, which is an important consideration for callers that make multiple decisions based on the foreground state.
  ++**Important design principle:** This function should NOT check `nat_fg()` (whether the native process is still in the foreground process group). Such a check creates a gap between native process exit and cleanup where keystrokes fall through to `line_edit()` (cyg pipe) instead of going to the nat pipe. This gap causes keystroke reordering: bytes that go directly to the cyg pipe during the gap arrive at readline before bytes that are transferred from the nat pipe at cleanup. The correct approach is to keep routing to the nat pipe as long as `switch_to_nat_pipe` is set, regardless of the native process's foreground status. The `switch_to_nat_pipe` flag is only cleared during cleanup, after `transfer_input(to_cyg)` has moved all pending data back to the cyg pipe.
   +
   +### Mutexes and Synchronization
   +
  -+Two cross-process named mutexes protect different aspects of the PTY state. Understanding which mutex protects what — and the fact that they are independent — is essential for diagnosing race conditions.
  ++Three cross-process named mutexes protect different aspects of the PTY state:
   +
   +- **`input_mutex`**: Protects the input data path. Held by `master::write()` while routing input to a pipe, by `transfer_input()` while moving data between pipes, and by `line_edit()` / `accept_input()`.
  -+- **`pipe_sw_mutex`**: Protects pipe switching state — creation/destruction of the pseudo console, changes to `switch_to_nat_pipe`, `nat_pipe_owner_pid`. This is a DIFFERENT mutex from `input_mutex`.
  ++- **`pipe_sw_mutex`**: Protects pipe switching state — creation/destruction of the pseudo console, changes to `switch_to_nat_pipe`, `nat_pipe_owner_pid`. Also acquired by `to_be_read_from_nat_pipe()` to read consistent state. The consistent lock ordering is: `pipe_sw_mutex` first, then `input_mutex`.
  ++- **`attach_mutex`**: Protects console attachment/detachment operations. Used during `transfer_input()` to prevent races when reading console input records via `ReadConsoleInputA()`, and in `get_winpid_to_hand_over()` to prevent the master process from being misidentified during temporary console attachment.
  ++
  ++Because these are **cross-process** named mutexes, they are shared via the kernel between the master (terminal emulator) and slave (bash and its children) processes. Operations that look local in the source code actually have system-wide synchronization effects.
  ++
  ++### The `master::write()` Input Routing
  ++
  ++When the terminal emulator (mintty) sends a keystroke, it calls `master::write()`. The function has three code paths:
   +
  -+Because these are separate mutexes, it is possible for one process to modify the pipe switching state (under `pipe_sw_mutex`) while another process is in the middle of writing input (under `input_mutex`). Any code that modifies `pty_input_state` or `pcon_activated` must carefully consider whether it also needs `input_mutex` to avoid creating a window where the master's write path makes inconsistent decisions.
  ++1. **pcon_start handler**: Active during pseudo console initialization (CSI6n exchange). Accumulates ESC sequence bytes and routes the CSI6n response to the slave. Non-response bytes go through `line_edit()`. This path is only active during the brief initialization window.
   +
  -+Additionally, because these are **cross-process** named mutexes, they are shared via the kernel between the master (terminal emulator) and slave (bash and its children) processes. Operations that look local in the source code actually have system-wide synchronization effects.
  ++2. **Fast path** (pcon+nat): Active when `to_be_read_from_nat_pipe()` AND `pcon_activated` AND `pty_input_state == to_nat`. Writes directly to `to_slave_nat` via `WriteFile()`, with signal processing and charset conversion. This is the steady-state path for native apps.
   +
  -+### The `master::write()` Input Routing (pty.cc, around line 2240)
  ++3. **Fallthrough** (`line_edit`): All other cases. Input goes through POSIX line discipline and `accept_input()` routes to the appropriate pipe based on `pty_input_state`.
   +
  -+When the terminal emulator (mintty) sends a keystroke, it calls `master::write()`. After acquiring `input_mutex`, the function decides which path to take:
  ++### Pseudo Console Oscillation
   +
  -+1. **Path 1 — pcon+nat** (line ~2245): If `to_be_read_from_nat_pipe()` AND `pcon_activated` AND `pty_input_state == to_nat` → write directly to `to_slave_nat`. This is the fast path for native apps with pcon.
  ++When a native process spawns short-lived Cygwin children (e.g. `git.exe` calling `cygpath` via `--format`), the pseudo console activates and deactivates in rapid succession:
   +
  -+2. **Path 2 — non-pcon transfer** (line ~2288): If `to_be_read_from_nat_pipe()` AND NOT `pcon_activated` AND `pty_input_state == to_cyg` → call `transfer_input(to_nat)` to move cyg pipe data to nat pipe, then fall through to line_edit.
  ++1. Native process in foreground: `pcon_activated=true`, `pty_input_state=to_nat`
  ++2. Cygwin child starts: `setpgid_aux()` fires, transfers data to cyg pipe, `pcon_activated=false`, `pty_input_state=to_cyg`
  ++3. Cygwin child exits (milliseconds later): native process regains foreground, pcon reactivates
   +
  -+3. **Path 3 — line_edit** (line ~2300): The default/fallthrough path. Calls `line_edit()` which processes the input through terminal line discipline and then calls `accept_input()`, which writes to either the cyg or nat pipe based on the current `pty_input_state`.
  ++**The key design principle for handling oscillation:** keystrokes must always go to the nat pipe while `switch_to_nat_pipe` is true, regardless of `pcon_activated` or foreground status flickering. When keystrokes reach the nat pipe while the pcon is temporarily deactivated, they go through the raw pipe (not via conhost). When `transfer_input` runs at cleanup, it moves them back. This is safe because the keystrokes stay in the nat pipe in chronological order.
   +
  -+The conditions checked at each step involve multiple shared-memory fields (`to_be_read_from_nat_pipe()`, `pcon_activated`, `pty_input_state`). If any of these fields changes between consecutive calls to `master::write()` — or worse, between the check and the write within a single call — input can end up in the wrong pipe.
  ++The bugs that cause keystroke reordering are always of the form: some bytes go to the cyg pipe (via `line_edit` fallthrough) while others go to the nat pipe (via the fast path), and the two sets arrive at bash's readline in the wrong order. The fix is to prevent the split: either ALL bytes go to one pipe, or the routing decision is properly synchronized so that no bytes leak to the wrong pipe.
   +
   +### Key Functions for State Transitions
   +
  -+- **`setup_for_non_cygwin_app()`** (~line 4150): Called when a non-Cygwin process becomes foreground. Sets up the pseudo console and switches input to nat pipe.
  -+- **`cleanup_for_non_cygwin_app()`** (~line 4184): Called when the non-Cygwin process exits. Tears down pcon, transfers input back to cyg pipe.
  -+- **`reset_switch_to_nat_pipe()`** (~line 1091): Cleanup function called from various slave-side operations (e.g., `bg_check()`, `setpgid_aux()`). Detects when the nat pipe owner has exited and resets state. This function is particularly subtle because it runs in the slave process and modifies shared state that the master relies on.
  -+- **`mask_switch_to_nat_pipe()`** (~line 1249): Temporarily masks/unmasks the nat pipe switching. Used when a Cygwin process starts/stops reading from the slave.
  -+- **`setpgid_aux()`** (~line 4214): Called when the foreground process group changes. May trigger pipe switching.
  ++- **`setup_for_non_cygwin_app()`**: Called when a non-Cygwin process is about to be spawned. Sets up the pseudo console and switches input to nat pipe. Holds `pipe_sw_mutex` during the entire setup to prevent the master from seeing inconsistent state.
  ++- **`cleanup_for_non_cygwin_app()`**: Called when the non-Cygwin process exits. First calls `transfer_input(to_cyg)` to move all pending input from the nat pipe (conhost's console buffer) back to the cyg pipe. Then tears down the pcon via `close_pseudoconsole()`. The transfer must happen BEFORE the pcon is closed (while the console is still accessible).
  ++- **`reset_switch_to_nat_pipe()`**: Cleanup function called from `bg_check()` and `setpgid_aux()`. Detects when the nat pipe owner has exited and resets state. Only performs cleanup when no other process owns the nat pipe and the owner is dead. Does NOT clean up when the owner is self (bash) or alive, to avoid tearing down active sessions.
  ++- **`transfer_input()`**: Moves pending data between the cyg and nat pipes. When transferring to cyg with pcon active, reads `INPUT_RECORD` events from the console via `ReadConsoleInputA()`. When transferring to cyg, signals `input_transferred_to_cyg` so the master's forward thread can apply `line_edit()` to the transferred bytes.
  ++- **`setpgid_aux()`**: Called when the foreground process group changes. Triggers `transfer_input` in the appropriate direction. Releases `pipe_sw_mutex` before acquiring `input_mutex` to maintain consistent lock ordering.
   +
   +### Debugging Tips
   +
   +When investigating PTY-related bugs, keep these patterns in mind:
   +
  -+- **Data in two pipes**: If characters are lost, duplicated, or reordered, check whether data ended up split across the cyg and nat pipes due to a state transition during input.
  -+- **Cross-process state changes**: The master and slave processes share state through the `tty` structure in shared memory. A state change in the slave (e.g., `reset_switch_to_nat_pipe()`) is immediately visible to the master, without any notification. Look for races where the master reads state, acts on it, but the state changed between the read and the action.
  -+- **Mutex coverage gaps**: Check whether every modification of `pty_input_state`, `pcon_activated`, and `switch_to_nat_pipe` is protected by the appropriate mutex. The existence of two separate mutexes (`input_mutex` and `pipe_sw_mutex`) means that holding one does not protect against changes guarded by the other.
  -+- **`transfer_input()` must accompany state changes**: Whenever `pty_input_state` is changed, any data buffered in the old pipe must be transferred to the new one. Forgetting this step causes data loss or reordering.
  -+- **Tracing**: For timing-sensitive bugs, in-process tracing with lock-free per-thread buffers (using Windows TLS and `QueryPerformanceCounter`) is effective. Avoid file I/O during reproduction — accumulate in memory and dump at process exit. See the `ui-tests/` directory for AutoHotKey-based reproducers that can drive mintty programmatically.
  ++- **Trace the full keystroke lifecycle**: Do not stop at "the keystroke goes to pipe X." Follow it all the way to where bash's readline receives it, including any `transfer_input` calls at cleanup. The most common bugs involve bytes being split across the two pipes and arriving at readline out of order.
  ++- **Check the routing decision in `to_be_read_from_nat_pipe()`**: This function is the gatekeeper for all routing decisions. If it returns the wrong value, keystrokes go to the wrong pipe. Verify that it holds `pipe_sw_mutex` while reading state, and that it does not have unnecessary checks (like `nat_fg()`) that create gaps during transitions.
  ++- **Study existing upstream patches before writing fixes**: Takashi Yano is the upstream PTY maintainer and understands the state machine deeply. When he proposes patches on cygwin-patches@, apply and test his full series before attempting alternative fixes. His patches form cohesive sets where individual patches depend on each other for correct behavior. Cherry-picking individual patches from his series will break invariants.
  ++- **Never remove `transfer_input()` calls without understanding what they transfer**: The transfers at `setpgid_aux()`, `cleanup_for_non_cygwin_app()`, and the pcon_start completion block each serve specific purposes. Removing them loses data. The correct fix for reordering bugs is to ensure keystrokes consistently go to one pipe (typically by fixing the routing decision), not to remove the transfer that reunites split data.
  ++- **The `pcon_start` handler is only for CSI6n**: During pcon initialization, `pcon_start=true` tells `master::write()` to enter a special handler that accumulates the CSI6n response. Non-CSI bytes in this handler go through `line_edit()` to the cyg pipe. This is correct and intentional: during the brief CSI6n exchange, the pcon is not yet ready to receive user input, so `line_edit()` buffers it for bash. The pcon_start handler is NOT a general-purpose input router and should not be modified to route bytes to the nat pipe.
  ++- **Tracing**: For timing-sensitive bugs, use a memory-mapped ring buffer (not per-event file I/O, which changes timings). The master process (mintty) is a MinGW program; C++ static destructors in msys-2.0.dll do NOT fire when it exits. Use `CreateFileMapping` + `MapViewOfFile` for trace buffers that persist after process termination. Use `QueryPerformanceCounter` for microsecond timestamps. Trace across both master and slave processes using separate per-PID files.
   +
   +## Packaging
   +
  @@ AGENTS.md (new)
   +- **Cygwin project**: https://cygwin.com — upstream source, FAQ, user's guide
   +- **Cygwin source**: https://github.com/cygwin/cygwin (mirror of `sourceware.org/git/newlib-cygwin.git`)
   +- **Cygwin announcements**: https://inbox.sourceware.org/cygwin-announce — release announcements
  ++- **Cygwin mailing lists**: https://inbox.sourceware.org/cygwin/ (general), https://inbox.sourceware.org/cygwin-patches/ (patches), https://inbox.sourceware.org/cygwin-developers/ (internals) — essential for understanding why specific code was added; commit messages often reference these discussions
   +- **MSYS2 project**: https://www.msys2.org — documentation, package management
   +- **MSYS2 runtime source**: https://github.com/msys2/msys2-runtime
   +- **MSYS2 packages**: https://github.com/msys2/MSYS2-packages — package recipes including `msys2-runtime`

• 66: 40e2b5d ! 51: 4bd00d6 Cygwin: CI: update Actions versions

  @@ Metadata
    ## Commit message ##
       Cygwin: CI: update Actions versions
   
  -    Bumps [actions/checkout](https://github.com/actions/checkout) from 5 to 6.
  -    - [Release notes](https://github.com/actions/checkout/releases)
  -    - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
  -    - [Commits](https://github.com/actions/checkout/compare/v5...v6)
  -
  -    Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 5 to 6.
  -    - [Release notes](https://github.com/actions/upload-artifact/releases)
  -    - [Commits](https://github.com/actions/upload-artifact/compare/v5...v6)
  +    Essentially, all of these major version updates bump the requirements to
  +    Node.JS 24.
   
       Originally-authored-by: dependabot[bot] <support@github.com>
       Signed-off-by: Johannes Schindelin <johannes.schindelin@gmx.de>
  @@ .github/workflows/cygwin.yml: jobs:
          HAS_SSH_KEY: ${{ secrets.SSH_KEY != '' }}
    
        steps:
  --    - uses: actions/checkout@v5
  +-    - uses: actions/checkout@v3
   +    - uses: actions/checkout@v6
    
        # install build tools
  @@ .github/workflows/cygwin.yml: jobs:
          run: |
            icacls . /inheritance:r
            icacls . /grant Administrators:F
  --    - uses: actions/checkout@v5
  +-    - uses: actions/checkout@v3
   +    - uses: actions/checkout@v6
    
        # install cygwin and build tools
  @@ .github/workflows/cygwin.yml: jobs:
    
        # upload test logs to facilitate investigation of problems
        - name: Upload test logs
  --      uses: actions/upload-artifact@v5
  +-      uses: actions/upload-artifact@v4
   +      uses: actions/upload-artifact@v6
          with:
            name: testlogs

• 42: 63747e4 ! 52: b72ad68 fixup! CI: add a GHA for doing a basic build test

  @@ .github/workflows/build.yaml: jobs:
            with:
              name: install
              path: ${{ steps.msys2.outputs.msys2-location }}
  -
  - ## .github/workflows/cygwin.yml ##
  -@@ .github/workflows/cygwin.yml: jobs:
  -       HAS_SSH_KEY: ${{ secrets.SSH_KEY != '' }}
  - 
  -     steps:
  --    - uses: actions/checkout@v3
  -+    - uses: actions/checkout@v5
  - 
  -     # install build tools
  -     - name: Install build tools
  -@@ .github/workflows/cygwin.yml: jobs:
  -       run: |
  -         icacls . /inheritance:r
  -         icacls . /grant Administrators:F
  --    - uses: actions/checkout@v3
  -+    - uses: actions/checkout@v5
  - 
  -     # install cygwin and build tools
  -     - name: Install Cygwin

• 44: ee9f333 = 53: 9e748a0 fixup! CI: add a GHA for doing a basic build test

• 49: ee961da < -: ------- Use MB_CUR_MAX == 6 by default

• 52: 7292892 = 54: 11e29af dependabot: help keeping GitHub Actions versions up to date

• 53: 0871d6d = 55: c18d12c Do not try to sync with Cygwin

• 54: 3a476d9 = 56: a85ceb4 ci: run Git's entire test suite

• 55: ad7fedc ! 57: 7eb77ae Start implementing UI-based tests by adding an AutoHotKey library

  @@ ui-tests/ui-test-library.ahk (new)
   +    return Result
   +}
   +
  -+; This function is quite the hack. It assumes that the Windows Terminal is the active window,
  -+; then drags the mouse diagonally across the window to select all text and then copies it.
  -+;
  -+; This is fragile! If any other window becomes active, or if the mouse is moved,
  -+; the function will not work as intended.
  -+;
  -+; An alternative would be to use `ControlSend`, e.g.
  -+; `ControlSend '+^a', 'Windows.UI.Input.InputSite.WindowClass1', 'ahk_id ' . hwnd
  -+; This _kinda_ works, the text is selected (all text, in fact), but the PowerShell itself
  -+; _also_ processes the keyboard events and therefore they leave ugly and unintended
  -+; `^Ac` characters in the prompt. So that alternative is not really usable.
  -+CaptureTextFromWindowsTerminal(winTitle := '') {
  ++; Capture the Windows Terminal buffer via the exportBuffer action (Ctrl+Shift+F12).
  ++; Requires a portable WT with settings.json that maps Ctrl+Shift+F12 to exportBuffer
  ++; writing to <script-dir>/wt-buffer-export.txt.
  ++CaptureBufferFromWindowsTerminal(winTitle := '') {
  ++    static exportFile := A_ScriptDir . '\wt-buffer-export.txt'
  ++    if FileExist(exportFile)
  ++        FileDelete exportFile
   +    if winTitle != ''
   +        WinActivate winTitle
  -+    ControlGetPos &cx, &cy, &cw, &ch, 'Windows.UI.Composition.DesktopWindowContentBridge1', "A"
  -+    titleBarHeight := 54
  -+    scrollBarWidth := 28
  -+    pad := 8
  -+
  -+    SavedClipboard := ClipboardAll
  -+    A_Clipboard := ''
  -+    SendMode('Event')
  -+    if winTitle != ''
  -+        WinActivate winTitle
  -+    MouseMove cx + pad, cy + titleBarHeight + pad
  -+    if winTitle != ''
  -+        WinActivate winTitle
  -+    MouseClickDrag 'Left', , , cx + cw - scrollBarWidth, cy + ch - pad, , ''
  -+    if winTitle != ''
  -+        WinActivate winTitle
  -+    MouseClick 'Right'
  -+    ClipWait()
  -+    Result := A_Clipboard
  -+    Clipboard := SavedClipboard
  -+    return Result
  ++    Sleep 200
  ++    Send '^+{F12}'
  ++    deadline := A_TickCount + 3000
  ++    while !FileExist(exportFile) && A_TickCount < deadline
  ++        Sleep 50
  ++    if !FileExist(exportFile)
  ++        return ''
  ++    Sleep 100
  ++    return FileRead(exportFile)
   +}
   +
   +WaitForRegExInWindowsTerminal(regex, errorMessage, successMessage, timeout := 5000, winTitle := '') {
  @@ ui-tests/ui-test-library.ahk (new)
   +    ; Wait for the regex to match in the terminal output
   +    while true
   +    {
  -+        capturedText := CaptureTextFromWindowsTerminal(winTitle)
  ++        capturedText := CaptureBufferFromWindowsTerminal(winTitle)
   +        if RegExMatch(capturedText, regex)
   +            break
   +        Sleep 100
  @@ ui-tests/ui-test-library.ahk (new)
   +            Info('Captured text:`n' . capturedText)
   +            ExitWithError errorMessage
   +        }
  -+        if winTitle != ''
  -+            WinActivate winTitle
  -+        MouseClick 'WheelDown', , , 20
   +    }
   +    Info(successMessage)
   +}

• 74: 78d4be1 ! 58: 2a344f8 amend! Start implementing UI-based tests by adding an AutoHotKey library

  @@ Metadata
   Author: Johannes Schindelin <johannes.schindelin@gmx.de>
   
    ## Commit message ##
  -    amend! Start implementing UI-based tests by adding an AutoHotKey library
  -
       Start implementing UI-based tests by adding an AutoHotKey library
   
       AutoHotKey is not only a convenient way to add keyboard shortcuts for
  @@ ui-tests/ui-test-library.ahk: CleanUpWorkTree() {
    }
    
    closeWindow := false
  +@@ ui-tests/ui-test-library.ahk: WaitForRegExInWindowsTerminal(regex, errorMessage, successMessage, timeout := 50
  +     while true
  +     {
  +         capturedText := CaptureBufferFromWindowsTerminal(winTitle)
  +-        if RegExMatch(capturedText, regex)
  +-            break
  ++        if RegExMatch(capturedText, regex, &matchObj)
  ++        {
  ++            Info(successMessage)
  ++            return matchObj
  ++        }
  +         Sleep 100
  +         if A_TickCount > timeout {
  +             Info('Captured text:`n' . capturedText)
  +             ExitWithError errorMessage
  +         }
  +     }
  +-    Info(successMessage)
  + }
  + \ No newline at end of file

• 56: ec92134 ! 59: ae49b26 ci: add an AutoHotKey-based integration test

  @@ Commit message
         quite a bit to get the syntax right.
   
       - Windows Terminal does not use classical Win32 controls that AutoHotKey
  -      knows well. In particular, there is no easy way to capture the text
  -      that is shown in the Terminal. I tried the (pretty excellent!) [OCR
  -      for AutoHotKey](https://github.com/Descolada/OCR), but it uses UWP OCR
  -      which does not recognize constructs like "C:\Users

unneradmin>"

•  because it is not English (or any other human language). I ended up
  

•  with a pretty inelegant method of selecting the text via mouse
  

•  movements and then copying that into the clipboard. This stops
  

•  scrolling and I worked around that by emulating the mouse wheel
  

•  afterwards.
  

• • Since Windows Terminal does not use classical Win32 controls, it is

•  relatively hard to get to the exact bounding box of the text, as there
  

•  is no convenient way to determine the size of the title bar or the
  

•  amount of padding around the text. I ended up hard-coding those
  

•  values, I'm not proud of that, but at least it works.
  

•  knows well. To capture the terminal text, we use Windows Terminal's
  

•  exportBuffer action, which writes the entire scrollback to a file on a
  

•  keybinding (Ctrl+Shift+F12). This requires running Windows Terminal in
  

•  portable mode with a settings.json that defines the action, which the
  

•  setup script takes care of.
  

  • Despite my expectations, ExitApp would not actually exit AutoHotKey
    before the spawned process exits and/or the associated window is
    @@ Commit message
    For good measure, run this test both on windows-2022 (corresponding to
    Windows 10) and on windows-2025 (corresponding to Windows 11).

• Note that this does not use the naive method to capture text from

• Windows Terminal, emulating mouse movements, dragging across the entire

• window with finicky pixel calculations for title bar height, scroll bar

• width and padding, then right-clicks to copy. This would be fragile:

• if the window geometry changes, if another window gets focus, or if the

• title bar height differs between OS versions, the capture silently gets

• the wrong text.

• Windows Terminal's exportBuffer action avoids all of that by writing the

• complete scrollback buffer to a file on a keybinding, with no dependence

• on pixel positions or window focus. To use it, Windows Terminal must

• run in portable mode with a settings.json that defines the action and

• keybinding. So that's what we do here.

• We add setup-portable-wt.ps1, which downloads Windows Terminal

• (when not already present), creates the .portable marker and writes

• settings.json with Ctrl+Shift+F12 bound to exportBuffer. It accepts

• a -DestDir parameter so CI can use $RUNNER_TEMP while local

• development uses $TEMP. When running inside GitHub Actions it also

• appends the Windows Terminal directory to $GITHUB_PATH.

• Co-authored-by: Eu-Pin Tien eu-pin.tien@diamond.ac.uk

• Assisted-by: Claude Opus 4.6
  Signed-off-by: Johannes Schindelin johannes.schindelin@gmx.de

• Converted ui-tests workflow into a test matrix that uses both the windows-2022 and windows-2025 runners.

• .github/workflows/build.yaml

@@ .github/workflows/build.yaml: jobs:
     with:

@@ .github/workflows/ui-tests.yml (new)
+ $p = Get-ChildItem -Recurse "${env:RUNNER_TEMP}�rtifacts" | where {$_.Name -eq "msys-2.0.dll"} | Select -ExpandProperty VersionInfo | Select -First 1 -ExpandProperty FileName
+ cp $p "c:/Program Files/Git/usr/bin/msys-2.0.dll"
+
++ - uses: actions/checkout@v6
++ with:
++ sparse-checkout: |
++ ui-tests
++
+ - uses: actions/cache/restore@v5
+ id: restore-wt
+ with:
+ key: wt-${{ env.WT_VERSION }}
+ path: ${{ runner.temp }}/wt.zip
-+ - name: Download Windows Terminal
-+ if: steps.restore-wt.outputs.cache-hit != 'true'
-+ shell: bash
++ - name: Install and configure portable Windows Terminal
++ working-directory: ui-tests
+ run: |
-+ curl -fLo "$RUNNER_TEMP/wt.zip"
-+ https://github.com/microsoft/terminal/releases/download/v$WT_VERSION/Microsoft.WindowsTerminal_${WT_VERSION}_x64.zip
++ powershell -File setup-portable-wt.ps1 -WtVersion $env:WT_VERSION -DestDir $env:RUNNER_TEMP
+ - uses: actions/cache/save@v5
+ if: steps.restore-wt.outputs.cache-hit != 'true'
+ with:
+ key: wt-${{ env.WT_VERSION }}
+ path: ${{ runner.temp }}/wt.zip
-+ - name: Install Windows Terminal
-+ shell: bash
-+ working-directory: ${{ runner.temp }}
-+ run: |
-+ "$WINDIR/system32/tar.exe" -xf "$RUNNER_TEMP/wt.zip" &&
-+ cygpath -aw terminal-$WT_VERSION >>$GITHUB_PATH
+ - uses: actions/cache/restore@v5
+ id: restore-ahk
+ with:
@@ .github/workflows/ui-tests.yml (new)
+ cygpath -aw "$RUNNER_TEMP/ahk" >>$GITHUB_PATH
+ - uses: actions/setup-node@v6 # the hook uses node for the background process
+
-+ - uses: actions/checkout@v6
-+ with:
-+ sparse-checkout: |
-+ ui-tests
+ - name: Run UI tests
+ id: ui-tests
+ timeout-minutes: 10
@@ .github/workflows/ui-tests.yml (new)
+ $exitCode = 0
+ & "${env:RUNNER_TEMP}�hk\AutoHotKey64.exe" /ErrorStdOut /force ui-tests�ackground-hook.ahk "$PWD�g-hook" 2>&1 | Out-Default
+ if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
-+ type bg-hook.log
+ exit $exitCode
+ - name: Show logs
+ if: always()
@@ .github/workflows/ui-tests.yml (new)
## ui-tests/.gitattributes (new) ##
@@
+.ahk eol=lf
++.ps1 eol=lf

 ## ui-tests/background-hook.ahk (new) ##
@@

@@ ui-tests/background-hook.ahk (new)
+; Verify that CursorUp shows the previous command
+Send('{Up}')
+Sleep 150
-+Text := CaptureTextFromWindowsTerminal()
++Text := CaptureBufferFromWindowsTerminal()
+if not RegExMatch(Text, 'git commit --allow-empty -m zOMG *$')
+ ExitWithError 'Cursor Up did not work: ' Text
+Info('Match!')
@@ ui-tests/background-hook.ahk (new)
+Sleep 50
+CleanUpWorkTree()
\ No newline at end of file
+

• ui-tests/setup-portable-wt.ps1 (new)

+@@
++# Configures a portable Windows Terminal for the UI tests.
++#
++# Downloads WT if needed, then creates .portable marker and settings.json
++# with exportBuffer bound to Ctrl+Shift+F12. The export file lands in the
++# script's own directory (ui-tests/) so it gets uploaded as build artifact.
++#
++# The portable WT uses its own settings directory (next to the executable)
++# so it never touches the user's installed Windows Terminal configuration.
++
++param(
++ [string]$WtVersion = $env:WT_VERSION,
++ [string]$DestDir = $env:TEMP
++)
++
++if (-not $WtVersion) { $WtVersion = '1.22.11141.0' }
++
++$wtDir = "$DestDir erminal-$WtVersion"
++$wtExe = "$wtDir\wt.exe"
++
++# Download if the directory doesn't contain wt.exe yet
++if (-not (Test-Path $wtExe)) {
++ $wtZip = "$DestDir\wt.zip"
++ if (-not (Test-Path $wtZip)) {
++ $url = "https://github.com/microsoft/terminal/releases/download/v$WtVersion/Microsoft.WindowsTerminal_${WtVersion}_x64.zip"
++ Write-Host "Downloading Windows Terminal $WtVersion ..."
++ curl.exe -fLo $wtZip $url
++ if ($LASTEXITCODE -ne 0) { throw "Download failed" }
++ }
++ Write-Host "Extracting ..."
++ & "$env:WINDIR\system32 ar.exe" -C $DestDir -xf $wtZip
++ if ($LASTEXITCODE -ne 0) { throw "Extract failed" }
++}
++
++# Create .portable marker so WT reads settings from settings\ next to wt.exe
++$portableMarker = "$wtDir.portable"
++if (-not (Test-Path $portableMarker)) {
++ Set-Content -Path $portableMarker -Value ""
++}
++
++# Write settings.json with exportBuffer action
++$settingsDir = "$wtDir\settings"
++if (-not (Test-Path $settingsDir)) { New-Item -ItemType Directory -Path $settingsDir -Force | Out-Null }
++
++$bufferExportPath = ($PSScriptRoot + '\wt-buffer-export.txt') -replace '', '/'
++
++$settings = @"
++{
++ "`$schema": "https://aka.ms/terminal-profiles-schema",
++ "actions": [
++ {
++ "command": {
++ "action": "exportBuffer",
++ "path": "$bufferExportPath"
++ },
++ "id": "User.TestExportBuffer"
++ },
++ {
++ "command": { "action": "copy", "singleLine": false },
++ "id": "User.copy"
++ },
++ { "command": "paste", "id": "User.paste" }
++ ],
++ "copyFormatting": "none",
++ "copyOnSelect": false,
++ "defaultProfile": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
++ "keybindings": [
++ { "id": "User.TestExportBuffer", "keys": "ctrl+shift+f12" },
++ { "id": null, "keys": "ctrl+v" },
++ { "id": null, "keys": "ctrl+c" }
++ ],
++ "profiles": {
++ "defaults": {},
++ "list": [
++ {
++ "commandline": "%SystemRoot%\System32\WindowsPowerShell�1.0\powershell.exe",
++ "guid": "{61c54bbd-c2c6-5271-96e7-009a87ff44bf}",
++ "hidden": false,
++ "name": "Windows PowerShell"
++ }
++ ]
++ },
++ "schemes": [],
++ "themes": []
++}
++"@
++
++Set-Content -Path "$settingsDir\settings.json" -Value $settings
++
++# Add WT to PATH if running in GitHub Actions
++if ($env:GITHUB_PATH) {
++ $wtDir | Out-File -Append -FilePath $env:GITHUB_PATH
++}
++
++Write-Host "Portable WT ready at: $wtDir"
++Write-Host " exportBuffer path: $bufferExportPath"
++Write-Host " exportBuffer key: Ctrl+Shift+F12"

* 57:  d0d28f3 ! 60:  c695b96 ci(ui-tests): upload the test logs

``````diff
@@ .github/workflows/ui-tests.yml: jobs:
 -          & "${env:RUNNER_TEMP}�hk\AutoHotKey64.exe" /ErrorStdOut /force ui-tests�ackground-hook.ahk "$PWD�g-hook" 2>&1 | Out-Default
 +          & "${env:RUNNER_TEMP}�hk\AutoHotKey64.exe" /ErrorStdOut /force background-hook.ahk "$PWD�g-hook" 2>&1 | Out-Default
            if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
-           type bg-hook.log
            exit $exitCode
        - name: Show logs
          if: always()

• 58: 5fe6836 = 61: 98f3ccf ci(ui-tests): take a screenshot when canceled

• 59: 681f35e ! 62: 2886c18 ui-tests: verify that a sleep in Windows Terminal can be interrupted

  @@ Commit message
   
    ## .github/workflows/ui-tests.yml ##
   @@ .github/workflows/ui-tests.yml: jobs:
  +           $exitCode = 0
              & "${env:RUNNER_TEMP}�hk\AutoHotKey64.exe" /ErrorStdOut /force background-hook.ahk "$PWD�g-hook" 2>&1 | Out-Default
              if (!$?) { $exitCode = 1; echo "::error::Test failed!" } else { echo "::notice::Test log" }
  -           type bg-hook.log
   +          & "${env:RUNNER_TEMP}�hk\AutoHotKey64.exe" /ErrorStdOut /force ctrl-c.ahk "$PWD

[dscho]

/open pr

The workflow run was started