fix: correct four wrong behaviors and drop three dead code pathsHEADmain

- yt-dlp downloads claimed completion when tsp had merely queued them.
- A fresh machine opened org links in EWW, not Chrome.
- ArchWiki search raised a raw error instead of the install hint.
- The pre-commit hook kept running when its cd failed.
- Removed a second device-grouping implementation nothing called.
- Removed a redundant epub advice that ran on every file visit.
- Removed a buffer-burying clause naming a mode Emacs doesn't define.
- Moved the Hugo bindings onto the custom prefix map.
- The ArchWiki docs path is now a variable, making it testable.

17 files changed, 627 insertions, 513 deletions

diff --git a/githooks/pre-commit b/githooks/pre-commit
index 27f280c3..2c0cf0b0 100755
--- a/githooks/pre-commit
+++ b/githooks/pre-commit
@@ -5,7 +5,7 @@
 set -u
 
 REPO_ROOT="$(git rev-parse --show-toplevel)"
-cd "$REPO_ROOT"
+cd "$REPO_ROOT" || exit 1
 
 # --- 1. Secret scan ---
 # Patterns for common credentials. Scans only added lines in the staged diff.
diff --git a/modules/browser-config.el b/modules/browser-config.el
index 564e7a27..4571c1d9 100644
--- a/modules/browser-config.el
+++ b/modules/browser-config.el
@@ -143,7 +143,23 @@ Persists the choice for future sessions."
             ('save-failed (message "Failed to save browser choice"))
             ('invalid-plist (message "Invalid browser configuration"))))))))
 
-;; Initialize: Load saved choice or use first available browser
+(defun cj/--preferred-default-browser (browsers)
+  "Return the browser plist to adopt as the first-run default from BROWSERS.
+
+Prefers the first entry with a non-nil :executable -- a real external
+browser -- and falls back to the first entry overall when none is
+installed.  Built-in browsers carry a nil :executable and so are always
+\"available\", which put EWW at the head of `cj/discover-browsers' on
+every machine.  Taking the head therefore opened every link in the text
+browser on a fresh checkout even with Chrome installed, until the user
+happened to run `cj/choose-browser'.  EWW stays reachable as the
+deliberate fallback when nothing external is on PATH.
+
+Returns nil for an empty BROWSERS list."
+  (or (seq-find (lambda (b) (plist-get b :executable)) browsers)
+      (car browsers)))
+
+;; Initialize: Load saved choice or use the preferred available browser
 (defun cj/--do-initialize-browser ()
   "Initialize browser configuration.
 Returns: (cons \\='loaded browser-plist) if saved choice was loaded,
@@ -153,10 +169,10 @@ Returns: (cons \\='loaded browser-plist) if saved choice was loaded,
   (let ((saved-choice (cj/load-browser-choice)))
     (if saved-choice
         (cons 'loaded saved-choice)
-      ;; No saved choice - try to set first available browser
+      ;; No saved choice - adopt the preferred available browser
       (let ((browsers (cj/discover-browsers)))
         (if browsers
-            (cons 'first-available (car browsers))
+            (cons 'first-available (cj/--preferred-default-browser browsers))
           (cons 'no-browsers nil))))))
 
 (defun cj/initialize-browser ()
diff --git a/modules/calibredb-epub-config.el b/modules/calibredb-epub-config.el
index e0a82245..27fa6369 100644
--- a/modules/calibredb-epub-config.el
+++ b/modules/calibredb-epub-config.el
@@ -205,22 +205,14 @@ Adjust it live with `cj/nov-widen-text' and `cj/nov-narrow-text'.")
 (defvar cj/nov-margin-step 2
   "Percentage points each `cj/nov-widen-text'/`cj/nov-narrow-text' press changes.")
 
-;; Prevent magic-fallback-mode-alist from opening epub as archive-mode
-;; Advise set-auto-mode to force nov-mode for .epub files before magic-fallback runs
-(defun cj/force-nov-mode-for-epub (orig-fun &rest args)
-  "Force nov-mode for .epub files, bypassing archive-mode detection."
-  (if (and buffer-file-name
-           (string-match-p "\\.epub\\'" buffer-file-name))
-      (progn
-        (unless (featurep 'nov)
-          (require 'nov nil t))
-        ;; Call nov-mode if available, otherwise fallback to default behavior
-        (if (fboundp 'nov-mode)
-            (nov-mode)
-          (apply orig-fun args)))
-    (apply orig-fun args)))
-
-(advice-add 'set-auto-mode :around #'cj/force-nov-mode-for-epub)
+;; .epub reaches nov-mode through auto-mode-alist -- nov's use-package :mode
+;; below registers "\\.epub\\'" there, and `set-auto-mode' consults
+;; auto-mode-alist before magic-fallback-mode-alist, so the zip container never
+;; reaches the archive-mode fallback.  An :around advice on `set-auto-mode' used
+;; to force this and was pure overhead: set-auto-mode runs on every file visit,
+;; so it added a frame and a failure surface to every file of every type.
+;; Verified live before removal -- a real zip-format .epub opened in nov-mode
+;; both with the advice and without it.
 
 ;; Define helper functions before use-package so they're available for hooks
 (defun cj/forward-paragraph-and-center ()
diff --git a/modules/help-utils.el b/modules/help-utils.el
index 9792841a..2709ac45 100644
--- a/modules/help-utils.el
+++ b/modules/help-utils.el
@@ -65,24 +65,40 @@
 ;; on Arch: yay (or whatever your AUR package manager is) -S  arch-wiki-docs
 ;; browse the arch wiki topics offline
 
+(defvar cj/arch-wiki-html-dir "/usr/share/doc/arch-wiki/html/en"
+  "Directory holding the offline ArchWiki HTML copies.
+Populated by the arch-wiki-docs package on Arch systems.")
+
+(defun cj/--arch-wiki-topics (dir)
+  "Return an alist of (BASENAME . FULLPATH) for ArchWiki topics under DIR.
+
+Returns nil when DIR does not exist rather than signaling.  This is the
+whole point of the helper: `directory-files' raises file-missing on an
+absent directory, and the caller's \"is arch-wiki-docs installed?\" hint
+sat below that call, so on the one machine state the hint was written for
+it could never be reached."
+  (when (file-directory-p dir)
+    (mapcar (lambda (f) (cons (file-name-base f) f))
+            (directory-files dir t "\\.html\\'"))))
+
 (defun cj/local-arch-wiki-search ()
   "Prompt for an ArchWiki topic and open its local HTML copy in EWW.
 
-Looks for “*.html” files under \"/usr/share/doc/arch-wiki/html/en\",
-lets you complete on their basenames, and displays the chosen file
-with `eww-browse-url'. If no file is found, reminds you to install
+Looks for “*.html” files under `cj/arch-wiki-html-dir', lets you complete
+on their basenames, and displays the chosen file with `eww-browse-url'.
+If the directory is missing or empty, reminds you to install
 arch-wiki-docs."
   (interactive)
-  (let* ((dir "/usr/share/doc/arch-wiki/html/en")
-		 (full-filenames (directory-files dir t "\\.html\\'"))
-		 (basenames (mapcar 'file-name-base full-filenames))
-		 (chosen (completing-read "Choose an ArchWiki Topic: " basenames)))
-	(if (member chosen basenames)
-		(let* ((idx (cl-position chosen basenames :test 'equal))
-			   (fullname (nth idx full-filenames))
-			   (url (concat "file://" fullname)))
-		  (eww-browse-url url))
-	  (message "File not found! Is arch-wiki-docs installed?"))))
+  (let ((topics (cj/--arch-wiki-topics cj/arch-wiki-html-dir)))
+    (if (null topics)
+        (message "No ArchWiki topics in %s. Is arch-wiki-docs installed?"
+                 cj/arch-wiki-html-dir)
+      (let* ((chosen (completing-read "Choose an ArchWiki Topic: "
+                                      (mapcar #'car topics)))
+             (fullname (cdr (assoc chosen topics))))
+        (if fullname
+            (eww-browse-url (concat "file://" fullname))
+          (message "No ArchWiki topic named %s" chosen))))))
 (keymap-global-set "C-h A" #'cj/local-arch-wiki-search)
 
 (provide 'help-utils)
diff --git a/modules/hugo-config.el b/modules/hugo-config.el
index b26398c6..36f9e07a 100644
--- a/modules/hugo-config.el
+++ b/modules/hugo-config.el
@@ -28,6 +28,7 @@
 (require 'user-constants)
 (require 'host-environment)
 (require 'system-lib)  ;; completion table + file annotator
+(require 'keybindings) ;; cj/register-prefix-map, cj/custom-keymap
 
 ;; --------------------------------- Constants ---------------------------------
 
@@ -247,14 +248,18 @@ to /var/www/cjennings/, so a successful push is the deploy."
 
 ;; -------------------------------- Keybindings --------------------------------
 
-(global-set-key (kbd "C-; h n") #'cj/hugo-new-post)
-(global-set-key (kbd "C-; h e") #'cj/hugo-export-post)
-(global-set-key (kbd "C-; h o") #'cj/hugo-open-blog-dir)
-(global-set-key (kbd "C-; h O") #'cj/hugo-open-blog-dir-external)
-(global-set-key (kbd "C-; h d") #'cj/hugo-open-draft)
-(global-set-key (kbd "C-; h D") #'cj/hugo-toggle-draft)
-(global-set-key (kbd "C-; h p") #'cj/hugo-preview)
-(global-set-key (kbd "C-; h P") #'cj/hugo-publish)
+(defvar-keymap cj/hugo-keymap
+  :doc "Keymap for Hugo blog commands"
+  "n" #'cj/hugo-new-post
+  "e" #'cj/hugo-export-post
+  "o" #'cj/hugo-open-blog-dir
+  "O" #'cj/hugo-open-blog-dir-external
+  "d" #'cj/hugo-open-draft
+  "D" #'cj/hugo-toggle-draft
+  "p" #'cj/hugo-preview
+  "P" #'cj/hugo-publish)
+
+(cj/register-prefix-map "h" cj/hugo-keymap)
 
 (with-eval-after-load 'which-key
   (which-key-add-key-based-replacements
diff --git a/modules/media-utils.el b/modules/media-utils.el
index 99b5dc37..7047411f 100644
--- a/modules/media-utils.el
+++ b/modules/media-utils.el
@@ -210,6 +210,32 @@ with a plain argv list -- no shell anywhere in the pipeline."
 
 ;; ------------------------- Media-Download Via yt-dlp -------------------------
 
+(defun cj/media--yt-dl-message (event url-display)
+  "Return the message for tsp EVENT on URL-DISPLAY, or nil when it reports nothing.
+
+Reports queueing, not completion, and the distinction is the point.
+`cj/yt-dl-it' launches \"tsp yt-dlp ...\", and tsp enqueues the job and
+exits immediately, so this sentinel fires on tsp's exit rather than
+yt-dlp's.  A clean exit proves the job was accepted by the spooler and
+nothing more, so claiming the download finished would be a guess that is
+wrong whenever yt-dlp fails minutes later.  Check the spooler with
+\"tsp\" for real download status."
+  (cond
+   ((string-match-p "finished" event)
+    (format "✓ Queued for download: %s" url-display))
+   ((string-match-p "exited abnormally" event)
+    (format "✗ Could not queue download: %s" url-display))))
+
+(defun cj/media--yt-dl-sentinel (url-display)
+  "A process sentinel reporting the queueing of URL-DISPLAY.
+Messages per `cj/media--yt-dl-message' and reaps the process buffer once
+tsp finishes or exits."
+  (lambda (proc event)
+    (when-let ((msg (cj/media--yt-dl-message event url-display)))
+      (message "%s" msg))
+    (when (string-match-p "finished\\|exited" event)
+      (kill-buffer (process-buffer proc)))))
+
 (defun cj/yt-dl-it (url)
   "Downloads the URL in an async shell."
   (unless (executable-find "yt-dlp")
@@ -223,16 +249,8 @@ with a plain argv list -- no shell anywhere in the pipeline."
 		 (process (start-process "yt-dlp" buffer-name
 								 "tsp" "yt-dlp" "--add-metadata" "-ic"
 								 "-o" output-template url)))
-	(message "Started download: %s" url-display)
-	(set-process-sentinel process
-						  (lambda (proc event)
-							(cond
-							 ((string-match-p "finished" event)
-							  (message "✓ Finished downloading: %s" url-display))
-							 ((string-match-p "exited abnormally" event)
-							  (message "✗ Download failed: %s" url-display)))
-							(when (string-match-p "finished\\|exited" event)
-							  (kill-buffer (process-buffer proc)))))))
+	(message "Queueing download: %s" url-display)
+	(set-process-sentinel process (cj/media--yt-dl-sentinel url-display))))
 
 (provide 'media-utils)
 ;;; media-utils.el ends here.
diff --git a/modules/video-audio-recording-devices.el b/modules/video-audio-recording-devices.el
index 375a81cf..8adcd347 100644
--- a/modules/video-audio-recording-devices.el
+++ b/modules/video-audio-recording-devices.el
@@ -272,54 +272,6 @@ Returns the selected device name, or signals user-error if cancelled."
       (user-error "Device setup cancelled"))
     device))
 
-(defun cj/recording-group-devices-by-hardware ()
-  "Group audio sources by physical hardware device.
-Returns alist of (friendly-name . (mic-source . monitor-source)).
-Only includes devices that have BOTH a mic and a monitor source,
-since recording needs both to capture your voice and system audio."
-  (let ((sources (cj/recording-parse-sources))
-        (devices (make-hash-table :test 'equal))
-        (result nil))
-    ;; Group sources by base device name (hardware identifier)
-    (dolist (source sources)
-      (let* ((device (nth 0 source))
-             ;; Extract hardware ID — the unique part identifying the physical device.
-             ;; Different device types use different naming conventions in PulseAudio.
-             (base-name (cond
-                         ;; USB devices: extract usb-XXXXX-XX part
-                         ((string-match "\\.\\(usb-[^.]+\\-[0-9]+\\)\\." device)
-                          (match-string 1 device))
-                         ;; Built-in (PCI) devices: extract pci-XXXXX part
-                         ((string-match "\\.\\(pci-[^.]+\\)\\." device)
-                          (match-string 1 device))
-                         ;; Bluetooth devices: extract and normalize MAC address
-                         ;; (input uses colons, output uses underscores)
-                         ((string-match "bluez_\\(?:input\\|output\\)\\.\\([^.]+\\)" device)
-                          (replace-regexp-in-string "_" ":" (match-string 1 device)))
-                         (t device)))
-             (is-monitor (string-match-p "\\.monitor$" device))
-             (device-entry (gethash base-name devices)))
-        (unless device-entry
-          (setf device-entry (cons nil nil))
-          (puthash base-name device-entry devices))
-        (if is-monitor
-            (setcdr device-entry device)
-          (setcar device-entry device))))
-
-    ;; Convert hash table to alist with user-friendly names
-    (maphash (lambda (base-name pair)
-               (when (and (car pair) (cdr pair))
-                 (let ((friendly-name
-                        (cond
-                         ((string-match-p "usb.*[Jj]abra" base-name) "Jabra SPEAK 510 USB")
-                         ((string-match-p "^usb-" base-name) "USB Audio Device")
-                         ((string-match-p "^pci-" base-name) "Built-in Audio")
-                         ((string-match-p "^[0-9A-Fa-f:]+$" base-name) "Bluetooth Headset")
-                         (t base-name))))
-                   (push (cons friendly-name pair) result))))
-             devices)
-    (nreverse result)))
-
 (defun cj/recording-select-device (prompt device-type)
   "Interactively select an audio device.
 PROMPT is shown to user.  DEVICE-TYPE is \\='mic or \\='monitor for filtering.
diff --git a/modules/wrap-up.el b/modules/wrap-up.el
index e28ba845..6901901f 100644
--- a/modules/wrap-up.el
+++ b/modules/wrap-up.el
@@ -23,12 +23,12 @@
   "Bury comint and compilation buffers."
   (dolist (buf (buffer-list))
     (with-current-buffer buf
+	  ;; Byte-compilation output arrives in `emacs-lisp-compilation-mode',
+	  ;; which derives from `compilation-mode' and so is covered by that clause.
 	  (when (or (derived-mode-p 'comint-mode)
 				(derived-mode-p 'compilation-mode)
 				(derived-mode-p 'debugger-mode)
-				(derived-mode-p 'elisp-compile-mode)
-				(derived-mode-p 'messages-buffer-mode)
-				) ;; byte-compilations
+				(derived-mode-p 'messages-buffer-mode))
         (bury-buffer)))))
 
 (defun cj/bury-buffers-after-delay ()
diff --git a/tests/test-browser-config--preferred-default.el b/tests/test-browser-config--preferred-default.el
new file mode 100644
index 00000000..113ad540
--- /dev/null
+++ b/tests/test-browser-config--preferred-default.el
@@ -0,0 +1,89 @@
+;;; test-browser-config--preferred-default.el --- Tests for the first-run browser pick -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Unit tests for cj/--preferred-default-browser, the pure helper that picks
+;; the first-run default when no saved choice exists.
+;;
+;; The behavior it fixes: EWW is listed first in `cj/browser-definitions' and
+;; carries a nil executable, so `cj/discover-browsers' always reports it as
+;; available and it sorted first.  A fresh machine therefore opened every org
+;; link in the Emacs text browser until the user found cj/choose-browser, even
+;; with Chrome or Firefox installed.  The helper prefers a real external
+;; browser and keeps EWW as the genuine last resort.
+;;
+;; The helper takes the discovered list as an argument rather than calling
+;; `cj/discover-browsers' itself, so these tests drive real data structures
+;; and never stub executable-find.
+;;
+;; Test organization:
+;; - Normal Cases: external browser preferred over a leading built-in
+;; - Boundary Cases: only built-ins, only externals, single entry, empty list
+;; - Error Cases: entries missing the :executable key
+;;
+;;; Code:
+
+(require 'ert)
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'browser-config)
+
+(defconst test-browser--eww
+  '(:executable nil :function eww-browse-url :name "EWW (Emacs Browser)"
+                :path nil :program-var nil))
+
+(defconst test-browser--chrome
+  '(:executable "google-chrome" :function browse-url-chrome :name "Google Chrome"
+                :path "/usr/bin/google-chrome" :program-var browse-url-chrome-program))
+
+(defconst test-browser--firefox
+  '(:executable "firefox" :function browse-url-firefox :name "Firefox"
+                :path "/usr/bin/firefox" :program-var browse-url-firefox-program))
+
+;;; Normal Cases
+
+(ert-deftest test-browser-config-preferred-default-skips-leading-builtin ()
+  "Normal: an installed external browser wins over a built-in listed first."
+  (should (equal (cj/--preferred-default-browser
+                  (list test-browser--eww test-browser--chrome))
+                 test-browser--chrome)))
+
+(ert-deftest test-browser-config-preferred-default-keeps-external-order ()
+  "Normal: the FIRST external in list order wins, not merely any external."
+  (should (equal (cj/--preferred-default-browser
+                  (list test-browser--eww test-browser--chrome test-browser--firefox))
+                 test-browser--chrome)))
+
+;;; Boundary Cases
+
+(ert-deftest test-browser-config-preferred-default-builtin-only-falls-back ()
+  "Boundary: with no external installed, the built-in is still chosen."
+  (should (equal (cj/--preferred-default-browser (list test-browser--eww))
+                 test-browser--eww)))
+
+(ert-deftest test-browser-config-preferred-default-external-only ()
+  "Boundary: a list of externals returns the first one."
+  (should (equal (cj/--preferred-default-browser
+                  (list test-browser--firefox test-browser--chrome))
+                 test-browser--firefox)))
+
+(ert-deftest test-browser-config-preferred-default-empty-list-is-nil ()
+  "Boundary: an empty discovery result yields nil, never an error."
+  (should (null (cj/--preferred-default-browser '()))))
+
+(ert-deftest test-browser-config-preferred-default-single-builtin ()
+  "Boundary: a one-element built-in list returns that element."
+  (should (equal (cj/--preferred-default-browser (list test-browser--eww))
+                 test-browser--eww)))
+
+;;; Error Cases
+
+(ert-deftest test-browser-config-preferred-default-missing-executable-key ()
+  "Error: a plist with no :executable key counts as built-in, not a crash."
+  (let ((malformed '(:name "Odd" :function ignore)))
+    (should (equal (cj/--preferred-default-browser
+                    (list malformed test-browser--chrome))
+                   test-browser--chrome))
+    (should (equal (cj/--preferred-default-browser (list malformed))
+                   malformed))))
+
+(provide 'test-browser-config--preferred-default)
+;;; test-browser-config--preferred-default.el ends here
diff --git a/tests/test-calibredb-epub-config--epub-mode.el b/tests/test-calibredb-epub-config--epub-mode.el
new file mode 100644
index 00000000..a65bdabf
--- /dev/null
+++ b/tests/test-calibredb-epub-config--epub-mode.el
@@ -0,0 +1,70 @@
+;;; test-calibredb-epub-config--epub-mode.el --- Tests for epub mode resolution -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests that .epub files reach nov-mode through `auto-mode-alist' alone, with
+;; no advice on `set-auto-mode'.
+;;
+;; Background: the module used to carry an :around advice on `set-auto-mode'
+;; forcing nov-mode for .epub, added to keep `magic-fallback-mode-alist' from
+;; opening the zip container in archive-mode.  It was never needed.
+;; `set-auto-mode' consults `auto-mode-alist' before `magic-fallback-mode-alist',
+;; and nov's use-package :mode registers "\\.epub\\'" there, so the alist
+;; already won.  Verified live on the daemon: a real zip-format .epub opened in
+;; nov-mode both with the advice and with it removed.
+;;
+;; The advice was not free.  `set-auto-mode' runs on every file visit, so the
+;; advice put a redundant frame and an extra failure surface on the path for
+;; every file of every type.
+;;
+;; The second test is a regression guard: it fails if the advice is ever
+;; reinstated, which is the mistake this cleanup exists to prevent.
+;;
+;; Test organization:
+;; - Normal Cases: .epub resolves to nov-mode; no advice on set-auto-mode
+;; - Boundary Cases: a path merely containing "epub", and a bare "epub" name
+;; - Error Cases: an unrelated extension does not resolve to nov-mode
+;;
+;;; Code:
+
+(require 'ert)
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'calibredb-epub-config)
+
+(defun test-epub-mode--resolve (filename)
+  "Return the major mode `auto-mode-alist' assigns to FILENAME."
+  (assoc-default filename auto-mode-alist 'string-match))
+
+;;; Normal Cases
+
+(ert-deftest test-calibredb-epub-config-epub-resolves-to-nov-mode ()
+  "Normal: auto-mode-alist maps a .epub file to nov-mode on its own."
+  (should (eq 'nov-mode (test-epub-mode--resolve "book.epub"))))
+
+(ert-deftest test-calibredb-epub-config-no-set-auto-mode-advice ()
+  "Normal: nothing advises set-auto-mode to force nov-mode.
+Regression guard.  auto-mode-alist already wins over
+magic-fallback-mode-alist, so an advice here would be redundant work on
+every file visit."
+  (should-not (advice-member-p 'cj/force-nov-mode-for-epub 'set-auto-mode))
+  (should-not (fboundp 'cj/force-nov-mode-for-epub)))
+
+;;; Boundary Cases
+
+(ert-deftest test-calibredb-epub-config-epub-in-directory-name ()
+  "Boundary: the extension anchors at the end, so a directory named epub
+does not by itself select nov-mode."
+  (should-not (eq 'nov-mode (test-epub-mode--resolve "/home/user/epub/notes.txt"))))
+
+(ert-deftest test-calibredb-epub-config-epub-with-path ()
+  "Boundary: a full path with directories still resolves on the extension."
+  (should (eq 'nov-mode (test-epub-mode--resolve "/home/user/books/a b.epub"))))
+
+;;; Error Cases
+
+(ert-deftest test-calibredb-epub-config-other-extension-not-nov ()
+  "Error: an unrelated extension must not resolve to nov-mode."
+  (should-not (eq 'nov-mode (test-epub-mode--resolve "archive.zip")))
+  (should-not (eq 'nov-mode (test-epub-mode--resolve "notes.org"))))
+
+(provide 'test-calibredb-epub-config--epub-mode)
+;;; test-calibredb-epub-config--epub-mode.el ends here
diff --git a/tests/test-calibredb-epub-config.el b/tests/test-calibredb-epub-config.el
index 71581d4c..7afc58f3 100644
--- a/tests/test-calibredb-epub-config.el
+++ b/tests/test-calibredb-epub-config.el
@@ -285,57 +285,6 @@ so the search buffer rebuilds against the now-unfiltered set."
       (cj/calibredb-clear-filters))
     (should (equal "" passed))))
 
-;;; --------------------------- cj/force-nov-mode-for-epub ---------------------
-
-(ert-deftest test-calibredb-epub-force-nov-mode-on-epub-calls-nov-mode ()
-  "Normal: a .epub buffer with nov-mode bound dispatches to `nov-mode' and
-does not fall through to the original mode dispatcher."
-  (skip-unless (fboundp 'nov-mode))
-  (let (orig-called nov-called)
-    (cl-letf (((symbol-function 'nov-mode)
-               (lambda () (setq nov-called t))))
-      (with-temp-buffer
-        (setq buffer-file-name "/tmp/sample.epub")
-        (cj/force-nov-mode-for-epub
-         (lambda (&rest _) (setq orig-called t)))))
-    (should nov-called)
-    (should-not orig-called)))
-
-(ert-deftest test-calibredb-epub-force-nov-mode-passes-through-non-epub ()
-  "Boundary: a non-epub buffer falls through to the original mode dispatcher."
-  (let (orig-called)
-    (with-temp-buffer
-      (setq buffer-file-name "/tmp/sample.txt")
-      (cj/force-nov-mode-for-epub
-       (lambda (&rest _) (setq orig-called t))))
-    (should orig-called)))
-
-(ert-deftest test-calibredb-epub-force-nov-mode-passes-through-no-filename ()
-  "Boundary: a buffer with no associated filename falls through to the
-original mode dispatcher."
-  (let (orig-called)
-    (with-temp-buffer
-      (cj/force-nov-mode-for-epub
-       (lambda (&rest _) (setq orig-called t))))
-    (should orig-called)))
-
-(ert-deftest test-calibredb-epub-force-nov-mode-passes-through-when-nov-missing ()
-  "Error: a .epub buffer falls through to the original dispatcher when nov-mode
-is not defined (the require failed and there is nothing to dispatch to)."
-  (let ((saved (and (fboundp 'nov-mode) (symbol-function 'nov-mode)))
-        orig-called)
-    (when saved (fmakunbound 'nov-mode))
-    (unwind-protect
-        (cl-letf (((symbol-function 'require)
-                   ;; Pretend the (require 'nov nil t) call fails too.
-                   (lambda (&rest _) nil)))
-          (with-temp-buffer
-            (setq buffer-file-name "/tmp/sample.epub")
-            (cj/force-nov-mode-for-epub
-             (lambda (&rest _) (setq orig-called t)))))
-      (when saved (fset 'nov-mode saved)))
-    (should orig-called)))
-
 ;;; ---------------------------- cj/nov--metadata-get --------------------------
 
 (ert-deftest test-calibredb-epub-metadata-get-symbol-key ()
diff --git a/tests/test-help-utils--arch-wiki-search.el b/tests/test-help-utils--arch-wiki-search.el
new file mode 100644
index 00000000..d02dd041
--- /dev/null
+++ b/tests/test-help-utils--arch-wiki-search.el
@@ -0,0 +1,124 @@
+;;; test-help-utils--arch-wiki-search.el --- Tests for the ArchWiki search guard -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Tests for cj/--arch-wiki-topics and the cj/local-arch-wiki-search command.
+;;
+;; The bug: the command read "/usr/share/doc/arch-wiki/html/en" with
+;; `directory-files' before checking the directory existed.  On a machine
+;; without arch-wiki-docs -- the exact state the command's own error text is
+;; written for -- that signaled file-missing on the first line, so the friendly
+;; "Is arch-wiki-docs installed?" message below it was unreachable.  The user
+;; got a raw Lisp error naming a path instead of the install hint.
+;;
+;; Two things had to change to make this testable.  The directory was
+;; hardcoded inside the command, so a test could only ever exercise whatever
+;; the developer's own machine happened to have installed; it is now
+;; `cj/arch-wiki-html-dir'.  And the directory read is now the pure helper
+;; cj/--arch-wiki-topics, which takes a directory and returns an alist, so the
+;; interesting cases are driven with real temporary directories instead of
+;; mocking `directory-files'.
+;;
+;; Test organization:
+;; - Normal Cases: topics found and returned; the command opens the choice
+;; - Boundary Cases: empty dir, single topic, a name matching no topic
+;; - Error Cases: missing dir returns nil and reports the install hint
+;;
+;;; Code:
+
+(require 'ert)
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'help-utils)
+
+(defmacro test-arch-wiki--with-topics (dir-var topics &rest body)
+  "Bind DIR-VAR to a temp dir holding TOPICS (a list of html basenames).
+The directory is removed after BODY."
+  (declare (indent 2))
+  `(let ((,dir-var (make-temp-file "arch-wiki-test" t)))
+     (unwind-protect
+         (progn
+           (dolist (name ,topics)
+             (write-region "" nil (expand-file-name (concat name ".html") ,dir-var)))
+           ,@body)
+       (delete-directory ,dir-var t))))
+
+;;; Normal Cases — the pure helper
+
+(ert-deftest test-help-utils-arch-wiki-topics-lists-html-basenames ()
+  "Normal: each .html file becomes a (basename . fullpath) pair."
+  (test-arch-wiki--with-topics dir '("Systemd" "Pacman")
+    (let ((topics (cj/--arch-wiki-topics dir)))
+      (should (equal '("Pacman" "Systemd") (sort (mapcar #'car topics) #'string<)))
+      (should (string-suffix-p "Systemd.html" (cdr (assoc "Systemd" topics)))))))
+
+(ert-deftest test-help-utils-arch-wiki-topics-ignores-non-html ()
+  "Normal: files without the .html extension are not topics."
+  (test-arch-wiki--with-topics dir '("Systemd")
+    (write-region "" nil (expand-file-name "README.txt" dir))
+    (should (equal '("Systemd") (mapcar #'car (cj/--arch-wiki-topics dir))))))
+
+;;; Boundary Cases
+
+(ert-deftest test-help-utils-arch-wiki-topics-empty-dir-is-nil ()
+  "Boundary: an existing but empty directory yields no topics."
+  (test-arch-wiki--with-topics dir '()
+    (should (null (cj/--arch-wiki-topics dir)))))
+
+(ert-deftest test-help-utils-arch-wiki-topics-single-topic ()
+  "Boundary: one topic returns a one-element alist."
+  (test-arch-wiki--with-topics dir '("Systemd")
+    (should (= 1 (length (cj/--arch-wiki-topics dir))))))
+
+;;; Error Cases — the missing-install path
+
+(ert-deftest test-help-utils-arch-wiki-topics-missing-dir-returns-nil ()
+  "Error: an absent directory returns nil rather than signaling file-missing."
+  (let ((missing (expand-file-name "definitely-absent-arch-wiki"
+                                   temporary-file-directory)))
+    (should-not (file-directory-p missing))
+    (should (null (cj/--arch-wiki-topics missing)))))
+
+(ert-deftest test-help-utils-arch-wiki-search-missing-dir-reports-hint ()
+  "Error: the command reports the install hint and opens nothing."
+  (let ((cj/arch-wiki-html-dir (expand-file-name "definitely-absent-arch-wiki"
+                                                 temporary-file-directory))
+        (said nil)
+        (opened nil))
+    (cl-letf (((symbol-function 'message)
+               (lambda (fmt &rest args) (setq said (apply #'format fmt args)) nil))
+              ((symbol-function 'eww-browse-url)
+               (lambda (url &rest _) (setq opened url))))
+      ;; Must not signal: this is the case that used to raise file-missing.
+      (cj/local-arch-wiki-search))
+    (should-not opened)
+    (should (string-match-p "arch-wiki-docs" said))))
+
+;;; Normal Cases — the command
+
+(ert-deftest test-help-utils-arch-wiki-search-opens-chosen-topic ()
+  "Normal: the chosen topic is opened as a file URL in EWW."
+  (test-arch-wiki--with-topics dir '("Systemd")
+    (let ((cj/arch-wiki-html-dir dir)
+          (opened nil))
+      (cl-letf (((symbol-function 'completing-read) (lambda (&rest _) "Systemd"))
+                ((symbol-function 'eww-browse-url)
+                 (lambda (url &rest _) (setq opened url))))
+        (cj/local-arch-wiki-search))
+      (should (string-prefix-p "file://" opened))
+      (should (string-suffix-p "Systemd.html" opened))
+      ;; The opened path is the one in the temp dir, not a system copy.
+      (should (string-match-p (regexp-quote dir) opened)))))
+
+(ert-deftest test-help-utils-arch-wiki-search-unknown-topic-opens-nothing ()
+  "Boundary: a name matching no topic reports rather than opening."
+  (test-arch-wiki--with-topics dir '("Systemd")
+    (let ((cj/arch-wiki-html-dir dir)
+          (opened nil))
+      (cl-letf (((symbol-function 'completing-read) (lambda (&rest _) "NotATopic"))
+                ((symbol-function 'message) (lambda (&rest _) nil))
+                ((symbol-function 'eww-browse-url)
+                 (lambda (url &rest _) (setq opened url))))
+        (cj/local-arch-wiki-search))
+      (should-not opened))))
+
+(provide 'test-help-utils--arch-wiki-search)
+;;; test-help-utils--arch-wiki-search.el ends here
diff --git a/tests/test-hugo-config--keymap.el b/tests/test-hugo-config--keymap.el
new file mode 100644
index 00000000..0f8df257
--- /dev/null
+++ b/tests/test-hugo-config--keymap.el
@@ -0,0 +1,71 @@
+;;; test-hugo-config--keymap.el --- Tests for the Hugo prefix keymap -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Pins the eight Hugo commands reachable under the "C-; h" prefix.
+;;
+;; The module used to install these with eight raw `global-set-key' calls plus
+;; a hand-written which-key block, writing into the global map directly instead
+;; of going through `cj/register-prefix-map' the way its siblings
+;; (erc-config, custom-ordering, org-reveal-config) do.  These tests were added
+;; alongside that conversion so the refactor is checkable: every key must still
+;; reach the same command afterward.
+;;
+;; Test organization:
+;; - Normal Cases: each of the eight keys resolves to its command
+;; - Boundary Cases: case-distinct pairs stay distinct; the map is a prefix map
+;; - Error Cases: an unbound key in the map resolves to nothing
+;;
+;;; Code:
+
+(require 'ert)
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(provide 'ox-hugo)
+(require 'hugo-config)
+(require 'keybindings)
+
+(defconst test-hugo--expected-bindings
+  '(("n" . cj/hugo-new-post)
+    ("e" . cj/hugo-export-post)
+    ("o" . cj/hugo-open-blog-dir)
+    ("O" . cj/hugo-open-blog-dir-external)
+    ("d" . cj/hugo-open-draft)
+    ("D" . cj/hugo-toggle-draft)
+    ("p" . cj/hugo-preview)
+    ("P" . cj/hugo-publish))
+  "Every key the Hugo prefix map must carry, and the command it runs.")
+
+;;; Normal Cases
+
+(ert-deftest test-hugo-config-keymap-binds-every-command ()
+  "Normal: each Hugo key resolves to its command inside the prefix map."
+  (dolist (pair test-hugo--expected-bindings)
+    (should (eq (cdr pair) (keymap-lookup cj/hugo-keymap (car pair))))))
+
+(ert-deftest test-hugo-config-keymap-registered-under-custom-prefix ()
+  "Normal: the map is reachable at \"h\" within `cj/custom-keymap'."
+  (should (eq cj/hugo-keymap (keymap-lookup cj/custom-keymap "h"))))
+
+;;; Boundary Cases
+
+(ert-deftest test-hugo-config-keymap-case-pairs-stay-distinct ()
+  "Boundary: the shifted variants run different commands than their lowercase
+counterparts, which a case-folding binding would silently collapse."
+  (should-not (eq (keymap-lookup cj/hugo-keymap "o")
+                  (keymap-lookup cj/hugo-keymap "O")))
+  (should-not (eq (keymap-lookup cj/hugo-keymap "d")
+                  (keymap-lookup cj/hugo-keymap "D")))
+  (should-not (eq (keymap-lookup cj/hugo-keymap "p")
+                  (keymap-lookup cj/hugo-keymap "P"))))
+
+(ert-deftest test-hugo-config-keymap-is-a-keymap ()
+  "Boundary: the value registered as a prefix is an actual keymap."
+  (should (keymapp cj/hugo-keymap)))
+
+;;; Error Cases
+
+(ert-deftest test-hugo-config-keymap-unbound-key-is-nil ()
+  "Error: a key the map does not define resolves to nothing."
+  (should-not (keymap-lookup cj/hugo-keymap "z")))
+
+(provide 'test-hugo-config--keymap)
+;;; test-hugo-config--keymap.el ends here
diff --git a/tests/test-integration-recording-device-workflow.el b/tests/test-integration-recording-device-workflow.el
index 3ef631f3..27ffac56 100644
--- a/tests/test-integration-recording-device-workflow.el
+++ b/tests/test-integration-recording-device-workflow.el
@@ -1,26 +1,24 @@
 ;;; test-integration-recording-device-workflow.el --- Integration tests for recording device workflow -*- lexical-binding: t; -*-
 
 ;;; Commentary:
-;; Integration tests covering the complete device detection and grouping workflow.
-;;
-;; This tests the full pipeline from raw pactl output through parsing, grouping,
-;; and friendly name assignment. The workflow enables users to select audio devices
-;; for recording calls/meetings.
+;; Integration test covering the device detection path that recording actually
+;; uses: raw pactl output through parsing and into friendly state names.
 ;;
 ;; Components integrated:
 ;; - cj/recording--parse-pactl-output (parse raw pactl output into structured data)
-;; - cj/recording-parse-sources (shell command wrapper)
-;; - cj/recording-group-devices-by-hardware (group inputs/monitors by device)
+;; - cj/recording-parse-sources (shell command wrapper, MOCKED at
+;;   shell-command-to-string so no pactl runs)
 ;; - cj/recording-friendly-state (convert technical state names)
-;; - Bluetooth MAC address normalization (colons → underscores)
-;; - Device name pattern matching (USB, PCI, Bluetooth)
-;; - Friendly name assignment (user-facing device names)
 ;;
 ;; Critical integration points:
-;; - Parse output must produce data that group-devices can process
-;; - Bluetooth MAC normalization must work across parse→group boundary
-;; - Incomplete devices (only mic OR only monitor) must be filtered
-;; - Friendly names must correctly identify device types
+;; - Parse output must carry device state through to the friendly-name conversion
+;;
+;; This file once covered a parse-to-group pipeline as well.  That half tested
+;; cj/recording-group-devices-by-hardware, a second device-grouping
+;; implementation nothing ever called -- cj/recording-select-device is the live
+;; selection path and reaches parse-sources directly.  The function and its
+;; tests were removed rather than left as coverage that proved an unused code
+;; path worked.
 
 ;;; Code:
 
@@ -46,58 +44,6 @@
 
 ;;; Normal Cases - Complete Workflow
 
-(ert-deftest test-integration-recording-device-workflow-parse-to-group-all-devices ()
-  "Test complete workflow from pactl output to grouped devices.
-
-When pactl output contains all three device types (built-in, USB, Bluetooth),
-the workflow should parse, group, and assign friendly names to all devices.
-
-Components integrated:
-- cj/recording--parse-pactl-output (parsing)
-- cj/recording-group-devices-by-hardware (grouping + MAC normalization)
-- Device pattern matching (USB/PCI/Bluetooth detection)
-- Friendly name assignment
-
-Validates:
-- All three device types are detected
-- Bluetooth MAC addresses normalized (colons → underscores)
-- Each device has both mic and monitor
-- Friendly names correctly assigned
-- Complete data flow: raw output → parsed list → grouped pairs"
-  (let ((output (test-load-fixture "pactl-output-normal.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      ;; Test parse step
-      (let ((parsed (cj/recording-parse-sources)))
-        (should (= 6 (length parsed)))
-
-        ;; Test group step (receives parsed data)
-        (let ((grouped (cj/recording-group-devices-by-hardware)))
-          (should (= 3 (length grouped)))
-
-          ;; Validate built-in device
-          (let ((built-in (assoc "Built-in Audio" grouped)))
-            (should built-in)
-            (should (string-prefix-p "alsa_input.pci" (cadr built-in)))
-            (should (string-prefix-p "alsa_output.pci" (cddr built-in))))
-
-          ;; Validate USB device
-          (let ((usb (assoc "Jabra SPEAK 510 USB" grouped)))
-            (should usb)
-            (should (string-match-p "Jabra" (cadr usb)))
-            (should (string-match-p "Jabra" (cddr usb))))
-
-          ;; Validate Bluetooth device (CRITICAL: MAC normalization)
-          (let ((bluetooth (assoc "Bluetooth Headset" grouped)))
-            (should bluetooth)
-            ;; Input has colons
-            (should (string-match-p "00:1B:66:C0:91:6D" (cadr bluetooth)))
-            ;; Output has underscores
-            (should (string-match-p "00_1B_66_C0_91_6D" (cddr bluetooth)))
-            ;; But they're grouped together!
-            (should (equal "bluez_input.00:1B:66:C0:91:6D" (cadr bluetooth)))
-            (should (equal "bluez_output.00_1B_66_C0_91_6D.1.monitor" (cddr bluetooth)))))))))
-
 (ert-deftest test-integration-recording-device-workflow-friendly-states-in-list ()
   "Test that friendly state names appear in device list output.
 
@@ -128,105 +74,5 @@ Validates:
 
 ;;; Boundary Cases - Incomplete Devices
 
-(ert-deftest test-integration-recording-device-workflow-incomplete-devices-filtered ()
-  "Test that devices with only mic OR only monitor are filtered out.
-
-For call recording, we need BOTH mic and monitor from the same device.
-Incomplete devices should not appear in the grouped output.
-
-Components integrated:
-- cj/recording-parse-sources (parsing all devices)
-- cj/recording-group-devices-by-hardware (filtering incomplete pairs)
-
-Validates:
-- Device with only mic is filtered
-- Device with only monitor is filtered
-- Only complete devices (both mic and monitor) are returned
-- Filtering happens at group stage, not parse stage"
-  (let ((output (concat
-                 ;; Complete device
-                 "50\talsa_input.pci-0000_00_1f.3.analog-stereo\tPipeWire\ts32le 2ch 48000Hz\tSUSPENDED\n"
-                 "49\talsa_output.pci-0000_00_1f.3.analog-stereo.monitor\tPipeWire\ts32le 2ch 48000Hz\tSUSPENDED\n"
-                 ;; Incomplete: USB mic with no monitor
-                 "100\talsa_input.usb-device.mono-fallback\tPipeWire\ts16le 1ch 16000Hz\tSUSPENDED\n"
-                 ;; Incomplete: Bluetooth monitor with no mic
-                 "81\tbluez_output.AA_BB_CC_DD_EE_FF.1.monitor\tPipeWire\ts24le 2ch 48000Hz\tRUNNING\n")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      ;; Parse sees all 4 devices
-      (let ((parsed (cj/recording-parse-sources)))
-        (should (= 4 (length parsed)))
-
-        ;; Group returns only 1 complete device
-        (let ((grouped (cj/recording-group-devices-by-hardware)))
-          (should (= 1 (length grouped)))
-          (should (equal "Built-in Audio" (caar grouped))))))))
-
-;;; Edge Cases - Bluetooth MAC Normalization
-
-(ert-deftest test-integration-recording-device-workflow-bluetooth-mac-variations ()
-  "Test Bluetooth MAC normalization with different formats.
-
-Bluetooth devices use colons in input names but underscores in output names.
-The grouping must normalize these to match devices correctly.
-
-Components integrated:
-- cj/recording-parse-sources (preserves original MAC format)
-- cj/recording-group-devices-by-hardware (normalizes MAC for matching)
-- Base name extraction (regex patterns)
-- MAC address transformation (underscores → colons)
-
-Validates:
-- Input with colons (bluez_input.AA:BB:CC:DD:EE:FF) parsed correctly
-- Output with underscores (bluez_output.AA_BB_CC_DD_EE_FF) parsed correctly
-- Normalization happens during grouping
-- Devices paired despite format difference
-- Original device names preserved (not mutated)"
-  (let ((output (concat
-                 "79\tbluez_input.11:22:33:44:55:66\tPipeWire\tfloat32le 1ch 48000Hz\tSUSPENDED\n"
-                 "81\tbluez_output.11_22_33_44_55_66.1.monitor\tPipeWire\ts24le 2ch 48000Hz\tRUNNING\n")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((parsed (cj/recording-parse-sources)))
-        ;; Original formats preserved in parse
-        (should (string-match-p "11:22:33" (caar parsed)))
-        (should (string-match-p "11_22_33" (caadr parsed)))
-
-        ;; But grouping matches them
-        (let ((grouped (cj/recording-group-devices-by-hardware)))
-          (should (= 1 (length grouped)))
-          (should (equal "Bluetooth Headset" (caar grouped)))
-          ;; Original names preserved
-          (should (equal "bluez_input.11:22:33:44:55:66" (cadar grouped)))
-          (should (equal "bluez_output.11_22_33_44_55_66.1.monitor" (cddar grouped))))))))
-
-;;; Error Cases - Malformed Data
-
-(ert-deftest test-integration-recording-device-workflow-malformed-output-handled ()
-  "Test that malformed pactl output is handled gracefully.
-
-When pactl output is malformed or unparseable, the workflow should not crash.
-It should return empty results at appropriate stages.
-
-Components integrated:
-- cj/recording--parse-pactl-output (malformed line handling)
-- cj/recording-group-devices-by-hardware (empty input handling)
-
-Validates:
-- Malformed lines are silently skipped during parse
-- Empty parse results don't crash grouping
-- Workflow degrades gracefully
-- No exceptions thrown"
-  (let ((output (test-load-fixture "pactl-output-malformed.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((parsed (cj/recording-parse-sources)))
-        ;; Malformed output produces empty parse
-        (should (null parsed))
-
-        ;; Empty parse produces empty grouping (no crash)
-        (let ((grouped (cj/recording-group-devices-by-hardware)))
-          (should (null grouped)))))))
-
 (provide 'test-integration-recording-device-workflow)
 ;;; test-integration-recording-device-workflow.el ends here
diff --git a/tests/test-media-utils--yt-dl-message.el b/tests/test-media-utils--yt-dl-message.el
new file mode 100644
index 00000000..491b64cf
--- /dev/null
+++ b/tests/test-media-utils--yt-dl-message.el
@@ -0,0 +1,64 @@
+;;; test-media-utils--yt-dl-message.el --- Tests for the yt-dl sentinel message -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Unit tests for cj/media--yt-dl-message, the pure helper behind
+;; cj/yt-dl-it's process sentinel.
+;;
+;; The behavior under test is a correctness fix, not cosmetics.  cj/yt-dl-it
+;; launches "tsp yt-dlp ...", and tsp enqueues the job and exits immediately.
+;; The sentinel therefore fires on tsp's exit, not on yt-dlp's, so the old
+;; "Finished downloading" text claimed a completed download at the moment the
+;; download was merely queued -- and a yt-dlp failure minutes later was silent.
+;; The helper reports queueing, which is the only thing tsp's exit actually
+;; proves.
+;;
+;; Test organization:
+;; - Normal Cases: clean tsp exit reports queued; abnormal exit reports failure
+;; - Boundary Cases: unrelated events return nil; URL text passes through verbatim
+;; - Error Cases: empty event string returns nil
+;;
+;;; Code:
+
+(require 'ert)
+(require 'media-utils)
+
+;;; Normal Cases
+
+(ert-deftest test-media-utils--yt-dl-message-normal-finished-says-queued ()
+  "Normal: a clean tsp exit reports the job queued, never downloaded."
+  (let ((msg (cj/media--yt-dl-message "finished\n" "https://example.com/v")))
+    (should (string-match-p "[Qq]ueued" msg))
+    (should-not (string-match-p "[Ff]inished downloading" msg))))
+
+(ert-deftest test-media-utils--yt-dl-message-normal-abnormal-reports-failure ()
+  "Normal: an abnormal tsp exit reports that queueing failed."
+  (let ((msg (cj/media--yt-dl-message "exited abnormally with code 1\n"
+                                      "https://example.com/v")))
+    (should msg)
+    (should-not (string-match-p "[Qq]ueued for" msg))))
+
+;;; Boundary Cases
+
+(ert-deftest test-media-utils--yt-dl-message-boundary-unrelated-event-is-nil ()
+  "Boundary: an event that reports neither outcome produces no message."
+  (should (null (cj/media--yt-dl-message "run\n" "https://example.com/v")))
+  (should (null (cj/media--yt-dl-message "stopped\n" "https://example.com/v"))))
+
+(ert-deftest test-media-utils--yt-dl-message-boundary-url-passes-through ()
+  "Boundary: the URL text is carried into the message verbatim."
+  (let ((url "https://example.com/watch?v=a&b=c%20d"))
+    (should (string-match-p (regexp-quote url)
+                            (cj/media--yt-dl-message "finished\n" url)))))
+
+(ert-deftest test-media-utils--yt-dl-message-boundary-empty-url ()
+  "Boundary: an empty URL still yields a message rather than signaling."
+  (should (stringp (cj/media--yt-dl-message "finished\n" ""))))
+
+;;; Error Cases
+
+(ert-deftest test-media-utils--yt-dl-message-error-empty-event-is-nil ()
+  "Error: an empty event string matches no outcome and returns nil."
+  (should (null (cj/media--yt-dl-message "" "https://example.com/v"))))
+
+(provide 'test-media-utils--yt-dl-message)
+;;; test-media-utils--yt-dl-message.el ends here
diff --git a/tests/test-video-audio-recording-group-devices-by-hardware.el b/tests/test-video-audio-recording-group-devices-by-hardware.el
deleted file mode 100644
index 2be4982f..00000000
--- a/tests/test-video-audio-recording-group-devices-by-hardware.el
+++ /dev/null
@@ -1,194 +0,0 @@
-;;; test-video-audio-recording-group-devices-by-hardware.el --- Tests for cj/recording-group-devices-by-hardware -*- lexical-binding: t; -*-
-
-;;; Commentary:
-;; Unit tests for cj/recording-group-devices-by-hardware function.
-;; Tests grouping of audio sources by physical hardware device.
-;; Critical test: Bluetooth MAC address normalization (colons vs underscores).
-;;
-;; This function is used by the quick setup command to automatically pair
-;; microphone and monitor devices from the same hardware.
-
-;;; Code:
-
-(require 'ert)
-
-;; Stub dependencies before loading the module
-(defvar cj/custom-keymap (make-sparse-keymap)
-  "Stub keymap for testing.")
-
-;; Now load the actual production module
-(require 'video-audio-recording)
-
-;;; Test Fixtures Helper
-
-(defun test-load-fixture (filename)
-  "Load fixture file FILENAME from tests/fixtures directory."
-  (let ((fixture-path (expand-file-name
-                       (concat "tests/fixtures/" filename)
-                       user-emacs-directory)))
-    (with-temp-buffer
-      (insert-file-contents fixture-path)
-      (buffer-string))))
-
-;;; Normal Cases
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-normal-all-types-grouped ()
-  "Test grouping of all three device types (built-in, USB, Bluetooth).
-This is the key test validating the complete grouping logic."
-  (let ((output (test-load-fixture "pactl-output-normal.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (listp result))
-        (should (= 3 (length result)))
-        ;; Check that we have all three device types
-        (let ((names (mapcar #'car result)))
-          (should (member "Built-in Audio" names))
-          (should (member "Bluetooth Headset" names))
-          (should (member "Jabra SPEAK 510 USB" names)))
-        ;; Verify each device has both mic and monitor
-        (dolist (device result)
-          (should (stringp (car device)))           ; friendly name
-          (should (stringp (cadr device)))          ; mic device
-          (should (stringp (cddr device)))          ; monitor device
-          (should-not (string-suffix-p ".monitor" (cadr device)))  ; mic not monitor
-          (should (string-suffix-p ".monitor" (cddr device))))))))  ; monitor has suffix
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-normal-built-in-paired ()
-  "Test that built-in laptop audio devices are correctly paired."
-  (let ((output (test-load-fixture "pactl-output-normal.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let* ((result (cj/recording-group-devices-by-hardware))
-             (built-in (assoc "Built-in Audio" result)))
-        (should built-in)
-        (should (string-match-p "pci-0000_00_1f" (cadr built-in)))
-        (should (string-match-p "pci-0000_00_1f" (cddr built-in)))
-        (should (equal "alsa_input.pci-0000_00_1f.3.analog-stereo" (cadr built-in)))
-        (should (equal "alsa_output.pci-0000_00_1f.3.analog-stereo.monitor" (cddr built-in)))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-normal-usb-paired ()
-  "Test that USB devices (Jabra) are correctly paired."
-  (let ((output (test-load-fixture "pactl-output-normal.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let* ((result (cj/recording-group-devices-by-hardware))
-             (jabra (assoc "Jabra SPEAK 510 USB" result)))
-        (should jabra)
-        (should (string-match-p "Jabra" (cadr jabra)))
-        (should (string-match-p "Jabra" (cddr jabra)))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-normal-bluetooth-paired ()
-  "Test that Bluetooth devices are correctly paired.
-CRITICAL: Tests MAC address normalization (colons in input, underscores in output)."
-  (let ((output (test-load-fixture "pactl-output-normal.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let* ((result (cj/recording-group-devices-by-hardware))
-             (bluetooth (assoc "Bluetooth Headset" result)))
-        (should bluetooth)
-        ;; Input has colons: bluez_input.00:1B:66:C0:91:6D
-        (should (equal "bluez_input.00:1B:66:C0:91:6D" (cadr bluetooth)))
-        ;; Output has underscores: bluez_output.00_1B_66_C0_91_6D.1.monitor
-        ;; But they should still be grouped together (MAC address normalized)
-        (should (equal "bluez_output.00_1B_66_C0_91_6D.1.monitor" (cddr bluetooth)))))))
-
-;;; Boundary Cases
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-boundary-empty-returns-empty ()
-  "Test that empty pactl output returns empty list."
-  (cl-letf (((symbol-function 'shell-command-to-string)
-             (lambda (_cmd) "")))
-    (let ((result (cj/recording-group-devices-by-hardware)))
-      (should (listp result))
-      (should (null result)))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-boundary-only-inputs-returns-empty ()
-  "Test that only input devices (no monitors) returns empty list.
-Devices must have BOTH mic and monitor to be included."
-  (let ((output (test-load-fixture "pactl-output-inputs-only.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (listp result))
-        (should (null result))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-boundary-only-monitors-returns-empty ()
-  "Test that only monitor devices (no inputs) returns empty list."
-  (let ((output (test-load-fixture "pactl-output-monitors-only.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (listp result))
-        (should (null result))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-boundary-single-complete-device ()
-  "Test that single device with both mic and monitor is returned."
-  (let ((output "50\talsa_input.pci-0000_00_1f.3.analog-stereo\tPipeWire\ts32le 2ch 48000Hz\tSUSPENDED\n49\talsa_output.pci-0000_00_1f.3.analog-stereo.monitor\tPipeWire\ts32le 2ch 48000Hz\tSUSPENDED\n"))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (= 1 (length result)))
-        (should (equal "Built-in Audio" (caar result)))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-boundary-mixed-complete-incomplete ()
-  "Test that only devices with BOTH mic and monitor are included.
-Incomplete devices (only mic or only monitor) are filtered out."
-  (let ((output (concat
-                 ;; Complete device (built-in)
-                 "50\talsa_input.pci-0000_00_1f.3.analog-stereo\tPipeWire\ts32le 2ch 48000Hz\tSUSPENDED\n"
-                 "49\talsa_output.pci-0000_00_1f.3.analog-stereo.monitor\tPipeWire\ts32le 2ch 48000Hz\tSUSPENDED\n"
-                 ;; Incomplete: USB mic with no monitor
-                 "100\talsa_input.usb-device.mono-fallback\tPipeWire\ts16le 1ch 16000Hz\tSUSPENDED\n"
-                 ;; Incomplete: Bluetooth monitor with no mic
-                 "81\tbluez_output.AA_BB_CC_DD_EE_FF.1.monitor\tPipeWire\ts24le 2ch 48000Hz\tRUNNING\n")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        ;; Only the complete built-in device should be returned
-        (should (= 1 (length result)))
-        (should (equal "Built-in Audio" (caar result)))))))
-
-;;; Error Cases
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-error-malformed-output-returns-empty ()
-  "Test that malformed pactl output returns empty list."
-  (let ((output (test-load-fixture "pactl-output-malformed.txt")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (listp result))
-        (should (null result))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-error-unknown-device-type ()
-  "Test that unknown device types get generic 'USB Audio Device' name."
-  (let ((output (concat
-                 "100\talsa_input.usb-unknown_device-00.analog-stereo\tPipeWire\ts16le 2ch 16000Hz\tSUSPENDED\n"
-                 "99\talsa_output.usb-unknown_device-00.analog-stereo.monitor\tPipeWire\ts16le 2ch 48000Hz\tSUSPENDED\n")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (= 1 (length result)))
-        ;; Should get generic USB name (not matching Jabra pattern)
-        (should (equal "USB Audio Device" (caar result)))))))
-
-(ert-deftest test-video-audio-recording-group-devices-by-hardware-error-bluetooth-mac-case-variations ()
-  "Test that Bluetooth MAC addresses work with different formatting.
-Tests the normalization logic handles various MAC address formats."
-  (let ((output (concat
-                 ;; Input with colons (typical)
-                 "79\tbluez_input.AA:BB:CC:DD:EE:FF\tPipeWire\tfloat32le 1ch 48000Hz\tSUSPENDED\n"
-                 ;; Output with underscores (typical)
-                 "81\tbluez_output.AA_BB_CC_DD_EE_FF.1.monitor\tPipeWire\ts24le 2ch 48000Hz\tRUNNING\n")))
-    (cl-letf (((symbol-function 'shell-command-to-string)
-               (lambda (_cmd) output)))
-      (let ((result (cj/recording-group-devices-by-hardware)))
-        (should (= 1 (length result)))
-        (should (equal "Bluetooth Headset" (caar result)))
-        ;; Verify both devices paired despite different MAC formats
-        (let ((device (car result)))
-          (should (string-match-p "AA:BB:CC" (cadr device)))
-          (should (string-match-p "AA_BB_CC" (cddr device))))))))
-
-(provide 'test-video-audio-recording-group-devices-by-hardware)
-;;; test-video-audio-recording-group-devices-by-hardware.el ends here
diff --git a/tests/test-wrap-up--bury-buffers.el b/tests/test-wrap-up--bury-buffers.el
new file mode 100644
index 00000000..00df69c7
--- /dev/null
+++ b/tests/test-wrap-up--bury-buffers.el
@@ -0,0 +1,96 @@
+;;; test-wrap-up--bury-buffers.el --- Tests for cj/bury-buffers -*- lexical-binding: t; -*-
+
+;;; Commentary:
+;; Characterization tests for cj/bury-buffers, which buries the noisy
+;; compile-and-shell buffers at the end of startup.
+;;
+;; Written to pin the buried set while a dead clause was removed.  The function
+;; tested `(derived-mode-p 'elisp-compile-mode)', and no such mode exists in
+;; Emacs -- the real one is `emacs-lisp-compilation-mode', which derives from
+;; `compilation-mode' and so was already matched by the clause above it.  The
+;; clause could never be true, and removing it must not change which buffers
+;; get buried.  These tests are what makes that claim checkable.
+;;
+;; Test organization:
+;; - Normal Cases: each buried mode is buried; byte-compilation output included
+;; - Boundary Cases: an ordinary buffer is left alone; an empty buffer list
+;; - Error Cases: a killed buffer in the list does not break the sweep
+;;
+;;; Code:
+
+(require 'ert)
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'wrap-up)
+
+;; Required explicitly so each test stands alone.  Without these the
+;; comint-mode test passed only because ERT runs tests in alphabetical order
+;; and an earlier test loaded `compile', which pulls in comint -- so renaming
+;; or running that test by itself made it fail with void-function comint-mode.
+(require 'comint)
+(require 'bytecomp)
+
+(defmacro test-wrap-up--with-mode-buffer (mode &rest body)
+  "Create a buffer in MODE, bind it to `buf', run BODY, then kill it."
+  (declare (indent 1))
+  `(let ((buf (generate-new-buffer "*test-bury*")))
+     (unwind-protect
+         (progn
+           (with-current-buffer buf (funcall ,mode))
+           ,@body)
+       (kill-buffer buf))))
+
+;;; Normal Cases
+
+(ert-deftest test-wrap-up-bury-buffers-buries-compilation ()
+  "Normal: a compilation-mode buffer is buried."
+  (test-wrap-up--with-mode-buffer #'compilation-mode
+    (switch-to-buffer buf)
+    (cj/bury-buffers)
+    (should-not (eq buf (car (buffer-list))))))
+
+(ert-deftest test-wrap-up-bury-buffers-buries-byte-compilation-output ()
+  "Normal: the real byte-compilation mode is buried.
+`emacs-lisp-compilation-mode' derives from `compilation-mode', which is
+why the never-matching elisp-compile-mode clause was redundant."
+  (should (eq 'compilation-mode
+              (get 'emacs-lisp-compilation-mode 'derived-mode-parent)))
+  (test-wrap-up--with-mode-buffer #'emacs-lisp-compilation-mode
+    (switch-to-buffer buf)
+    (cj/bury-buffers)
+    (should-not (eq buf (car (buffer-list))))))
+
+(ert-deftest test-wrap-up-bury-buffers-buries-comint ()
+  "Normal: a comint-mode buffer is buried."
+  (test-wrap-up--with-mode-buffer #'comint-mode
+    (switch-to-buffer buf)
+    (cj/bury-buffers)
+    (should-not (eq buf (car (buffer-list))))))
+
+;;; Boundary Cases
+
+(ert-deftest test-wrap-up-bury-buffers-leaves-ordinary-buffer ()
+  "Boundary: a fundamental-mode buffer is not buried."
+  (test-wrap-up--with-mode-buffer #'fundamental-mode
+    (switch-to-buffer buf)
+    (cj/bury-buffers)
+    (should (eq buf (car (buffer-list))))))
+
+(ert-deftest test-wrap-up-bury-buffers-leaves-text-buffer ()
+  "Boundary: an ordinary text-mode buffer is not buried."
+  (test-wrap-up--with-mode-buffer #'text-mode
+    (switch-to-buffer buf)
+    (cj/bury-buffers)
+    (should (eq buf (car (buffer-list))))))
+
+;;; Error Cases
+
+(ert-deftest test-wrap-up-bury-buffers-survives-dead-mode-name ()
+  "Error: the sweep completes even though elisp-compile-mode does not exist.
+The removed clause named a mode Emacs has never defined; this pins that
+the function still runs cleanly with no such mode anywhere."
+  (should-not (fboundp 'elisp-compile-mode))
+  (should-not (get 'elisp-compile-mode 'derived-mode-parent))
+  (cj/bury-buffers))
+
+(provide 'test-wrap-up--bury-buffers)
+;;; test-wrap-up--bury-buffers.el ends here