T55: a drag moves Ely along the edge she stands on, which the owner asked for after 0.1.5: on macOS, Windows and X11 her window follows the pointer's place on the screen, on Wayland her popup opens again where she is let go; she moves by whole points inside the pane, and the settings keep where she stands as ely_left, 140 by default

AGENTS.md

@@ -111,3 +111,4 @@ ELYTerminal. A terminal on GPUI and Ely components. `PRD.md` says what it does;
 - 2026-10-18: Ely peeks over the main window's top edge, which the owner asked for after the 0.1.3 film, her head and fingers drawn from the icon's own paths and cut at the edge she holds, in a transparent window of her own, 112 by 107 points with 16 above her for her hops, 140 in from the pane's left edge, less on a pane too narrow for that, so she holds its edge at any width, and the main window seems to hide the rest of her. Her window never takes the keys from the terminal: on macOS her panel becomes key only if needed, which gpui's view never asks; on Windows her window answers a press's activation with none, every other message passed on to gpui's own procedure; on X11 and Wayland a press moves no focus. gpui moves no window and places its popups only on Wayland, so each platform keeps her there its own way: on macOS gpui's popup panel is made the main window's child, at its level and in its Spaces, without a shadow, so AppKit moves it and hides it with the window; on Windows gpui's popup is owned by the main window and loses the topmost place gpui gives it, so it stays just above the main window and hides with it; gpui makes it an overlapped window, which Windows gives a caption and a frame, and opens it as large as the display when the middle of the box asked for lies off every display, as hers does over a window near the screen's top: in 0.1.4 a user found her at the bottom of a framed window the display's size, which took the clicks meant for the windows behind; so it becomes a bare popup, without caption, frame, corners or shadow, and the glue posts her window her bottom left corner on the pane's top edge as the main window moves, since Windows sends a new size at once and gpui hears it only outside its own updates, as gpui defers its own resize; her window sizes her at the DPI it has when the place lands, so her height is her own DPI's and her bottom the pane's top, whatever the two windows' DPI, and a place posted before her DPI changed sizes her at the new one; at a new DPI gpui takes the rect Windows suggests, and once the move that brought it is done she takes her box at that DPI on the corner her last place gave her, while that DPI is still hers and the box lies mostly on a display of it, as Windows reckons a window's display, else Windows' rect stands; so a keep changes no DPI and posts no other, where between two displays a corner kept always, or a keep whose DPI had passed while places piled up, set her DPI back, and back again; on X11 gpui's popup, which no window manager places, is moved onto the pane, stacked just above the window manager's frame as the window moves or comes forward, and unmapped while it hides; on Wayland she is gpui's anchored popup, an xdg_popup on the pane's top edge, which the compositor keeps there; gpui moves a popup's anchor never, so a new width that moves her place opens her again. She opens with the sessions' mood and moves all the time, as the films move her, which the owner asked for after 0.1.4, where she stood still but for a press. She is rigged from the icon's paths as the films rig her, in layers of one color, each an SVG mask gpui rasterizes once at its size and moves with a matrix of its own after its pixels are placed, so she moves between pixels; her head bobs with her breath while her neck, collar and hands stay on the edge, her side locks sway, her ahoge breathes, and she blinks on her own, at times twice. Her mood sets her act: calm, she glances left, then right, her head after her eyes, and dozes after 5 minutes, her eyes falling shut, her head and ahoge drooping, zs floating up, the 5 minutes counted from her mood's start or the last press, so a press wakes her, which the owner asked for after 0.1.4, where only a new mood did; a program that works runs her eyes along the terminal's lines while her fingers tap by turns; one that waits on you widens her eyes, opens her mouth, rocks a mark beside her and hops her twice every 2.6 s; an error raises her brows and shakes her, more softly every 4.5 s after, while a drop runs down; a finish cheers her for 4 s with smiling eyes, a hop and sparkles; a press winks at you while a heart rises. Each act begins with her eyes opening and her mouth popping, and a change of act, a change of mood though the act stays, as inside a wink, and a press each ease her from the pose she was in, in 0.3 s, her brows with her, the marks she leaves fading. She draws at every frame the display gives her window while it shows, and gpui gives a hidden window none; her time is folded into each move's round in f64, so weeks of one mood keep her steps fine. Settings › Terminal › Ely turns her off; she is on by default.
 - 2026-10-19: Ely stands inside the main window, her bottom on its pane's bottom edge, as far in from the left, while her box would not fit above it, which the owner asked for after 0.1.4: on a window at the screen's top or full screen her titled macOS panel, which AppKit keeps under the menu bar, stuck between the menu bar and the terminal, and on Windows and X11 she stood off the screen. The rule lives in `pet.rs`: she stands on the top edge while the room above the pane, up to the top of the work area of the main window's display, holds her box, 123.4 points; each platform measures the room and places her: macOS from the main window's `frame` and its `screen`'s `visibleFrame`, which leaves out the menu bar, both in AppKit's points; Windows from the client rect and the work area (`rcWork`) of the monitor `MonitorFromWindow` names, at the main window's scale, since above it or inside it she stands on that monitor; X11 from the pane's place on the root, up to the top of the RandR monitor holding most of it, as Windows and macOS pick a window's display, or of `_NET_WORKAREA`, its first desktop's, where that lies lower: the work area spans every monitor, so on a lower monitor its top is another's. A Wayland client knows no place of its own, so there she stands on the bottom edge while the window is full screen, maximized or tiled at its top, which gpui reports only for a window it draws itself: under server decorations, as Sway's tiling draws them, she stays on top. gpui moves a popup's anchor never, hears a change of state alone as no change of bounds, and gives an unseen popup no frames, so twice a second she checks where the window's size and state put her anchor, counted from the pane as gpui counts it, and opens there again when it moved. Each place logs the edge she moves to. On WSLg, X11 and Weston's Wayland both put her inside a window as tall as the screen or maximized, and over one with room; headless Sway and a two-monitor Xorg did too.
 - 2026-10-19: Ely's window shows nothing but her, which the owner asked for after a user's 0.1.4 drew a hairline along the top of her box on macOS. gpui opens a popup as a titled panel, style mask 0x8081, titled, full-size content and nonactivating, and macOS draws a titled window's frame, there as a light edge over the clear room above her head. As it is glued her panel turns borderless, nonactivating alone, 0x80, and the log names both masks; a mask that does not take fails the glue, which closes her window, as any failed glue now does, where her window stayed open, unplaced, while the log said she did not show. macOS 27.2 draws nothing of that frame, so the line never showed here, the app active or not; there a real click on her borderless panel still winks her, the front app stays in front, and keys typed after it reach the terminal. On Windows her bare popup, and on Linux X11's override-redirect window and Wayland's xdg_popup, draw no frame, border or shadow.
