refactor(agenda): replace the dedicated frame with a full-frame F8

- F8 now fills the whole frame instead of three quarters.
- The agenda rebuilds itself on every five-minute wall-clock mark.
- Quitting restores the window layout it took over.
- The dedicated agenda frame and its tests are gone.
- S-<f8> returns to the force-rescan.

The frame bought live shared state. It paid for that with a read-only deny policy, engage-routing and a snapshot failure path. All of it existed only because the agenda shared a process with my working frames. A full-frame F8 needs none of it.

The refresh rebuilds only a visible agenda. It keeps point on its line. The body is guarded, because a signal in a repeating timer resignals every tick.

1 files changed, 170 insertions, 0 deletions

diff --git a/tests/test-org-agenda-config--auto-refresh.el b/tests/test-org-agenda-config--auto-refresh.el
new file mode 100644
index 00000000..58ef729b
--- /dev/null
+++ b/tests/test-org-agenda-config--auto-refresh.el
@@ -0,0 +1,170 @@
+;;; test-org-agenda-config--auto-refresh.el --- Tests for agenda auto-refresh -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for the wall-clock-aligned auto-refresh behind the F8 agenda:
+;; the next-mark arithmetic, the on-screen-agenda lookup, the timer body's
+;; error containment, and start/stop timer ownership.
+
+;;; Code:
+
+(require 'ert)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'org-agenda-config)
+
+;; -- Fixtures ----------------------------------------------------------------
+
+(defun test-org-agenda-auto-refresh--time (hh mm ss)
+  "Return an Emacs time value for today at HH:MM:SS local time."
+  (let ((now (decode-time)))
+    (encode-time (list ss mm hh
+                       (nth 3 now) (nth 4 now) (nth 5 now)
+                       nil -1 (nth 8 now)))))
+
+(defmacro test-org-agenda-auto-refresh--with-agenda-window (&rest body)
+  "Run BODY with a window displaying a buffer in `org-agenda-mode'.
+Sets `major-mode' directly rather than calling the mode function: the
+lookup under test only asks what mode the window's buffer is in, and
+`org-agenda-mode' setup wants a real agenda build behind it."
+  (declare (indent 0))
+  `(let ((buffer (get-buffer-create "*Org Agenda*")))
+     (unwind-protect
+         (save-window-excursion
+           (with-current-buffer buffer
+             (setq major-mode 'org-agenda-mode))
+           (set-window-buffer (selected-window) buffer)
+           ,@body)
+       (kill-buffer buffer))))
+
+;; -- cj/--org-agenda-seconds-to-next-mark ------------------------------------
+
+(ert-deftest test-org-agenda-config-next-mark-mid-interval ()
+  "Normal: a time between marks returns the remainder to the next one."
+  (should (= 120 (cj/--org-agenda-seconds-to-next-mark
+                  (test-org-agenda-auto-refresh--time 9 3 0) 300))))
+
+(ert-deftest test-org-agenda-config-next-mark-exactly-on-mark ()
+  "Boundary: a time exactly on a mark returns a full period, never zero.
+A zero delay would fire the timer immediately and again a period later."
+  (should (= 300 (cj/--org-agenda-seconds-to-next-mark
+                  (test-org-agenda-auto-refresh--time 9 5 0) 300))))
+
+(ert-deftest test-org-agenda-config-next-mark-one-second-before ()
+  "Boundary: one second short of a mark returns one second."
+  (should (= 1 (cj/--org-agenda-seconds-to-next-mark
+                (test-org-agenda-auto-refresh--time 9 4 59) 300))))
+
+(ert-deftest test-org-agenda-config-next-mark-lands-on-a-multiple ()
+  "Normal: TIME plus the result is always a whole multiple of PERIOD.
+This is the property that makes the refresh land on :00/:05 rather than
+five minutes after whenever the agenda happened to open."
+  (dolist (seconds '(0 1 59 60 61 149 150 299))
+    (let* ((time (test-org-agenda-auto-refresh--time 9 0 0))
+           (start (+ (floor (float-time time)) seconds))
+           (delay (cj/--org-agenda-seconds-to-next-mark start 300)))
+      (should (zerop (mod (+ start delay) 300))))))
+
+(ert-deftest test-org-agenda-config-next-mark-rejects-nonpositive-period ()
+  "Error: a zero or negative period is a caller bug, not a silent no-op."
+  (should-error (cj/--org-agenda-seconds-to-next-mark (current-time) 0))
+  (should-error (cj/--org-agenda-seconds-to-next-mark (current-time) -300)))
+
+;; -- cj/--org-agenda-refresh-window ------------------------------------------
+
+(ert-deftest test-org-agenda-config-refresh-window-finds-displayed-agenda ()
+  "Normal: the lookup returns the window showing an agenda buffer."
+  (test-org-agenda-auto-refresh--with-agenda-window
+    (should (eq (cj/--org-agenda-refresh-window) (selected-window)))))
+
+(ert-deftest test-org-agenda-config-refresh-window-nil-when-not-displayed ()
+  "Boundary: an agenda buffer that exists but is off-screen is not a target.
+Rebuilding an invisible agenda costs time and shows nobody anything."
+  (let ((buffer (get-buffer-create "*Org Agenda*")))
+    (unwind-protect
+        (progn
+          (with-current-buffer buffer (setq major-mode 'org-agenda-mode))
+          (should-not (cj/--org-agenda-refresh-window)))
+      (kill-buffer buffer))))
+
+(ert-deftest test-org-agenda-config-refresh-window-nil-with-no-agenda ()
+  "Boundary: no agenda buffer anywhere returns nil rather than erroring."
+  (should-not (cj/--org-agenda-refresh-window)))
+
+;; -- cj/--org-agenda-auto-refresh (the timer body) ---------------------------
+
+(ert-deftest test-org-agenda-config-auto-refresh-noop-without-agenda ()
+  "Boundary: the tick does nothing, and signals nothing, with no agenda up."
+  (let ((called nil))
+    (cl-letf (((symbol-function 'org-agenda-redo)
+               (lambda (&rest _) (setq called t))))
+      (cj/--org-agenda-auto-refresh)
+      (should-not called))))
+
+(ert-deftest test-org-agenda-config-auto-refresh-redoes-visible-agenda ()
+  "Normal: the tick redoes the agenda shown on screen."
+  (let ((called nil))
+    (cl-letf (((symbol-function 'org-agenda-redo)
+               (lambda (&rest _) (setq called t))))
+      (test-org-agenda-auto-refresh--with-agenda-window
+        (cj/--org-agenda-auto-refresh))
+      (should called))))
+
+(ert-deftest test-org-agenda-config-auto-refresh-contains-errors ()
+  "Error: a failing redo must not escape the timer body.
+An unguarded signal in a repeating timer resignals on every tick, which is
+how a five-minute timer turns into an endless backtrace."
+  (cl-letf (((symbol-function 'org-agenda-redo)
+             (lambda (&rest _) (error "simulated redo failure")))
+            ((symbol-function 'cj/log-silently) (lambda (&rest _) nil)))
+    (test-org-agenda-auto-refresh--with-agenda-window
+      (should (progn (cj/--org-agenda-auto-refresh) t)))))
+
+(ert-deftest test-org-agenda-config-auto-refresh-restores-point-line ()
+  "Normal: the tick leaves point on the line it started on.
+A refresh that scrolls the reader back to the top every five minutes is
+worse than no refresh."
+  (cl-letf (((symbol-function 'org-agenda-redo) (lambda (&rest _) nil)))
+    (test-org-agenda-auto-refresh--with-agenda-window
+      (with-current-buffer "*Org Agenda*"
+        (erase-buffer)
+        (dotimes (i 10) (insert (format "agenda line %d\n" i)))
+        (goto-char (point-min))
+        (forward-line 4))
+      (cj/--org-agenda-auto-refresh)
+      (with-current-buffer "*Org Agenda*"
+        (should (= 5 (line-number-at-pos)))))))
+
+;; -- start / stop ------------------------------------------------------------
+
+(ert-deftest test-org-agenda-config-auto-refresh-start-owns-one-timer ()
+  "Normal: starting twice leaves exactly one timer, not two.
+Re-loading the module in a live daemon re-runs the arming form, so a
+non-idempotent start would stack a second ticker on every reload."
+  (let ((cj/--org-agenda-refresh-timer nil))
+    (unwind-protect
+        (progn
+          (cj/org-agenda-auto-refresh-start)
+          (let ((first cj/--org-agenda-refresh-timer))
+            (cj/org-agenda-auto-refresh-start)
+            (should (timerp cj/--org-agenda-refresh-timer))
+            (should-not (memq first timer-list))
+            (should (memq cj/--org-agenda-refresh-timer timer-list))))
+      (cj/org-agenda-auto-refresh-stop))))
+
+(ert-deftest test-org-agenda-config-auto-refresh-stop-clears-timer ()
+  "Normal: stopping cancels the timer and clears the handle."
+  (let ((cj/--org-agenda-refresh-timer nil))
+    (cj/org-agenda-auto-refresh-start)
+    (let ((timer cj/--org-agenda-refresh-timer))
+      (cj/org-agenda-auto-refresh-stop)
+      (should-not cj/--org-agenda-refresh-timer)
+      (should-not (memq timer timer-list)))))
+
+(ert-deftest test-org-agenda-config-auto-refresh-stop-is-safe-when-stopped ()
+  "Boundary: stopping an already-stopped refresh is a no-op, not an error."
+  (let ((cj/--org-agenda-refresh-timer nil))
+    (should (progn (cj/org-agenda-auto-refresh-stop) t))
+    (should-not cj/--org-agenda-refresh-timer)))
+
+(provide 'test-org-agenda-config--auto-refresh)
+;;; test-org-agenda-config--auto-refresh.el ends here