Preserve scroll position across window resize (M-x, etc.)

Scrolling up to read terminal history and then pressing M-x (or any
command that resizes the ghostel window) previously yanked the view
back to the prompt.  Three root causes conspired:

1. The post-redraw anchor check keyed off `point', which is always at
   `point-max' after the native redraw — so it always snapped the
   window down unless `saved-marker' happened to restore point first.
2. Byte-position markers don't survive the native redraw's
   `eraseBuffer' + re-insert on full redraw / resize.
3. Emacs' own redisplay can clamp `window-start' to `point-min'
   between our delayed-redraws (typically after a minibuffer
   open/close cycle).

Fix: classify windows as auto-follow vs. user-scrolled by comparing
`window-start' to a recorded `ghostel--last-anchor-position'.  Track
scrolled positions by multi-line content keys (`ghostel--line-key',
3 consecutive lines) so they survive arbitrary buffer reshuffles —
scrollback eviction, viewport rewrite, full redraw erase — and aren't
fooled by blank lines or repeated prompts.

A pre-redraw pass restores any window whose `window-start' or
`window-point' has been clamped to `point-min' while the saved key
pointed elsewhere (`ghostel--position-mangled-p').  Other position
changes are left alone — the post-redraw capture rebuilds
`ghostel--scroll-positions' from each window's live state.

Reset scroll state in `ghostel-clear-scrollback' and
`ghostel-copy-mode-exit' so stale entries don't point into rewritten
content.  copy-mode-exit also sets `ghostel--force-next-redraw' so
the snap fires under DEC 2026 synchronized output.

Trade-off: opted for this heuristic over a `post-command-hook' that
would fire every keystroke.  Known limitation (documented + tested):
if Emacs moves ws to a non-`point-min' non-saved position
(programmatic `recenter', `follow-mode'), the pass treats it as a
user scroll.

Also fixes Claude Code TUI flicker: typing into a TUI that re-renders
per keystroke caused a 1-row jump-down/jump-back-up oscillation.  Two
contributors:

1. `ghostel--snap-to-input' did `(goto-char (point-max))' on every
   self-insert / send-event / paste.  Emacs' redisplay then pulled
   `window-point' along, saw it at `window-end', and
   `scroll-conservatively-101' bumped `window-start' forward by a row.
   The next ghostel redraw reset it — flicker.  With
   `ghostel--snap-requested' driving anchoring regardless of point,
   the goto is redundant; remove it.
2. `ghostel--viewport-start' computed viewport from `point-max' via
   `forward-line -(tr-1)'.  When the buffer ends with a trailing
   newline (left by partial-redraw trim), the walk lands one line too
   deep and clips row 1.  Step past a trailing `\n' first.

Refactored `ghostel--delayed-redraw' (was 149 lines) into an
orchestrator plus focused helpers: `ghostel--viewport-start',
`--window-anchored-p', `--capture-window-state',
`--position-mangled-p', `--reconcile-saved-position',
`--correct-mangled-scroll-positions', `--anchor-window',
`--restore-scrollback-window'.

`ghostel-debug.el' now snapshots viewport / anchor / per-window
ws/we/wp state around each redraw so oscillation patterns are visible
from the log.

New tests cover: scroll preservation across the real resize path
(`ghostel--window-adjust-process-window-size'), live output while
scrolled, blank-line disambiguation, multi-window mixed states,
clear / copy-mode state reset (incl. `force-next-redraw'), OSC 51;E
window-point sync, first-redraw bootstrap, user rescroll between
redraws, ws-mangled restore, wp mangled independently, the known
false-negative case, and viewport-start off-by-one.

Benchmarks (200 iterations, ~500-line scrollback):
- auto-follow: 0.07 ms/redraw (matches baseline)
- scrolled-up: 0.16 ms/redraw (was 0.08 ms; well under frame budget)

Fixes #115

Author: dakra

ghostel-debug.el

@@ -119,43 +119,72 @@ _PROC is ignored."
                       (format-time-string "%T.%3N")
                       key-name mods utf8)))))
 