+- 2026-10-19: a drag moves Ely along the edge she stands on, which the owner asked for after 0.1.5. On macOS, Windows and X11 her glue moves her window after the pointer's place on the screen, `NSEvent`'s `mouseLocation`, `GetCursorPos` and `query_pointer`, since her window moves under the pointer, so a place in it would lag; her window keeps the pointer while the button is held, inside it or not, as AppKit, gpui's `SetCapture` and X's implicit grab give it. A Wayland popup cannot move, so there she moves once let go: the settings keep the place, and the twice-a-second check opens her popup there. She moves by whole points inside the pane, and `ely_left` keeps where she stands, 140 by default, where she stood before; a narrower pane holds her at its right end, and the log names where she is let go. Under Xorg's dummy screen xdotool dragged her 200 pixels and her window followed them; under Sway nested in Xorg, whose X input gives its seat a pointer, xdotool's drag reopened her popup 200 points on. Sway's own `seat cursor` commands send no motion while their press is held, and Sway draws no popup opened before its window settled, so a probe there reopens her before it drags.

PRD.md

@@ -70,7 +70,7 @@ Ghostty is the bar for what the terminal does. ELYTerminal owns its engine on `a
 - The window opens at the size it was left at, on macOS, Windows and Linux: the size is kept in settings once it settles; a maximized or full-screen window keeps the size from before; a kept size past the screen shrinks to it; the window is no smaller than 100 by 100, the least the settings keep.
 - The title shows the active session's title, and no other text.
 - The pointer over the terminal is the arrow.
-- Ely, the icon's girl, peeks over the window's top edge from behind it, on macOS, Windows and Linux; where no room lies above the window, at the screen's top or full screen, she stands inside it at its bottom left. She moves all the time, as she does in the films: she breathes, sways and blinks, and how the sessions are doing, waiting, an error, work, a finish or calm, moves her. Nothing but her shows: no frame, line or shadow around her. A press pets her, and wakes her from a doze. A switch in Settings, Terminal, turns her off.
+- Ely, the icon's girl, peeks over the window's top edge from behind it, on macOS, Windows and Linux; where no room lies above the window, at the screen's top or full screen, she stands inside it at its bottom left. She moves all the time, as she does in the films: she breathes, sways and blinks, and how the sessions are doing, waiting, an error, work, a finish or calm, moves her. Nothing but her shows: no frame, line or shadow around her. A press pets her, and wakes her from a doze. A drag moves her along the edge she stands on, and she stays where she is let go. A switch in Settings, Terminal, turns her off.
 - The title bar is transparent, as Ghostty's: the window's background, opacity and blur run under it, so it wears the terminal's color.
 - Every control in the title bar takes its own press on every platform, the window buttons Ely draws on Windows and Linux too.
 

README.md

@@ -43,7 +43,7 @@ The app writes its log to stderr. `RUST_LOG=elyterminal=debug` writes more; `tra
 
 - The terminal runs on `alacritty_terminal`: 256 colors and truecolor, bold, dim, italic, five underline styles, wide characters and combining marks. Box drawing, block elements and powerline shapes are drawn as geometry, so lines join across cells. Keys follow xterm and the kitty keyboard protocol, and on Windows win32-input-mode, as Windows Terminal sends them, so herdr's shortcuts work; input methods compose at the cursor; programs can track the mouse; pastes are bracketed when a program asks; OSC 8 and plain links open with the link press below; inside herdr, herdr opens them, web links only, whole where its pane wraps them, and with Shift the terminal opens what it sees; find searches the scrollback.
 - Shell integration for zsh, bash, fish and PowerShell: each prompt reports its folder and title, and OSC 133 marks each prompt, each command and its exit status.
-- Ely peeks over the window's top edge, or up from its bottom left when the window leaves her no room above it, and moves all the time: she breathes, sways and blinks. She follows your sessions: she hops when a program waits on you, shakes at an error, cheers a finish, reads along while a program works, and dozes when all is calm for long. Press her and she winks, waking her from a doze. Settings › Terminal › Ely turns her off.
+- Ely peeks over the window's top edge, or up from its bottom left when the window leaves her no room above it, and moves all the time: she breathes, sways and blinks. She follows your sessions: she hops when a program waits on you, shakes at an error, cheers a finish, reads along while a program works, and dozes when all is calm for long. Press her and she winks, waking her from a doze. Drag her along the edge to move her. Settings › Terminal › Ely turns her off.
 - Sessions: new, close and switch. A bell marks a hidden session's row and makes no sound. A row's mark shows what its programs report through OSC 7501, OSC 9;4 or herdr: waiting on you, an error, work with its progress, done or idle, else a failed last command. The mark is 3 by 3 dots: work ripples and waiting dips while they last. Hover over the mark lists each report.
 - Notifications: while the window is in the background or the session hidden, a session that starts waiting, finishes or fails, and a program's OSC 9, 777 or 99, post a system notification, one a session every 3 seconds at most; a press shows the session. On macOS only the app bundle posts them, not `cargo run`.
 - Cmd-Up and Cmd-Down, Ctrl-Shift-Up and Ctrl-Shift-Down off macOS, jump to the prompt before or after the view's top.

TASKS.md

@@ -139,3 +139,12 @@ Progress truth. Top to bottom, one at a time. A task is ticked only after its co
 ## 29. Release
 
 - [x] T54 Release v0.1.5 with T51 to T53: version 0.1.5; the macOS disk image, the Windows zip and the Linux tarball, each from its script; the notes list what changed.
+
+## 30. Ely's drag and updates
+
+- [x] T55 A drag moves Ely along the edge she stands on, which the owner asked for after 0.1.5: she follows the pointer sideways inside the pane, on macOS, Windows and X11 as it moves, on Wayland, whose popup keeps its place, once it lets go; where she stands, in points from the pane's left edge, the settings keep as `ely_left`.
+- [ ] T56 Settings › Terminal checks for updates, which the owner asked for after 0.1.5: under Ely, a switch checks ELYTerminal's latest release at start and once a day, on by default, and a button checks at once; the row says what the check found, and a newer release brings a button that opens its page; a newer release an automatic check finds posts a system notification, whose press opens that page.
+
+## 31. Release
+
+- [ ] T57 Release v0.1.6 with T55 and T56: version 0.1.6; the macOS disk image, the Windows zip and the Linux tarball, each from its script; the notes list what changed.

