Emit focus events on window selection changes

Previously ghostel only reported focus via
`after-focus-change-function', so child programs (Claude Code,
btop, vim) that enable mode 1004 only saw focus-out when the
entire Emacs frame blurred.  Selecting a different window inside
Emacs kept the terminal thinking it was focused.

Compute logical focus per ghostel buffer as "frame is focused AND
buffer is in frame's selected window" and hook into
`window-selection-change-functions' and
`window-buffer-change-functions' in addition to frame focus.  A
buffer-local `ghostel--focus-state' dedups so only actual
transitions emit VT events.  Minibuffer activation correctly
drives focus-out because the ghostel window is no longer the
frame's selected window.

Also drop an unrelated bug in the sentinel: it called
`remove-function' on every process exit, which removed the focus
hook globally and broke focus reporting for all other live
ghostel buffers.  The handler's existing guards (`ghostel--term',
`process-live-p') already make it a no-op after exit, so the
removal was both wrong and unnecessary.

Only dedup focus state when event actually emits

When mode 1004 is disabled, `ghostel--focus-event' drops the write
and returns nil.  Previously we updated `ghostel--focus-state'
unconditionally, so if a focus change ran before the child enabled
1004, the cached state would dedup away the first real event once
1004 was turned on.  Update the state only when the event actually
emitted.

Close #140

Author: dakra

ghostel.el

@@ -2244,17 +2244,41 @@ Call this after changing the Emacs theme so terminals match."
 
 ;;; Focus events
 
-(defun ghostel--focus-change ()
-  "Notify ghostel terminals in the selected frame about focus change.
-Only send the event if the terminal has enabled focus reporting (mode 1004)."
-  (let ((focused (frame-focus-state)))
-    (dolist (buf (buffer-list))
+(defvar-local ghostel--focus-state nil
+  "Last focus state actually reported to the terminal for this buffer.
+Non-nil means a focus-in event was delivered.  Only updated when
+`ghostel--focus-event' actually emits (mode 1004 enabled), so that
+enabling 1004 after a focus change still lets the next event fire.")
+
+(defun ghostel--buffer-focused-p (buf)
+  "Return non-nil if BUF is logically focused.
+BUF is focused when it is displayed in the selected window of a
+frame whose focus state is t (i.e. the frame has keyboard focus
+and the buffer is the active selection within it)."
+  (seq-some (lambda (win)
+              (let ((frame (window-frame win)))
+                (and (eq (frame-focus-state frame) t)
+                     (eq win (frame-selected-window frame)))))
+            (get-buffer-window-list buf nil t)))
+
+(defun ghostel--focus-change (&rest _)
+  "Update focus state for every live ghostel buffer.
+Called from `after-focus-change-function',
+`window-selection-change-functions', and
+`window-buffer-change-functions'.  Sends a focus event only when
+the buffer's logical focus state transitions; `ghostel--focus-event'
+further gates on terminal mode 1004."
+  (dolist (buf (buffer-list))
+    (when (buffer-live-p buf)
       (with-current-buffer buf
         (when (and (derived-mode-p 'ghostel-mode)
                    ghostel--term
                    ghostel--process
                    (process-live-p ghostel--process))
-          (ghostel--focus-event ghostel--term focused))))))
+          (let ((focused (and (ghostel--buffer-focused-p buf) t)))
+            (unless (eq focused ghostel--focus-state)
+              (when (ghostel--focus-event ghostel--term focused)
+                (setq ghostel--focus-state focused)))))))))
 
 (defvar-local ghostel--pending-output nil
   "Accumulated output chunks waiting to be fed to the terminal.
@@ -2319,7 +2343,6 @@ PROCESS is the shell process, EVENT describes the state change."
         (when ghostel--input-timer
           (cancel-timer ghostel--input-timer)
           (setq ghostel--input-timer nil))
-        (remove-function after-focus-change-function #'ghostel--focus-change)
         (run-hook-with-args 'ghostel-exit-functions buf event)
         (if ghostel-kill-buffer-on-exit
             (kill-buffer buf)
@@ -2978,6 +3001,8 @@ PROCESS is the shell process, WINDOWS is the list of windows."
   (setq-local scroll-conservatively 101)
   (setq-local line-spacing 0)
   (add-function :after after-focus-change-function #'ghostel--focus-change)
+  (add-hook 'window-selection-change-functions #'ghostel--focus-change)
+  (add-hook 'window-buffer-change-functions #'ghostel--focus-change)
   (ghostel--suppress-interfering-modes)
   (setq ghostel--scroll-intercept-active t)
   ;; Let C-g reach the keymap instead of triggering keyboard-quit.

test/ghostel-test.el

@@ -1582,6 +1582,206 @@ the reply waits for the redraw timer."
     (ghostel--write-input term "\e[?1004l")
     (should (equal nil (ghostel--focus-event term t)))))   ; focus ignored after reset
 
+;; -----------------------------------------------------------------------
+;; Test: window-level focus events (issue #140)
+;; -----------------------------------------------------------------------
+
+(defun ghostel-test--make-focus-buffer (name)
+  "Create a ghostel-mode buffer NAME with a fake term and live process.
+Returns the buffer."
+  (let ((buf (generate-new-buffer name)))
+    (with-current-buffer buf
+      (ghostel-mode)
+      (setq ghostel--term (vector 'fake-term))
+      (setq ghostel--process
+            (start-process (concat "ghostel-test-focus-" name)
+                           nil "cat"))
+      (set-process-query-on-exit-flag ghostel--process nil))
+    buf))
+
+(defun ghostel-test--cleanup-focus-buffer (buf)
+  "Kill BUF and its fake process."
+  (when (buffer-live-p buf)
+    (with-current-buffer buf
+      (when (and ghostel--process (process-live-p ghostel--process))
+        (delete-process ghostel--process)))
+    (kill-buffer buf)))
+
+(defmacro ghostel-test--with-focus-stub (events-var focus-fn &rest body)
+  "Run BODY with `ghostel--focus-event' and `frame-focus-state' stubbed.
+EVENTS-VAR names a list that receives (BUFFER . FOCUSED) pairs.
+FOCUS-FN is a zero-arg function returning the current `frame-focus-state'."
+  (declare (indent 2))
+  `(cl-letf (((symbol-function 'ghostel--focus-event)
+              (lambda (_term focused)
+                (push (cons (current-buffer) focused) ,events-var)
+                t))
+             ((symbol-function 'frame-focus-state)
+              (lambda (&optional _frame) (funcall ,focus-fn))))
+     ,@body))
+
+(ert-deftest ghostel-test-focus-window-selection ()
+  "Window selection changes flip per-buffer focus state."
+  (let* ((events nil)
+         (focus-fn (lambda () t))
+         (buf (ghostel-test--make-focus-buffer " *ghostel-focus-1*"))
+         (other (generate-new-buffer " *other*"))
+         (saved-window-config (current-window-configuration)))
+    (unwind-protect
+        (ghostel-test--with-focus-stub events focus-fn
+          (delete-other-windows)
+          (switch-to-buffer buf)
+          (let ((other-win (split-window)))
+            (set-window-buffer other-win other)
+            ;; ghostel window selected → focus-in
+            (ghostel--focus-change)
+            (should (equal (car events) (cons buf t)))
+            ;; Select the other window → focus-out
+            (select-window other-win)
+            (setq events nil)
+            (ghostel--focus-change)
+            (should (equal (car events) (cons buf nil)))
+            ;; Select ghostel window again → focus-in
+            (select-window (get-buffer-window buf))
+            (setq events nil)
+            (ghostel--focus-change)
+            (should (equal (car events) (cons buf t)))))
+      (set-window-configuration saved-window-config)
+      (ghostel-test--cleanup-focus-buffer buf)
+      (kill-buffer other))))
+
+(ert-deftest ghostel-test-focus-dedup ()
+  "Repeat calls with unchanged state do not re-send focus events."
+  (let* ((events nil)
+         (frame-focused t)
+         (focus-fn (lambda () frame-focused))
+         (buf (ghostel-test--make-focus-buffer " *ghostel-focus-dedup*"))
+         (saved-window-config (current-window-configuration)))
+    (unwind-protect
+        (ghostel-test--with-focus-stub events focus-fn
+          (delete-other-windows)
+          (switch-to-buffer buf)
+          (ghostel--focus-change)          ; focus-in
+          (ghostel--focus-change)          ; no-op (dedup)
+          (ghostel--focus-change)          ; no-op (dedup)
+          (should (equal events (list (cons buf t))))
+          ;; Transition to focus-out, then confirm further calls dedup.
+          (setq frame-focused nil)
+          (ghostel--focus-change)          ; focus-out
+          (ghostel--focus-change)          ; no-op (dedup)
+          (should (equal events (list (cons buf nil) (cons buf t)))))
+      (set-window-configuration saved-window-config)
+      (ghostel-test--cleanup-focus-buffer buf))))
+
+(ert-deftest ghostel-test-focus-two-ghostel-buffers ()
+  "Only the ghostel buffer in the selected window is focused."
+  (let* ((events nil)
+         (focus-fn (lambda () t))
+         (buf-a (ghostel-test--make-focus-buffer " *ghostel-focus-a*"))
+         (buf-b (ghostel-test--make-focus-buffer " *ghostel-focus-b*"))
+         (saved-window-config (current-window-configuration)))
+    (unwind-protect
+        (ghostel-test--with-focus-stub events focus-fn
+          (delete-other-windows)
+          (switch-to-buffer buf-a)
+          (let ((win-b (split-window)))
+            (set-window-buffer win-b buf-b)
+            ;; A selected: A transitions nil→t, B stays nil (dedup).
+            (ghostel--focus-change)
+            (should (equal events (list (cons buf-a t))))
+            ;; Select B: A transitions t→nil, B transitions nil→t.
+            (select-window win-b)
+            (setq events nil)
+            (ghostel--focus-change)
+            (should (= (length events) 2))
+            (should (member (cons buf-a nil) events))
+            (should (member (cons buf-b t) events))
+            ;; Back to A: inverse transitions.
+            (select-window (get-buffer-window buf-a))
+            (setq events nil)
+            (ghostel--focus-change)
+            (should (= (length events) 2))
+            (should (member (cons buf-a t) events))
+            (should (member (cons buf-b nil) events))))
+      (set-window-configuration saved-window-config)
+      (ghostel-test--cleanup-focus-buffer buf-a)
+      (ghostel-test--cleanup-focus-buffer buf-b))))
+
+(ert-deftest ghostel-test-focus-frame-blur ()
+  "Frame losing focus drives the ghostel buffer to focus-out."
+  (let* ((events nil)
+         (frame-focused t)
+         (focus-fn (lambda () frame-focused))
+         (buf (ghostel-test--make-focus-buffer " *ghostel-focus-blur*"))
+         (saved-window-config (current-window-configuration)))
+    (unwind-protect
+        (ghostel-test--with-focus-stub events focus-fn
+          (delete-other-windows)
+          (switch-to-buffer buf)
+          (ghostel--focus-change)          ; focus-in
+          (should (equal (car events) (cons buf t)))
+          (setq frame-focused nil)         ; simulate app blur
+          (setq events nil)
+          (ghostel--focus-change)
+          (should (equal (car events) (cons buf nil)))
+          (setq frame-focused t)           ; refocus
+          (setq events nil)
+          (ghostel--focus-change)
+          (should (equal (car events) (cons buf t))))
+      (set-window-configuration saved-window-config)
+      (ghostel-test--cleanup-focus-buffer buf))))
+
+(ert-deftest ghostel-test-focus-skips-state-update-when-1004-off ()
+  "Dropped events (mode 1004 off) do not update cached focus state.
+Otherwise, enabling 1004 after a focus change would dedup away the
+first real focus event."
+  (let* ((events nil)
+         (emit-p nil)
+         (buf (ghostel-test--make-focus-buffer " *ghostel-focus-gated*"))
+         (saved-window-config (current-window-configuration)))
+    (unwind-protect
+        (cl-letf (((symbol-function 'ghostel--focus-event)
+                   (lambda (_term focused)
+                     (when emit-p
+                       (push (cons (current-buffer) focused) events))
+                     emit-p))
+                  ((symbol-function 'frame-focus-state)
+                   (lambda (&optional _frame) t)))
+          (delete-other-windows)
+          (switch-to-buffer buf)
+          ;; Mode 1004 off: event is dropped, state must remain nil.
+          (ghostel--focus-change)
+          (should (null events))
+          (with-current-buffer buf
+            (should (null ghostel--focus-state)))
+          ;; Child now enables mode 1004.  Next focus-change must emit.
+          (setq emit-p t)
+          (ghostel--focus-change)
+          (should (equal events (list (cons buf t)))))
+      (set-window-configuration saved-window-config)
+      (ghostel-test--cleanup-focus-buffer buf))))
+
+(ert-deftest ghostel-test-focus-minibuffer ()
+  "Activating the minibuffer triggers focus-out on the ghostel buffer."
+  (let* ((events nil)
+         (focus-fn (lambda () t))
+         (buf (ghostel-test--make-focus-buffer " *ghostel-focus-mini*"))
+         (saved-window-config (current-window-configuration)))
+    (unwind-protect
+        (ghostel-test--with-focus-stub events focus-fn
+          (delete-other-windows)
+          (switch-to-buffer buf)
+          (ghostel--focus-change)
+          (should (equal (car events) (cons buf t)))
+          ;; Simulate minibuffer activation by selecting the minibuffer window.
+          (let ((mb-win (minibuffer-window)))
+            (select-window mb-win)
+            (setq events nil)
+            (ghostel--focus-change)
+            (should (equal (car events) (cons buf nil)))))
+      (set-window-configuration saved-window-config)
+      (ghostel-test--cleanup-focus-buffer buf))))
+
 ;; -----------------------------------------------------------------------
 ;; Test: incremental (partial) redraw
 ;; -----------------------------------------------------------------------
@@ -5942,7 +6142,13 @@ while :; do sleep 0.1; done'\n")
 
 
 (defconst ghostel-test--elisp-tests
-  '(ghostel-test-raw-key-sequences
+  '(ghostel-test-focus-window-selection
+    ghostel-test-focus-dedup
+    ghostel-test-focus-two-ghostel-buffers
+    ghostel-test-focus-frame-blur
+    ghostel-test-focus-skips-state-update-when-1004-off
+    ghostel-test-focus-minibuffer
+    ghostel-test-raw-key-sequences
     ghostel-test-modifier-number
     ghostel-test-send-event
     ghostel-test-raw-key-modified-specials