fix(ai-term): stop F9 toggle shrinking the agent window each cycle

The F9 toggle captured the agent window's body-height and replayed it as
body-lines. Body-height subtracts the mode line's pixel height, which differs
between an active and an inactive mode line; the agent is captured active but
redisplayed inactive, so under a theme whose mode-line-inactive is shorter than
a text line the window lost ~1 line per toggle.

Capture and replay total-height for the vertical axis instead, via the renamed
cj/window-replay-size. Total-height is identical active or inactive and has no
mode-line-pixel dependence, so the round-trip is a fixed point. Width keeps
body-width (total-width has the position-dependent divider problem that total-
height does not). The shared lib fix covers the F12 terminal toggle too.

The shrink only manifests in a GUI frame, so it is not reproducible in the
batch harness; the unit tests pin the new total-height contract.

1 files changed, 16 insertions, 14 deletions

diff --git a/modules/cj-window-toggle-lib.el b/modules/cj-window-toggle-lib.el
index ba91f5a40..175a1d958 100644
--- a/modules/cj-window-toggle-lib.el
+++ b/modules/cj-window-toggle-lib.el
@@ -44,7 +44,7 @@ No-op when WINDOW is nil or not live."
       (if (or (null allowed) (memq dir allowed))
           (progn
             (set direction-var dir)
-            (set size-var (cj/window-body-size window dir)))
+            (set size-var (cj/window-replay-size window dir)))
         (set direction-var default-direction)
         (set size-var nil)))))
 
@@ -59,10 +59,12 @@ DEFAULT-SIZE when the stored values are nil.  The cardinal direction
 is mapped to its frame-edge variant via
 `cj/cardinal-to-edge-direction' so the new buffer always lands at
 the same frame edge regardless of the selected window.  An integer
-size is wrapped in a `(body-columns . N)' / `(body-lines . N)' cons
-so `display-buffer-in-direction' sets the body explicitly,
-divider-independent.  A float size passes through as a fraction of
-the new window's parent.
+size is wrapped per axis: a width size as a `(body-columns . N)'
+cons (divider-independent body width), a height size as a plain
+integer total-line count.  Height uses total rather than body so the
+capture/replay round-trip is immune to the mode line's pixel height
+(see `cj/window-replay-size').  A float size passes through as a
+fraction of the new window's parent.
 
 Caller-supplied ALIST entries for direction, window-width, or
 window-height are stripped before delegating to
@@ -74,15 +76,15 @@ placement; the remaining alist entries are passed through."
          (edge-direction (or (cj/cardinal-to-edge-direction direction)
                              (cj/cardinal-to-edge-direction default-direction)))
          (size (or stored-size default-size))
-         (size-key (if (memq direction '(right left))
-                       'window-width
-                     'window-height))
-         (body-tag (if (memq direction '(right left))
-                       'body-columns
-                     'body-lines))
-         (size-value (if (integerp size)
-                         (cons body-tag size)
-                       size))
+         (width-axis (memq direction '(right left)))
+         (size-key (if width-axis 'window-width 'window-height))
+         ;; A width integer is a body-column count (divider-independent); a
+         ;; height integer is a plain total-line count (mode-line-pixel-
+         ;; independent -- see `cj/window-replay-size').  Floats pass through.
+         (size-value (cond
+                      ((not (integerp size)) size)
+                      (width-axis (cons 'body-columns size))
+                      (t size)))
          (filtered (cl-remove-if
                     (lambda (cell)
                       (memq (car-safe cell)