src/pet.rs

@@ -18,10 +18,10 @@ use std::{
 };
 
 use gpui::{
-    App, AppContext as _, Bounds, Context, Decorations, InteractiveElement, IntoElement,
-    MouseButton, ParentElement, Pixels, Point, Render, Styled, Subscription, Window,
-    WindowBackgroundAppearance, WindowBounds, WindowHandle, WindowKind, WindowOptions, canvas, div,
-    point, popup, px, size,
+    App, AppContext as _, Bounds, Context, Decorations, DispatchPhase, InteractiveElement,
+    IntoElement, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, ParentElement, Pixels,
+    Point, Render, Styled, Subscription, Window, WindowBackgroundAppearance, WindowBounds,
+    WindowHandle, WindowKind, WindowOptions, canvas, div, point, popup, px, size,
 };
 
 #[cfg(target_os = "macos")]
@@ -40,8 +40,6 @@ use crate::{settings::SettingsStore, workspace::Workspace};
 const WIDTH: f32 = 112.0;
 const HEAD: f32 = 107.4;
 const ROOM: f32 = 16.0;
-/// How far in from the pane's left edge she holds its top edge.
-const LEFT: f32 = 140.0;
 /// How often she checks her Wayland anchor against the main window.
 const CHECK: Duration = Duration::from_millis(500);
 
@@ -70,6 +68,10 @@ pub struct Pet {
     /// The edge she stands on, and on Wayland the anchor her popup opened at, from the pane's top left, which never moves.
     edge: Edge,
     anchor: Option<Point<Pixels>>,
+    /// How far in from the pane's left edge she stands, and a drag under way: the pointer's x where it began and where she stood then.
+    at: f32,
+    drag: Option<(f32, f32)>,
+    main: WindowHandle<Workspace>,
     /// What keeps her window on the main window's edge, where the platform does not.
     glue: Option<platform::Glue>,
     _watch: Vec<Subscription>,
@@ -125,9 +127,9 @@ fn close(pet: WindowHandle<Pet>, why: &str, cx: &mut App) {
     }
 }
 