+(defun ghostel-debug--snapshot (buffer)
+  "Return a plist of redraw-relevant state for BUFFER, or nil.
+Captures DEC 2026, force flag, buffer size, trailing-byte flag,
+point, `ghostel--term-rows', `ghostel--last-anchor-position',
+computed viewport-start, and per-window ws/we/wp/body-height."
+  (when (buffer-live-p buffer)
+    (with-current-buffer buffer
+      (let* ((pm (point-max))
+             (cb (and (> pm 1) (char-before pm)))
+             (wins (get-buffer-window-list buffer nil t)))
+        (list :sync (and ghostel--term
+                         (ghostel--mode-enabled ghostel--term 2026))
+              :force ghostel--force-next-redraw
+              :snap ghostel--snap-requested
+              :buf-size (buffer-size)
+              :trailing-nl (eq cb ?\n)
+              :point (point)
+              :term-rows ghostel--term-rows
+              :anchor-pos ghostel--last-anchor-position
+              :vs (ghostel--viewport-start)
+              :wins (mapcar (lambda (w)
+                              (list :w w
+                                    :ws (window-start w)
+                                    :we (window-end w t)
+                                    :wp (window-point w)
+                                    :body (window-body-height w)))
+                            wins))))))
+
+(defun ghostel-debug--fmt-wins (wins)
+  "Format per-window entries WINS for the redraw log line."
+  (mapconcat
+   (lambda (w) (format "ws=%d we=%d wp=%d body=%d"
+                       (plist-get w :ws) (plist-get w :we)
+                       (plist-get w :wp) (plist-get w :body)))
+   wins " | "))
+
 (defun ghostel-debug--log-redraw (orig-fn buffer)
   "Log redraw decisions: skip vs execute, DEC 2026 state, timing.
 ORIG-FN is `ghostel--delayed-redraw', BUFFER is the target buffer."
   (when ghostel-debug--log-buffer
-    (let (sync force win-start pt buf-size)
-      (when (buffer-live-p buffer)
-        (with-current-buffer buffer
-          (setq sync (and ghostel--term
-                          (ghostel--mode-enabled ghostel--term 2026)))
-          (setq force ghostel--force-next-redraw)
-          (setq buf-size (buffer-size))
-          (setq pt (point))
-          (let ((win (get-buffer-window buffer)))
-            (when win
-              (setq win-start (window-start win))))))
-      (let ((t0 (current-time)))
-        (funcall orig-fn buffer)
-        (let ((elapsed (* 1000 (float-time (time-subtract (current-time) t0))))
-              pt-after win-start-after buf-size-after)
-          (when (buffer-live-p buffer)
-            (with-current-buffer buffer
-              (setq pt-after (point))
-              (setq buf-size-after (buffer-size))
-              (let ((win (get-buffer-window buffer)))
-                (when win
-                  (setq win-start-after (window-start win))))))
-          (with-current-buffer ghostel-debug--log-buffer
-            (goto-char (point-max))
-            (if (and sync (not force))
-                (insert (format "[%s] REDRAW: SKIPPED (DEC2026 active, force=nil)\n"
-                                (format-time-string "%T.%3N")))
-              (insert (format "[%s] REDRAW: %.1fms force=%s dec2026=%s buf=%d→%d pt=%d→%d wstart=%s→%s\n"
-                              (format-time-string "%T.%3N")
-                              elapsed force sync
-                              buf-size buf-size-after
-                              pt pt-after
-                              win-start win-start-after)))))))))
+    (let ((before (ghostel-debug--snapshot buffer))
+          (t0 (current-time)))
+      (funcall orig-fn buffer)
+      (let* ((elapsed (* 1000 (float-time (time-subtract (current-time) t0))))
+             (after (ghostel-debug--snapshot buffer)))
+        (with-current-buffer ghostel-debug--log-buffer
+          (goto-char (point-max))
+          (if (and (plist-get before :sync) (not (plist-get before :force)))
+              (insert (format "[%s] REDRAW: SKIPPED (DEC2026 active, force=nil)\n"
+                              (format-time-string "%T.%3N")))
+            (insert (format "[%s] REDRAW: %.1fms force=%s→%s snap=%s→%s dec2026=%s buf=%d→%d trailNL=%s→%s pt=%d→%d rows=%s vs=%s→%s anchor=%s→%s\n"
+                            (format-time-string "%T.%3N")
+                            elapsed
+                            (plist-get before :force) (plist-get after :force)
+                            (plist-get before :snap) (plist-get after :snap)
+                            (plist-get before :sync)
+                            (plist-get before :buf-size) (plist-get after :buf-size)
+                            (plist-get before :trailing-nl) (plist-get after :trailing-nl)
+                            (plist-get before :point) (plist-get after :point)
+                            (plist-get after :term-rows)
+                            (plist-get before :vs) (plist-get after :vs)
+                            (plist-get before :anchor-pos) (plist-get after :anchor-pos)))
+            (insert (format "           wins-before: %s\n"
+                            (ghostel-debug--fmt-wins (plist-get before :wins))))
+            (insert (format "           wins-after:  %s\n"
+                            (ghostel-debug--fmt-wins (plist-get after :wins))))))))))
 
 (defun ghostel-debug--log-resize (orig-fn process windows)
   "Log resize events with old/new dimensions and timing.