-/// How far in from the pane's left edge she stands on a pane `width` points wide: `LEFT`, or less on a narrow pane, so she holds its edge.
-fn left(width: Pixels) -> f32 {
-    LEFT.min(f32::from(width) - WIDTH).max(0.0)
+/// How far in from the pane's left edge she stands on a pane `width` points wide: `at`, or less on a narrow pane, so she holds its edge.
+fn left(width: Pixels, at: f32) -> f32 {
+    at.min(f32::from(width) - WIDTH).max(0.0)
 }
 
 /// The edge she stands on with `room` points free above the pane, up to the top of the work area of the main window's display.
@@ -150,19 +152,20 @@ fn wayland_edge(window: &Window) -> Edge {
 }
 
 /// Where she stands over a Wayland window: the edge, and her anchor counted from the pane's top left, as gpui's popups count.
-fn wayland_spot(window: &Window) -> (Edge, Point<Pixels>) {
+fn wayland_spot(window: &Window, at: f32) -> (Edge, Point<Pixels>) {
     let pane = pane(window);
     let edge = wayland_edge(window);
     let y = match edge {
         Edge::Top => px(0.),
         Edge::Bottom => pane.size.height - px(1.),
     };
-    (edge, point(px(left(pane.size.width)), y))
+    (edge, point(px(left(pane.size.width, at)), y))
 }
 
 /// Opens her again over a Wayland `main` once its size or state moves the anchor her popup opened at, which never moves.
 fn reanchor(main: WindowHandle<Workspace>, shown: &Shown, cx: &mut App) -> anyhow::Result<()> {
-    let spot = main.update(cx, |_, window, _| wayland_spot(window))?;
+    let at = SettingsStore::get(cx).ely_left;
+    let spot = main.update(cx, |_, window, _| wayland_spot(window, at))?;
     let Some(pet) = *shown.borrow() else {
         return Ok(());
     };
@@ -174,7 +177,7 @@ fn reanchor(main: WindowHandle<Workspace>, shown: &Shown, cx: &mut App) -> anyho
     }
     close(
         pet,
-        "to stand where the window's new size or state puts her",
+        "to stand where the window's size or state, or a drag, puts her",
         cx,
     );
     *shown.borrow_mut() = open_pet(main, cx);
@@ -183,15 +186,16 @@ fn reanchor(main: WindowHandle<Workspace>, shown: &Shown, cx: &mut App) -> anyho
 
 /// Opens her window on `main`'s pane: a popup Wayland's compositor places, else a window kept there.
 fn show(main: WindowHandle<Workspace>, cx: &mut App) -> anyhow::Result<WindowHandle<Pet>> {
+    let kept = SettingsStore::get(cx).ely_left;
     let (bounds, pane, wayland, (edge, spot)) = main.update(cx, |_, window, _| {
         (
             window.bounds(),
             pane(window),
             wayland(window),
-            wayland_spot(window),
+            wayland_spot(window, kept),
         )
     })?;
-    let at = left(pane.size.width);
+    let at = left(pane.size.width, kept);
     let room = size(px(WIDTH), px(HEAD + ROOM));
     let (edge, kind) = if wayland {
         let anchor = match edge {
@@ -254,6 +258,9 @@ fn show(main: WindowHandle<Workspace>, cx: &mut App) -> anyhow::Result<WindowHan
                 eased: None,
                 edge,
                 anchor: wayland.then_some(spot),
+                at: kept,
+                drag: None,
+                main,
                 glue: None,
                 _watch: vec![feel],
             }
@@ -282,7 +289,7 @@ fn glue(
     main.update(cx, |_, main, cx| {
         pet.update(cx, |pet, window, cx| {
             let glue = platform::Glue::new(window, main)?;
-            pet.edge = glue.place(main)?;
+            pet.edge = glue.place(main, pet.at)?;
             pet.glue = Some(glue);
             pet._watch
                 .push(cx.observe_window_bounds(main, |pet, main, _| pet.place(main)));
@@ -371,7 +378,7 @@ impl Pet {
         let Some(glue) = &self.glue else {
             return;
         };
-        match glue.place(main) {
+        match glue.place(main, self.at) {
             Ok(edge) if edge != self.edge => {
                 let name = format!("{edge:?}").to_lowercase();
                 log::info!("pet: Ely moves to the pane's {name} edge");
@@ -382,6 +389,58 @@ impl Pet {
         }
     }
 
+    /// Takes hold of her for a drag along her edge, the pointer `local` in her window.
+    fn grab(&mut self, local: Pixels, scale: f32) {
+        match self.pointer(local, scale) {
+            Ok(x) => self.drag = Some((x, self.at)),
+            Err(error) => log::error!("{error:#}"),
+        }
+    }
+
+    /// Moves her along her edge after the pointer, inside the pane.
+    fn slide(&mut self, local: Pixels, scale: f32, cx: &mut App) {
+        let Some((from, at)) = self.drag else {
+            return;
+        };
+        let x = match self.pointer(local, scale) {
+            Ok(x) => x,
+            Err(error) => {
+                self.drag = None;
+                return log::error!("{error:#}");
+            }
+        };
+        let main = self.main;
+        let slid = main.update(cx, |_, main, _| {
+            let room = (f32::from(pane(main).size.width) - WIDTH).max(0.0);
+            // Whole points, so the kept place carries no float noise.
+            self.at = (at + x - from).round().clamp(0.0, room.floor());
+            self.place(main);
+        });
+        if let Err(error) = slid {
+            log::debug!("pet: the main window does not read: {error:#}");
+        }
+    }
+
+    /// Lets go of her, the settings keeping where the drag left her, where a Wayland popup then opens again.
+    fn release(&mut self, cx: &mut App) {
+        if self.drag.take().is_none() || SettingsStore::get(cx).ely_left == self.at {
+            return;
+        }
+        let at = self.at;
+        match SettingsStore::update(cx, |settings| settings.ely_left = at) {
+            Ok(()) => log::info!("pet: Ely stands {at} points in from the pane's left edge"),
+            Err(error) => log::error!("pet: where Ely stands is not kept: {error:#}"),
+        }
+    }
+
+    /// The pointer's x in points: on the screen where her glue moves her window, else in her window, which a drag leaves in place.
+    fn pointer(&self, local: Pixels, scale: f32) -> anyhow::Result<f32> {
+        match &self.glue {
+            Some(glue) => glue.pointer(scale),
+            None => Ok(local.into()),
+        }
+    }
+
     #[cfg(target_os = "linux")]
     fn shown(&mut self, visible: bool, main: &Window) {
         if let Some(glue) = &self.glue {
@@ -402,17 +461,32 @@ impl Render for Pet {
         // gpui gives a hidden window no frames, so she rests while unseen.
         window.request_animation_frame();
         let rig = self.rig.clone();
+        let this = cx.entity();
         let drawn = canvas(
             |_, _, _| {},
             move |bounds, _, window, cx| {
                 let head = point(bounds.origin.x, bounds.origin.y + px(ROOM));
                 rig.paint(head, &pose, window, cx);
+                // Her window keeps the pointer while the button is held, inside it or not.
+                let held = this.clone();
+                window.on_mouse_event(move |event: &MouseMoveEvent, phase, window, cx| {
+                    if phase == DispatchPhase::Bubble && event.dragging() {
+                        let scale = window.scale_factor();
+                        held.update(cx, |pet, cx| pet.slide(event.position.x, scale, cx));
+                    }
+                });
+                window.on_mouse_event(move |event: &MouseUpEvent, phase, _, cx| {
+                    if phase == DispatchPhase::Bubble && event.button == MouseButton::Left {
+                        this.update(cx, |pet, cx| pet.release(cx));
+                    }
+                });
             },
         );
         div().size_full().child(drawn.size_full()).on_mouse_down(
             MouseButton::Left,
-            cx.listener(|pet, _, _, cx| {
+            cx.listener(|pet, event: &MouseDownEvent, window, cx| {
                 pet.press(Instant::now());
+                pet.grab(event.position.x, window.scale_factor());
                 cx.notify();
             }),
         )

src/pet/macos.rs

@@ -3,7 +3,7 @@
 use anyhow::bail;
 use gpui::Window;
 use objc::{
-    msg_send,
+    class, msg_send,
     runtime::{NO, Object, YES},
     sel, sel_impl,
 };
@@ -64,8 +64,8 @@ impl Glue {
         Ok(Self { pet, main })
     }
 
-    /// Stands her on the main window's top edge while her box fits under the top of its screen's visible frame, else on its bottom edge, as far in as its width allows, and gives the edge.
-    pub fn place(&self, _: &Window) -> anyhow::Result<Edge> {
+    /// Stands her on the main window's top edge while her box fits under the top of its screen's visible frame, else on its bottom edge, `at` in as far as its width allows, and gives the edge.
+    pub fn place(&self, _: &Window, at: f32) -> anyhow::Result<Edge> {
         unsafe {
             let frame: Rect = msg_send![self.main, frame];
             let screen: *mut Object = msg_send![self.main, screen];
@@ -74,7 +74,7 @@ impl Glue {
             let top = frame.origin.y + frame.height;
             let edge = edge((visible.origin.y + visible.height - top) as f32);
             let at = Point {
-                x: frame.origin.x + f64::from(left(gpui::px(frame.width as f32))),
+                x: frame.origin.x + f64::from(left(gpui::px(frame.width as f32), at)),
                 y: match edge {
                     Edge::Top => top,
                     Edge::Bottom => frame.origin.y,
@@ -84,6 +84,12 @@ impl Glue {
             Ok(edge)
         }
     }
+
+    /// The pointer's x on the screen, in points.
+    pub fn pointer(&self, _: f32) -> anyhow::Result<f32> {
+        let at: Point = unsafe { msg_send![class!(NSEvent), mouseLocation] };
+        Ok(at.x as f32)
+    }
 }
 
 /// The NSWindow gpui made for `window`.

src/pet/tests.rs

@@ -1,5 +1,7 @@
 use std::time::Duration;
 
+use gpui::WindowId;
+
 use super::{look::Mark, *};
 
 /// Her, `mood` since `since`, come long before.
@@ -15,6 +17,9 @@ fn ely(mood: Mood, since: Instant) -> Pet {
         eased: None,
         edge: Edge::Top,
         anchor: None,
+        at: 140.0,
+        drag: None,
+        main: WindowHandle::new(WindowId::from(1)),
         glue: None,
         _watch: Vec::new(),
     }
@@ -98,11 +103,14 @@ fn she_stands_on_the_top_edge_while_her_box_fits_above_it() {
 }
 
 #[test]
-fn she_holds_the_edge_of_any_pane() {
-    assert_eq!(left(px(1200.)), LEFT);
-    assert_eq!(left(px(200.)), 200.0 - WIDTH);
+fn she_holds_the_edge_of_any_pane_where_a_drag_left_her() {
+    assert_eq!(left(px(1200.), 140.0), 140.0);
+    assert_eq!(left(px(1200.), 900.0), 900.0, "dragged right");
+    assert_eq!(left(px(1200.), 0.0), 0.0, "dragged to its left end");
+    assert_eq!(left(px(600.), 900.0), 600.0 - WIDTH, "a narrower pane");
+    assert_eq!(left(px(200.), 140.0), 200.0 - WIDTH);
     assert_eq!(
-        left(px(100.)),
+        left(px(100.), 140.0),
         0.0,
         "narrower than she is, she stands at its left"
     );

src/pet/windows.rs

@@ -9,14 +9,14 @@ use anyhow::bail;
 use gpui::{Bounds, Pixels, Window};
 use raw_window_handle::{HasWindowHandle, RawWindowHandle};
 use windows_sys::Win32::{
-    Foundation::{HWND, LPARAM, LRESULT, RECT, WPARAM},
+    Foundation::{HWND, LPARAM, LRESULT, POINT, RECT, WPARAM},
     Graphics::Gdi::{
         GetMonitorInfoW, MONITOR_DEFAULTTONEAREST, MONITORINFO, MonitorFromRect, MonitorFromWindow,
     },
     UI::{
         HiDpi::{GetDpiForMonitor, GetDpiForWindow, MDT_EFFECTIVE_DPI},
         WindowsAndMessaging::{
-            CallWindowProcW, GWL_STYLE, GWLP_HWNDPARENT, GWLP_WNDPROC, GetWindowInfo,
+            CallWindowProcW, GWL_STYLE, GWLP_HWNDPARENT, GWLP_WNDPROC, GetCursorPos, GetWindowInfo,
             GetWindowLongPtrW, HWND_NOTOPMOST, MA_NOACTIVATE, PostMessageW, SWP_FRAMECHANGED,
             SWP_NOACTIVATE, SWP_NOMOVE, SWP_NOSIZE, SWP_NOZORDER, SetWindowLongPtrW, SetWindowPos,
             USER_DEFAULT_SCREEN_DPI, WINDOWINFO, WM_APP, WM_DPICHANGED, WM_MOUSEACTIVATE, WNDPROC,
@@ -77,13 +77,21 @@ impl Glue {
         Ok(Self { pet, main })
     }
 
-    /// Stands her on the main window's top edge while her box fits under the top of its display's work area, else on its bottom edge, as far in as its width allows, and gives the edge.
-    pub fn place(&self, main: &Window) -> anyhow::Result<Edge> {
-        self.put(main.scale_factor(), pane(main))
+    /// Stands her on the main window's top edge while her box fits under the top of its display's work area, else on its bottom edge, `at` in as far as its width allows, and gives the edge.
+    pub fn place(&self, main: &Window, at: f32) -> anyhow::Result<Edge> {
+        self.put(main.scale_factor(), pane(main), at)
     }
 
-    /// Posts her bottom left corner on an edge of `pane` at `scale`, in the main window's points; her window sizes her at the DPI it has when the place lands, as gpui did not when it opened her off the display.
-    fn put(&self, scale: f32, pane: Bounds<Pixels>) -> anyhow::Result<Edge> {
+    /// The pointer's x on the screen, in points at `scale`.
+    pub fn pointer(&self, scale: f32) -> anyhow::Result<f32> {
+        let mut at = POINT::default();
+        let read = unsafe { GetCursorPos(&mut at) };
+        anyhow::ensure!(read != 0, "pet: the pointer's place does not read");
+        Ok(at.x as f32 / scale)
+    }
+
+    /// Posts her bottom left corner on an edge of `pane` at `scale`, `at` points in, in the main window's points; her window sizes her at the DPI it has when the place lands, as gpui did not when it opened her off the display.
+    fn put(&self, scale: f32, pane: Bounds<Pixels>, at: f32) -> anyhow::Result<Edge> {
         let mut main = WINDOWINFO {
             cbSize: size_of::<WINDOWINFO>() as u32,
             ..Default::default()
@@ -97,9 +105,9 @@ impl Glue {
         let monitor = unsafe { MonitorFromWindow(self.main, MONITOR_DEFAULTTONEAREST) };
         let read = unsafe { GetMonitorInfoW(monitor, &mut display) };
         anyhow::ensure!(read != 0, "pet: the main window's display does not read");
-        let (_, top) = stand(main.rcClient, scale, pane, Edge::Top);
+        let (_, top) = stand(main.rcClient, scale, pane, Edge::Top, at);
         let edge = edge((top - display.rcWork.top) as f32 / scale);
-        let corner = stand(main.rcClient, scale, pane, edge);
+        let corner = stand(main.rcClient, scale, pane, edge, at);
         let posted = unsafe { PostMessageW(self.pet, PLACE, pack(corner), 0) };
         anyhow::ensure!(posted != 0, "pet: her place does not post");
         log::debug!("pet: Ely is to stand on {corner:?}, the pane's {edge:?} edge");
@@ -107,13 +115,13 @@ impl Glue {
     }
 }
 
-/// Her bottom left corner on `edge` of `pane` at `scale` over the main window's `client` rect, in pixels.
-fn stand(client: RECT, scale: f32, pane: Bounds<Pixels>, edge: Edge) -> (i32, i32) {
+/// Her bottom left corner on `edge` of `pane`, `at` points in, at `scale` over the main window's `client` rect, in pixels.
+fn stand(client: RECT, scale: f32, pane: Bounds<Pixels>, edge: Edge, at: f32) -> (i32, i32) {
     let y = match edge {
         Edge::Top => pane.origin.y,
         Edge::Bottom => pane.bottom(),
     };
-    let x = f32::from(pane.origin.x) + left(pane.size.width);
+    let x = f32::from(pane.origin.x) + left(pane.size.width, at);
     (
         client.left + (x * scale).round() as i32,
         client.top + (f32::from(y) * scale).round() as i32,

src/pet/windows/tests.rs

@@ -102,14 +102,14 @@ fn her_bottom_stands_on_either_edge_of_the_pane_whatever_the_two_windows_dpi() {
     let pane = Bounds::new(point(px(10.), px(8.)), size(px(800.), px(600.)));
     for (scale, dpi) in [(1.0, 96), (1.0, 144), (1.5, 96), (2.0, 120)] {
         for (edge, y) in [(Edge::Top, 8.0), (Edge::Bottom, 608.0)] {
-            let her = boxed(stand(client, scale, pane, edge), dpi);
+            let her = boxed(stand(client, scale, pane, edge, 140.0), dpi);
             let own = dpi as f32 / 96.0;
             let own_box = (
                 (WIDTH * own).round() as i32,
                 ((HEAD + ROOM) * own).round() as i32,
             );
             let corner = (
-                100 + ((10.0 + left(px(800.))) * scale).round() as i32,
+                100 + ((10.0 + left(px(800.), 140.0)) * scale).round() as i32,
                 20 + (y * scale).round() as i32,
             );
             assert_eq!(
@@ -272,7 +272,7 @@ fn the_large_framed_popup_gpui_makes_stands_bare_in_her_box_on_an_edge_of_the_pa
     let work = work_area(main);
     move_main(main, (work.left + 200, work.top + 400));
     let pane = Bounds::new(point(px(0.), px(0.)), size(px(380.), px(280.)));
-    let roomy = glue.put(1.0, pane).expect("placed");
+    let roomy = glue.put(1.0, pane, 140.0).expect("placed");
     let made = info(pet).rcWindow;
     deliver(pet);
     let (her, under) = (info(pet), info(main));
@@ -297,7 +297,7 @@ fn the_large_framed_popup_gpui_makes_stands_bare_in_her_box_on_an_edge_of_the_pa
     let (suggested, taken, stood) = change(display + 48);
     // At the work area's top the main window leaves her no room above it.
     move_main(main, (work.left + 200, work.top));
-    let cramped = glue.put(1.0, pane).expect("placed again");
+    let cramped = glue.put(1.0, pane, 140.0).expect("placed again");
     deliver(pet);
     let (inside, low) = (info(pet).rcWindow, info(main).rcClient);
     unsafe {
@@ -317,7 +317,7 @@ fn the_large_framed_popup_gpui_makes_stands_bare_in_her_box_on_an_edge_of_the_pa
         ((HEAD + ROOM) * own).round() as i32,
     );
     let edge = (
-        under.rcClient.left + left(px(380.)).round() as i32,
+        under.rcClient.left + left(px(380.), 140.0).round() as i32,
         under.rcClient.top,
     );
     let rect = |rect: RECT| (rect.left, rect.top, rect.right, rect.bottom);

src/pet/x11.rs

@@ -49,20 +49,29 @@ impl Glue {
         Ok(glue)
     }
 
-    /// Stands her on the main window's pane, on its top edge while her box fits under the top of the monitor holding most of the pane, or of the work area where that lies lower, else on its bottom edge, as far in as its width allows, stacked just above the main window's frame, and gives the edge.
-    pub fn place(&self, main: &Window) -> anyhow::Result<Edge> {
-        self.put(main.scale_factor(), pane(main))
+    /// Stands her on the main window's pane, on its top edge while her box fits under the top of the monitor holding most of the pane, or of the work area where that lies lower, else on its bottom edge, `at` in as far as its width allows, stacked just above the main window's frame, and gives the edge.
+    pub fn place(&self, main: &Window, at: f32) -> anyhow::Result<Edge> {
+        self.put(main.scale_factor(), pane(main), at)
+    }
+
+    /// The pointer's x on the screen, in points at `scale`.
+    pub fn pointer(&self, scale: f32) -> anyhow::Result<f32> {
+        let reply = (self.connection)
+            .query_pointer(self.pet)?
+            .reply()
+            .context("pet: the pointer's place")?;
+        Ok(f32::from(reply.root_x) / scale)
     }
 
     /// Places her at `scale` on an edge of `pane`, in the main window's points.
-    fn put(&self, scale: f32, pane: Bounds<Pixels>) -> anyhow::Result<Edge> {
+    fn put(&self, scale: f32, pane: Bounds<Pixels>, at: f32) -> anyhow::Result<Edge> {
         let (root, frame) = self.frame()?;
-        let at = (self.connection)
+        let origin = (self.connection)
             .translate_coordinates(self.main, root, 0, 0)?
             .reply()
             .context("pet: the main window's place")?;
-        let down = |y: Pixels| i32::from(at.dst_y) + (f32::from(y) * scale).round() as i32;
-        let across = |x: Pixels| i32::from(at.dst_x) + (f32::from(x) * scale).round() as i32;
+        let down = |y: Pixels| i32::from(origin.dst_y) + (f32::from(y) * scale).round() as i32;
+        let across = |x: Pixels| i32::from(origin.dst_x) + (f32::from(x) * scale).round() as i32;
         let (west, top) = (across(pane.origin.x), down(pane.origin.y));
         let rect = [
             west,
@@ -77,7 +86,7 @@ impl Glue {
             Edge::Bottom => pane.bottom(),
         });
         let aux = ConfigureWindowAux::new()
-            .x(across(pane.origin.x + px(left(pane.size.width))))
+            .x(across(pane.origin.x + px(left(pane.size.width, at))))
             .y(bottom - ((HEAD + ROOM) * scale).round() as i32)
             .sibling(frame)
             .stack_mode(StackMode::ABOVE);
@@ -269,7 +278,7 @@ mod tests {
             workarea,
         };
         let pane = Bounds::new(point(px(10.), px(10.)), size(px(380.), px(280.)));
-        let roomy = glue.put(2.0, pane).expect("she is placed");
+        let roomy = glue.put(2.0, pane, 140.0).expect("she is placed");
         let check = x11rb::connect(Some(&xvfb.display))
             .expect("the check connects")
             .0;
@@ -280,7 +289,7 @@ mod tests {
             .expect("her place");
         let tall = ((HEAD + ROOM) * 2.0).round() as i32;
         let stands = (
-            100 + ((10.0 + left(px(380.))) * 2.0).round() as i32,
+            100 + ((10.0 + left(px(380.), 140.0)) * 2.0).round() as i32,
             440 - tall,
         );
         assert_eq!(
@@ -322,7 +331,7 @@ mod tests {
             .expect("the request")
             .check()
             .expect("a work area");
-        let cramped = glue.put(2.0, pane).expect("she is placed again");
+        let cramped = glue.put(2.0, pane, 140.0).expect("she is placed again");
         let low = check
             .get_geometry(pet)
             .expect("the request")

src/settings/mod.rs

@@ -74,6 +74,8 @@ pub struct Settings {
     pub copy_on_select: bool,
     /// Ely peeks over the main window's top edge.
     pub ely: bool,
+    /// How far in from the pane's left edge she stands, in points, as a drag left her.
+    pub ely_left: f32,
     pub show_sessions: bool,
     pub show_panel: bool,
     pub panel: PanelTab,
@@ -106,6 +108,7 @@ impl Default for Settings {
             option_as_alt: OptionAsAlt::Off,
             copy_on_select: false,
             ely: true,
+            ely_left: 140.0,
             show_sessions: true,
             show_panel: true,
             panel: PanelTab::Git,
@@ -124,6 +127,7 @@ pub const PADDING: RangeInclusive<f32> = 0.0..=64.0;
 pub const SCROLLBACK: RangeInclusive<u32> = 0..=100_000;
 pub const COLUMN: RangeInclusive<f32> = 160.0..=960.0;
 pub const WINDOW: RangeInclusive<f32> = 100.0..=16384.0;
+pub const ELY_LEFT: RangeInclusive<f32> = 0.0..=16384.0;
 
 impl Settings {
     /// Every value inside its range, every theme built in; the error names the field.
@@ -138,6 +142,7 @@ impl Settings {
         within("panel_width", self.panel_width, &COLUMN)?;
         within("window_width", self.window_width, &WINDOW)?;
         within("window_height", self.window_height, &WINDOW)?;
+        within("ely_left", self.ely_left, &ELY_LEFT)?;
         for (field, id) in [
             ("theme", Some(&self.theme)),
             ("dark_theme", self.dark_theme.as_ref()),

tasks/acceptance.md

@@ -84,7 +84,7 @@ What no check reached: no real KWin drew the blur; of Wayland desktops, only Hyp
 | The pointer over the terminal is the arrow | T26 | the terminal sets no pointer, so gpui's arrow shows; on X11 with the pointer over the grid, gpui asked for no I-beam ("text"), which it had asked for, and failed to load under Xvfb, before | Pass |
 | The title bar is transparent | T11, T19 | T19 review | Pass |
 | Every title bar control takes its press, Ely's window buttons on Windows and Linux too | T26 | Ely `cdc5ce8`: `window_controls_occlude_what_lies_under` (each style; before, the box under Windows' caption buttons took the press), `a_wobbling_press_on_a_slot_moves_no_window` (before, the window moved), `a_wobbling_press_on_a_column_title_moves_the_window`; on the owner's PC, window messages asked the app for Windows' hit test along the title bar: v0.1.0 answered caption from end to end, T26's build answers client over the toggles and +, caption over the titles, min, max and close over Ely's buttons, and a press on close closed the app; the owner, given v0.1.1's build and these controls to click, reported it works on Windows | Pass |
-| Ely peeks over the window's top edge from behind it, or stands inside at its bottom left where no room lies above it; her face follows the sessions; a press pets her and wakes her from a doze; nothing but her shows | T46, T48, T49, T51, T52, T53 | `pet::look` tests: the most pressing mark sets her mood; she moves in every mood, weeks into one too; she blinks on her own, twice at times, her eyes opening as an act begins; calm glances, then dozes with zs; a finish cheers her with a hop; work runs her eyes along the lines and taps her fingers; a wait widens her eyes and hops her twice a round; an error shakes her and runs a drop down; a press winks with a rising heart; she rises from behind the edge; a change of act eases her from her last pose, her brows easing and the marks she leaves fading; `pet` tests: a mood that changes inside a wink, an old finish cleared mid-glance and a second press mid-hop each ease her from where she was, where round 1 of T49's review found her drop 12 points; `pet::rig` tests: every layer of the icon's paths parses and stays in its box, and every mark has its layer; on macOS `shot`'s snaps, 40 in 10 s while calm, caught her breathing, blinking and glancing, and two a second apart in each mood caught her reading along, rocking her mark, fretting with her drop, cheering, and easing back to calm; `pet::x11` test under Xvfb: her window stands on the pane, just above the window manager's frame, and unmaps and maps with the main window; on macOS `shot` found her the main window's child, 112 by 124 points on its top edge 140 in, a capture of the screen showed her over the edge, and OSC 7501 reports gave her surprise, worry, eyes down and a cheer; a press on her window left the main window key and every key typed before and after it reached the program; switched off and on during an error she came back worried; on a 100-point window she stood at its left edge, and moved, resized and minimized she followed it; on Windows the `pet::windows` test, red before T48, finds the framed popup Windows makes, 1898 by 1481, bare in her own box, 168 by 185 at 150%, on the pane's top edge, and no size until her window takes the place posted to it; `pet::windows` tests, red before T48's second round: with the main window at 1, 1.5 or 2 and hers at 1, 1.25 or 1.5, her height is her own and her bottom the pane's top, where it fell 62 pixels into the terminal, and at a new DPI gpui takes the rect Windows suggests, then her box comes back on her corner, or Windows' rect stands where that box would lie on a display of another DPI; two displays side by side at 144 and 96 DPI, simulated, settle her after one change, where a corner kept always, red before T48's third round, changed her DPI back and forth; and two places piled up before either ran drain on the last corner in her DPI's size, where a keep whose DPI had passed, red before T48's fourth change, set it back and forth, and where a place sized when it was posted left her 112 by 123 at 144 DPI, red before its fifth; on a Windows 11 VM at 150%, with the main window 49 pixels from the screen's top, 0.1.4 opened her 2326 by 1654 with a caption, drawn at its bottom over the terminal, and a press inside the terminal went to her; T48's build opened her 168 by 185 without one, on the edge, the press went to the terminal, one beside her box to the program behind, and one on her to her; with the window mid-screen she showed whole on its edge; T51: `pet` tests: she stands on the top edge while her box fits above the pane, 123.4 points, else the bottom; on macOS 0.1.4 opened her, over a window under the menu bar, at 1081 to 1205, inside its top, as the owner saw, and T51 at its bottom edge, 92, 140 in, and over a centered window still on its top edge, 1028; the `pet::windows` tests on the owner's PC put her on the top edge 400 pixels down the work area and on the bottom edge at its top, and there the release build stood her on the top edge of a centered window, on the bottom edge of one moved to the work area's top and of a maximized one, 210 pixels in at 150%, and on the top edge again once it came back; the `pet::x11` test under Xvfb puts her on the bottom edge once `_NET_WORKAREA` leaves no room; on WSLg's X11 she stood over a window with room and inside one as tall as the screen; on WSLg's Wayland, Weston, her popup stood on the pane's top edge and, once the window was maximized, opened again on its bottom edge, at its bottom left; under Xorg with two monitors she moved to the bottom edge of a window at the lower one's top, 112x123+240+1277, and of one held mostly by a staggered monitor at its top, 112x123+1240+877; under headless Sway her anchor went (140, 0) on the top edge, then (140, 999), (140, 799) and (140, 999) on the bottom edge as the window went full screen and the output 800 and 1000 high, and full screen at the same size moved her too; T52: the `pet::look` test wakes her from a doze 400 s into calm with a press, which winks her, then she stays awLine truncated
+| Ely peeks over the window's top edge from behind it, or stands inside at its bottom left where no room lies above it; her face follows the sessions; a press pets her and wakes her from a doze; nothing but her shows; a drag moves her along her edge | T46, T48, T49, T51, T52, T53, T55 | `pet::look` tests: the most pressing mark sets her mood; she moves in every mood, weeks into one too; she blinks on her own, twice at times, her eyes opening as an act begins; calm glances, then dozes with zs; a finish cheers her with a hop; work runs her eyes along the lines and taps her fingers; a wait widens her eyes and hops her twice a round; an error shakes her and runs a drop down; a press winks with a rising heart; she rises from behind the edge; a change of act eases her from her last pose, her brows easing and the marks she leaves fading; `pet` tests: a mood that changes inside a wink, an old finish cleared mid-glance and a second press mid-hop each ease her from where she was, where round 1 of T49's review found her drop 12 points; `pet::rig` tests: every layer of the icon's paths parses and stays in its box, and every mark has its layer; on macOS `shot`'s snaps, 40 in 10 s while calm, caught her breathing, blinking and glancing, and two a second apart in each mood caught her reading along, rocking her mark, fretting with her drop, cheering, and easing back to calm; `pet::x11` test under Xvfb: her window stands on the pane, just above the window manager's frame, and unmaps and maps with the main window; on macOS `shot` found her the main window's child, 112 by 124 points on its top edge 140 in, a capture of the screen showed her over the edge, and OSC 7501 reports gave her surprise, worry, eyes down and a cheer; a press on her window left the main window key and every key typed before and after it reached the program; switched off and on during an error she came back worried; on a 100-point window she stood at its left edge, and moved, resized and minimized she followed it; on Windows the `pet::windows` test, red before T48, finds the framed popup Windows makes, 1898 by 1481, bare in her own box, 168 by 185 at 150%, on the pane's top edge, and no size until her window takes the place posted to it; `pet::windows` tests, red before T48's second round: with the main window at 1, 1.5 or 2 and hers at 1, 1.25 or 1.5, her height is her own and her bottom the pane's top, where it fell 62 pixels into the terminal, and at a new DPI gpui takes the rect Windows suggests, then her box comes back on her corner, or Windows' rect stands where that box would lie on a display of another DPI; two displays side by side at 144 and 96 DPI, simulated, settle her after one change, where a corner kept always, red before T48's third round, changed her DPI back and forth; and two places piled up before either ran drain on the last corner in her DPI's size, where a keep whose DPI had passed, red before T48's fourth change, set it back and forth, and where a place sized when it was posted left her 112 by 123 at 144 DPI, red before its fifth; on a Windows 11 VM at 150%, with the main window 49 pixels from the screen's top, 0.1.4 opened her 2326 by 1654 with a caption, drawn at its bottom over the terminal, and a press inside the terminal went to her; T48's build opened her 168 by 185 without one, on the edge, the press went to the terminal, one beside her box to the program behind, and one on her to her; with the window mid-screen she showed whole on its edge; T51: `pet` tests: she stands on the top edge while her box fits above the pane, 123.4 points, else the bottom; on macOS 0.1.4 opened her, over a window under the menu bar, at 1081 to 1205, inside its top, as the owner saw, and T51 at its bottom edge, 92, 140 in, and over a centered window still on its top edge, 1028; the `pet::windows` tests on the owner's PC put her on the top edge 400 pixels down the work area and on the bottom edge at its top, and there the release build stood her on the top edge of a centered window, on the bottom edge of one moved to the work area's top and of a maximized one, 210 pixels in at 150%, and on the top edge again once it came back; the `pet::x11` test under Xvfb puts her on the bottom edge once `_NET_WORKAREA` leaves no room; on WSLg's X11 she stood over a window with room and inside one as tall as the screen; on WSLg's Wayland, Weston, her popup stood on the pane's top edge and, once the window was maximized, opened again on its bottom edge, at its bottom left; under Xorg with two monitors she moved to the bottom edge of a window at the lower one's top, 112x123+240+1277, and of one held mostly by a staggered monitor at its top, 112x123+1240+877; under headless Sway her anchor went (140, 0) on the top edge, then (140, 999), (140, 799) and (140, 999) on the bottom edge as the window went full screen and the output 800 and 1000 high, and full screen at the same size moved her too; T52: the `pet::look` test wakes her from a doze 400 s into calm with a preLine truncated
 
 ## 7. Sessions panel
 

tasks/reviews.md

@@ -272,3 +272,7 @@ Each task gets at most three codex rounds. Each round: the commit, the verdict,
 ## T54
 
 - Round 1, 0119776 and 15153b4 with v0.1.5 published: PASS. The reviewer found the bump only elyterminal's version; downloaded the three files anonymously, each matching the notes' SHA-256 and target/t54/anon byte for byte, and the tag's source archive the commit's 141 files; checked the disk image's ticket, strict signatures and Gatekeeper, the hardened arm64 app at 0.1.5 and macOS 11.0, the zip's GUI executable with its seven icon images, icon group 1, PerMonitorV2 manifest and no C runtime DLL, and the tarball's modes and glibc 2.35; found T51's and the failed glue's markers in all three binaries, T53's in the app and the monitors' in the tarball; and read CI run 1311 succeed on macOS, Ubuntu and Windows at 0119776 a minute before the release was published, and Release run 1312 on the signing runner. check.sh passed with 240 tests. Windows and Linux windows went unexercised.
+
+## T55
+
+- No review: the owner asked for 0.1.6 without one. Checked by scripts/check.sh (240 tests), Linux tests (247) and clippy, Windows gnu clippy, an xdotool drag under Xorg, a drag under Sway nested in Xorg, and the owner's own drags on macOS.