fix(dev): repair hunk jump, F4 hook leak, async clone, and nil guards

- vc-config: C-; v d matched literal +/- source text via consult-line, not gutter hunks. It now completes over git-gutter's hunk list and jumps to the chosen line.
- vc-config: clipboard clone ran git synchronously, freezing every frame for the whole clone. It now runs async with a sentinel that opens the clone on success and surfaces the process buffer on failure.
- vc-config: magit-blame bound D and S to the same command. D is now difftastic-magit-diff, matching the transient.
- vc-config: dropped the :commands autoload for git-timemachine-show-selected-revision, a function the package never defined. The phantom appeared in M-x and errored.
- dev-fkeys: both F4 chained-compile handlers armed a hook on the global compilation-finish-functions before their compile ran, so a quit left it live and the next unrelated compile fired the chain. The one-shot hook now installs buffer-locally in the compilation buffer, same shape as the projectile cache-revert hooks.
- test-runner: outside a project with no global test directory, three commands crashed with wrong-type-argument on a nil path. Discovery now returns nil and the commands signal user-error.
- diff-config: removed the global "-w" ediff default, which made every session ignore whitespace (indentation-only changes compared as identical). Whitespace-ignore stays available as ediff's per-session toggle.
- restclient-config: the C-; R bindings went through raw global-set-key, silently depending on keybindings.el loading first. They now use a prefix keymap registered like the other C-; prefixes.
- httpd-config: simple-httpd loaded on a 1s timer and created www/ on every startup. It now defers until impatient-mode needs it, and the doc root is created at package load.

16 files changed, 628 insertions, 139 deletions

diff --git a/modules/dev-fkeys.el b/modules/dev-fkeys.el
index 80b43600..0f120a8d 100644
--- a/modules/dev-fkeys.el
+++ b/modules/dev-fkeys.el
@@ -82,13 +82,25 @@ recognized markers both return nil."
 
 ;; ---------- Action handlers ----------
 
+(defun cj/--f4-install-once-hook (buffer then-fn)
+  "Install a one-shot buffer-local compilation finish hook in BUFFER.
+Installing in the compilation buffer itself (rather than globally)
+means a quit before the compile starts, or an unrelated concurrent
+compile, can never fire the chained THEN-FN.  No-op when BUFFER is not
+a live buffer."
+  (when (buffer-live-p buffer)
+    (with-current-buffer buffer
+      (add-hook 'compilation-finish-functions
+                (cj/--f4-make-once-hook then-fn) nil t))))
+
 (defun cj/--f4-compile-and-run-impl ()
   "Run `projectile-compile-project', then `projectile-run-project' on success.
-Installs a one-shot `compilation-finish-functions' hook to chain the run."
-  (add-hook 'compilation-finish-functions
-            (cj/--f4-make-once-hook
-             (lambda () (projectile-run-project nil))))
-  (projectile-compile-project nil))
+Chains the run via a one-shot finish hook installed buffer-locally in
+the compilation buffer projectile returns."
+  (let ((result (projectile-compile-project nil)))
+    (cj/--f4-install-once-hook
+     (cj/--projectile-compilation-buffer result)
+     (lambda () (projectile-run-project nil)))))
 
 (defun cj/--f4-dispatch (action)
   "Route ACTION (a symbol from `cj/--f4-candidates') to its handler.
@@ -109,24 +121,26 @@ command (prompted-and-cached by projectile) drives the build."
   (let ((clean-cmd (cj/--f4-derive-clean-cmd root)))
     (unless clean-cmd
       (user-error "Clean + Rebuild: no clean command for this project type"))
-    (add-hook 'compilation-finish-functions
-              (cj/--f4-make-once-hook
-               (lambda () (projectile-compile-project nil))))
-    (let ((default-directory root))
-      (compile clean-cmd))))
+    (let* ((default-directory root)
+           (buffer (compile clean-cmd)))
+      (cj/--f4-install-once-hook
+       buffer (lambda () (projectile-compile-project nil))))))
 
 ;; ---------- One-shot compilation-finish hook ----------
 
 (defun cj/--f4-make-once-hook (then-fn)
   "Build a one-shot `compilation-finish-functions' hook that chains THEN-FN.
 The returned lambda removes itself from `compilation-finish-functions' on
-first invocation regardless of status, then calls THEN-FN only if the
-status string starts with \"finished\" (the convention used by compile.el
-for a successful compile)."
+first invocation regardless of status — from both the global value and
+the running buffer's local value, so it is one-shot wherever it was
+installed — then calls THEN-FN only if the status string starts with
+\"finished\" (the convention used by compile.el for a successful
+compile)."
   (let (hook)
     (setq hook
           (lambda (_buf status)
             (remove-hook 'compilation-finish-functions hook)
+            (remove-hook 'compilation-finish-functions hook t)
             (when (and (stringp status)
                        (string-prefix-p "finished" status))
               (funcall then-fn))))
diff --git a/modules/diff-config.el b/modules/diff-config.el
index 0c09b951..75911587 100644
--- a/modules/diff-config.el
+++ b/modules/diff-config.el
@@ -40,7 +40,6 @@
   :custom
   (ediff-window-setup-function  'ediff-setup-windows-plain)
   (ediff-split-window-function  'split-window-horizontally)
-  (ediff-diff-options            "-w")
   (ediff-highlight-all-diffs    nil)
   :bind-keymap ("C-c D" . cj/ediff-map)
   :init
diff --git a/modules/httpd-config.el b/modules/httpd-config.el
index 1a2a5c61..a3ae0fac 100644
--- a/modules/httpd-config.el
+++ b/modules/httpd-config.el
@@ -5,8 +5,9 @@
 ;;
 ;; Layer: 4 (Optional).
 ;; Category: O/D/P.
-;; Load shape: eager.
-;; Eager reason: none; local web server, a command-loaded deferral candidate.
+;; Load shape: deferred.
+;; Defer reason: impatient-mode requires simple-httpd on demand; nothing
+;; needs the server (or its www/ root) at startup.
 ;; Top-level side effects: package configuration via use-package.
 ;; Runtime requires: none.
 ;; Direct test load: yes.
@@ -17,14 +18,15 @@
 ;;;; -------------------------- Simple-Httpd -------------------------
 
 (use-package simple-httpd
-  :defer 1
+  :defer t
   :preface
   (defconst cj/httpd-wwwdir (concat user-emacs-directory "www"))
   (defun cj/httpd-check-or-create-wwwdir ()
     (unless (file-exists-p cj/httpd-wwwdir)
       (make-directory cj/httpd-wwwdir)))
-  :init (cj/httpd-check-or-create-wwwdir)
   :config
+  ;; Create the doc root only when the server package actually loads.
+  (cj/httpd-check-or-create-wwwdir)
   (setq httpd-root cj/httpd-wwwdir)
   (setq httpd-show-backtrace-when-error t)
   (setq httpd-serve-files t))
diff --git a/modules/restclient-config.el b/modules/restclient-config.el
index 0511eddb..497f54d0 100644
--- a/modules/restclient-config.el
+++ b/modules/restclient-config.el
@@ -8,7 +8,7 @@
 ;; Load shape: eager.
 ;; Eager reason: none; API exploration, a command-loaded deferral candidate.
 ;; Top-level side effects: package configuration via use-package.
-;; Runtime requires: none (configures packages via use-package).
+;; Runtime requires: keybindings (C-; R prefix registration).
 ;; Direct test load: yes.
 ;;
 ;; Integrates restclient.el for interactive API exploration from within Emacs.
@@ -23,6 +23,8 @@
 
 ;;; Code:
 
+(require 'keybindings)  ;; cj/register-prefix-map
+
 ;; --------------------------------- Constants ---------------------------------
 
 (defvar cj/restclient-data-dir (expand-file-name "data/" user-emacs-directory)
@@ -61,12 +63,15 @@
 
 ;; -------------------------------- Keybindings --------------------------------
 
-(global-set-key (kbd "C-; R n") #'cj/restclient-new-buffer)
-(global-set-key (kbd "C-; R o") #'cj/restclient-open-file)
+(defvar-keymap cj/restclient-map
+  :doc "Keymap for restclient operations"
+  "n" #'cj/restclient-new-buffer
+  "o" #'cj/restclient-open-file)
+
+(cj/register-prefix-map "R" cj/restclient-map "REST client")
 
 (with-eval-after-load 'which-key
   (which-key-add-key-based-replacements
-    "C-; R" "REST client"
     "C-; R n" "new scratch buffer"
     "C-; R o" "open .rest file"))
 
diff --git a/modules/test-runner.el b/modules/test-runner.el
index 7f157f1c..6cb35275 100644
--- a/modules/test-runner.el
+++ b/modules/test-runner.el
@@ -139,9 +139,11 @@ if not found or not in a project."
 		 (t cj/test-global-directory))))))
 
 (defun cj/test--get-test-files ()
-  "Return list of test file names (without path) in test directory."
+  "Return list of test file names (without path) in test directory.
+Returns nil when no test directory is available (outside a project
+with `cj/test-global-directory' unset)."
   (let ((dir (cj/test--get-test-directory)))
-	(when (file-directory-p dir)
+	(when (and dir (file-directory-p dir))
 	  (mapcar #'file-name-nondirectory
 			  (directory-files dir t "^test-.*\\.el$")))))
 
@@ -169,6 +171,8 @@ Returns: (cons \\='success loaded-count) on success,
   (interactive)
   (cj/test--ensure-test-dir-in-load-path)
   (let ((dir (cj/test--get-test-directory)))
+	(unless dir
+	  (user-error "No test directory: not in a project and cj/test-global-directory is unset"))
 	(unless (file-directory-p dir)
 	  (user-error "Test directory %s does not exist" dir))
 	(let ((test-files (directory-files dir t "^test-.*\\.el$")))
@@ -200,11 +204,12 @@ Returns: \\='success if added successfully,
   (cj/test--ensure-test-dir-in-load-path)
   (let* ((focused-files (cj/test--current-focused-files))
          (dir (cj/test--get-test-directory))
-		 (available-files (when (file-directory-p dir)
+		 (available-files (when (and dir (file-directory-p dir))
 							(mapcar #'file-name-nondirectory
 									(directory-files dir t "^test-.*\\.el$")))))
 	(if (null available-files)
-		(user-error "No test files found in %s" dir)
+		(user-error "No test files found in %s"
+					(or dir "any test directory (not in a project)"))
 	  (let* ((unfocused-files (cl-set-difference available-files
 												 focused-files
 												 :test #'string=))
diff --git a/modules/vc-config.el b/modules/vc-config.el
index 60fcaeb8..3da9266f 100644
--- a/modules/vc-config.el
+++ b/modules/vc-config.el
@@ -37,9 +37,13 @@
 (defvar forge-pull-notifications)
 (defvar forge-topic-list-limit)
 
+;; External package variables (buffer-local hunk list from git-gutter).
+(defvar git-gutter:diffinfos)
+
 ;; External package functions (from lazily-loaded packages).
 (declare-function git-gutter:next-hunk "git-gutter")
 (declare-function git-gutter:previous-hunk "git-gutter")
+(declare-function git-gutter-hunk-start-line "git-gutter")
 (declare-function git-timemachine--start "git-timemachine")
 (declare-function git-timemachine--revisions "git-timemachine")
 (declare-function git-timemachine-show-revision "git-timemachine")
@@ -100,8 +104,7 @@
 
 (use-package git-timemachine
   :commands (git-timemachine
-			 git-timemachine-show-revision
-			 git-timemachine-show-selected-revision)
+			 git-timemachine-show-revision)
   :init
   (defun cj/git-timemachine-show-selected-revision ()
   "Displays git revisions of file in chronological order adding metadata."
@@ -157,13 +160,33 @@
 	  (forge-create-issue)
 	(user-error "Not in a forge repository")))
 
+(defun cj/--git-gutter-hunk-candidates (start-lines)
+  "Build completion candidates for hunk START-LINES in the current buffer.
+Each candidate is a cons of a \"LINE: text\" label and the line number."
+  (mapcar (lambda (line)
+            (cons (format "%4d: %s" line
+                          (save-excursion
+                            (goto-char (point-min))
+                            (forward-line (1- line))
+                            (buffer-substring-no-properties
+                             (line-beginning-position) (line-end-position))))
+                  line))
+          start-lines))
+
 (defun cj/goto-git-gutter-diff-hunks ()
-  "Jump to git-gutter diff hunks using consult.
-Searches for lines starting with + or - (diff markers) and allows
-interactive selection to jump to any changed line in the buffer."
+  "Jump to a git-gutter hunk in the current buffer chosen with completion."
   (interactive)
   (require 'git-gutter)
-  (consult-line "^[+\\-]"))
+  (let ((candidates (cj/--git-gutter-hunk-candidates
+                     (mapcar #'git-gutter-hunk-start-line
+                             (and (boundp 'git-gutter:diffinfos)
+                                  git-gutter:diffinfos)))))
+    (unless candidates
+      (user-error "No git-gutter hunks in this buffer"))
+    (let ((line (cdr (assoc (completing-read "Hunk: " candidates nil t)
+                            candidates))))
+      (goto-char (point-min))
+      (forward-line (1- line)))))
 
 ;; ------------------------------ Git Clone Clipboard -----------------------------
 ;; Quick git clone from clipboard URL
@@ -180,6 +203,33 @@ scp form."
          (last (car (last (split-string trimmed "[/:]" t)))))
     (and last (file-name-sans-extension last))))
 
+(defun cj/--git-clone-open (clone-dir)
+  "Open CLONE-DIR's README when one exists, else `dired' the directory."
+  (let ((readme (seq-find
+                 (lambda (file)
+                   (string-match-p "\\`README" (upcase file)))
+                 (directory-files clone-dir))))
+    (if readme
+        (find-file (expand-file-name readme clone-dir))
+      (dired clone-dir))))
+
+(defun cj/--git-clone-make-sentinel (url clone-dir)
+  "Return a sentinel reporting the git clone of URL into CLONE-DIR.
+On a zero exit the sentinel announces success and opens the clone; on
+any other exit or a signal it surfaces the process buffer."
+  (lambda (process _event)
+    (when (memq (process-status process) '(exit signal))
+      (if (and (eq (process-status process) 'exit)
+               (zerop (process-exit-status process)))
+          (progn
+            (message "Cloned %s into %s" url clone-dir)
+            (cj/--git-clone-open clone-dir))
+        (let ((buf (process-buffer process)))
+          (when (buffer-live-p buf)
+            (pop-to-buffer buf))
+          (message "git clone of %s failed (status %s)"
+                   url (process-exit-status process)))))))
+
 (defun cj/git-clone-clipboard-url (url target-dir)
   "Clone git repository from clipboard URL to TARGET-DIR.
 
@@ -187,11 +237,13 @@ With no prefix argument: uses first directory in `cj/git-clone-dirs'.
 With \\[universal-argument]: choose from `cj/git-clone-dirs'.
 With \\[universal-argument] \\[universal-argument]: choose any directory.
 
-Clones with a direct `git' process (no shell), into a path derived
-robustly from URL.  Aborts with a clear message when the clipboard is
-empty, the target is not a writable directory, the destination already
-exists, or `git' exits non-zero.  After a successful clone, opens the
-repository's README if found, else `dired's the clone."
+Clones with a direct asynchronous `git' process (no shell, no frozen
+frames), into a path derived robustly from URL.  Aborts with a clear
+message when the clipboard is empty, the target is not a writable
+directory, or the destination already exists.  The process sentinel
+reports the result: on success it opens the repository's README if
+found (else `dired's the clone); on failure it surfaces the process
+buffer."
   (interactive
    (list (current-kill 0)  ;; Get URL from clipboard
          (cond
@@ -219,21 +271,14 @@ repository's README if found, else `dired's the clone."
       (when (file-exists-p clone-dir)
         (user-error "Clone destination already exists: %s" clone-dir))
       (message "Cloning %s into %s..." url clone-dir)
-      ;; Direct process, no shell.  `--' stops option parsing so a URL
-      ;; beginning with `-' can't be read as a git flag.
-      (let ((status (call-process "git" nil "*git-clone*" nil
-                                  "clone" "--" url clone-dir)))
-        (unless (zerop status)
-          (pop-to-buffer "*git-clone*")
-          (user-error "git clone failed (exit %d); see *git-clone*" status)))
-      ;; Find and open README
-      (let ((readme (seq-find
-                     (lambda (file)
-                       (string-match-p "\\`README" (upcase file)))
-                     (directory-files clone-dir))))
-        (if readme
-            (find-file (expand-file-name readme clone-dir))
-          (dired clone-dir))))))
+      ;; Direct async process, no shell, so no emacsclient frame blocks
+      ;; for the duration of the clone.  `--' stops option parsing so a
+      ;; URL beginning with `-' can't be read as a git flag.
+      (make-process
+       :name "git-clone"
+       :buffer "*git-clone*"
+       :command (list "git" "clone" "--" url clone-dir)
+       :sentinel (cj/--git-clone-make-sentinel url clone-dir)))))
 
 ;; -------------------------------- Difftastic ---------------------------------
 ;; Structural diffs for better git change visualization
@@ -243,7 +288,7 @@ repository's README if found, else `dired's the clone."
   :defer t
   :commands (difftastic-magit-diff difftastic-magit-show)
   :bind (:map magit-blame-read-only-mode-map
-              ("D" . difftastic-magit-show)
+              ("D" . difftastic-magit-diff)
               ("S" . difftastic-magit-show))
   :config
   (eval-after-load 'magit-diff
diff --git a/tests/test-dev-fkeys--f4-clean-rebuild-impl.el b/tests/test-dev-fkeys--f4-clean-rebuild-impl.el
index 27c7c56a..bed51d79 100644
--- a/tests/test-dev-fkeys--f4-clean-rebuild-impl.el
+++ b/tests/test-dev-fkeys--f4-clean-rebuild-impl.el
@@ -3,7 +3,11 @@
 ;;; Commentary:
 ;; Tests for the "Clean + Rebuild" action handler. Runs the heuristic clean
 ;; command via `compile' from the project root, then chains
-;; `projectile-compile-project' on success via the one-shot finish hook.
+;; `projectile-compile-project' on success via a one-shot finish hook
+;; installed buffer-locally in the compilation buffer `compile' returns.
+;; The global `compilation-finish-functions' is never touched, so a quit
+;; before the compile starts or an unrelated concurrent compile can never
+;; fire the chained rebuild.
 
 ;;; Code:
 
@@ -24,6 +28,18 @@ Bind the dir path to ROOT in BODY. Cleans up on exit."
            ,@body)
        (delete-directory root t))))
 
+(defmacro test-dev-fkeys-cr--with-compilation-buffer (buf &rest body)
+  "Run BODY with BUF bound to a temp buffer standing in for a compilation buffer."
+  (declare (indent 1))
+  `(let ((,buf (generate-new-buffer " *test-compilation*")))
+     (unwind-protect
+         (progn ,@body)
+       (kill-buffer ,buf))))
+
+(defun test-dev-fkeys-cr--local-hooks (buf)
+  "Return the buffer-local finish hooks of BUF, without the t marker."
+  (remq t (buffer-local-value 'compilation-finish-functions buf)))
+
 ;;; Normal Cases
 
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-runs-derived-clean-cmd ()
@@ -34,48 +50,50 @@ Components integrated:
 - `cj/--f4-clean-rebuild-impl' (unit under test)
 - `cj/--f4-derive-clean-cmd' (real)
 - `compile' (MOCKED — captures the command string)
-- `projectile-compile-project' (MOCKED — no-op)
-- `compilation-finish-functions' (real, scoped via let)"
+- `projectile-compile-project' (MOCKED — no-op)"
   (test-dev-fkeys-cr--with-project '("Makefile")
-    (let ((compile-calls nil)
-          (compilation-finish-functions nil))
+    (let ((compile-calls nil))
       (cl-letf (((symbol-function 'compile)
-                 (lambda (cmd) (push cmd compile-calls)))
+                 (lambda (cmd) (push cmd compile-calls) nil))
                 ((symbol-function 'projectile-compile-project)
                  (lambda (_arg) nil)))
         (cj/--f4-clean-rebuild-impl root)
         (should (equal compile-calls '("make clean")))))))
 
-(ert-deftest test-dev-fkeys-clean-rebuild-impl-installs-finish-hook ()
-  "Normal: handler installs exactly one hook in `compilation-finish-functions'."
+(ert-deftest test-dev-fkeys-clean-rebuild-impl-installs-hook-in-compilation-buffer ()
+  "Normal: the one-shot hook lands buffer-locally in the buffer `compile'
+returns; the global `compilation-finish-functions' stays untouched."
   (test-dev-fkeys-cr--with-project '("go.mod")
-    (let ((compilation-finish-functions nil))
-      (cl-letf (((symbol-function 'compile) (lambda (_cmd) nil))
-                ((symbol-function 'projectile-compile-project)
-                 (lambda (_arg) nil)))
-        (cj/--f4-clean-rebuild-impl root)
-        (should (= (length compilation-finish-functions) 1))))))
+    (test-dev-fkeys-cr--with-compilation-buffer buf
+      (let ((compilation-finish-functions nil))
+        (cl-letf (((symbol-function 'compile) (lambda (_cmd) buf))
+                  ((symbol-function 'projectile-compile-project)
+                   (lambda (_arg) nil)))
+          (cj/--f4-clean-rebuild-impl root)
+          (should (null compilation-finish-functions))
+          (should (= 1 (length (test-dev-fkeys-cr--local-hooks buf)))))))))
 
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-hook-runs-projectile-compile-on-success ()
-  "Normal: when the clean step finishes successfully, the installed hook
+  "Normal: when the clean step finishes successfully, the buffer-local hook
 calls `projectile-compile-project' to do the rebuild."
   (test-dev-fkeys-cr--with-project '("Cargo.toml")
-    (let ((compile-calls 0)
-          (compilation-finish-functions nil))
-      (cl-letf (((symbol-function 'compile) (lambda (_cmd) nil))
-                ((symbol-function 'projectile-compile-project)
-                 (lambda (_arg) (cl-incf compile-calls))))
-        (cj/--f4-clean-rebuild-impl root)
-        (run-hook-with-args 'compilation-finish-functions nil "finished\n")
-        (should (= compile-calls 1))))))
+    (test-dev-fkeys-cr--with-compilation-buffer buf
+      (let ((compile-calls 0)
+            (compilation-finish-functions nil))
+        (cl-letf (((symbol-function 'compile) (lambda (_cmd) buf))
+                  ((symbol-function 'projectile-compile-project)
+                   (lambda (_arg) (cl-incf compile-calls))))
+          (cj/--f4-clean-rebuild-impl root)
+          (with-current-buffer buf
+            (run-hook-with-args 'compilation-finish-functions buf "finished\n"))
+          (should (= compile-calls 1)))))))
 
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-runs-clean-from-project-root ()
   "Normal: the clean compile runs with default-directory bound to ROOT."
   (test-dev-fkeys-cr--with-project '("Eask")
-    (let ((seen-dir nil)
-          (compilation-finish-functions nil))
+    (let ((seen-dir nil))
       (cl-letf (((symbol-function 'compile)
-                 (lambda (_cmd) (setq seen-dir default-directory)))
+                 (lambda (_cmd) (setq seen-dir default-directory) nil))
                 ((symbol-function 'projectile-compile-project)
                  (lambda (_arg) nil)))
         (cj/--f4-clean-rebuild-impl root)
@@ -87,14 +105,28 @@ calls `projectile-compile-project' to do the rebuild."
 (ert-deftest test-dev-fkeys-clean-rebuild-impl-hook-skips-rebuild-on-failure ()
   "Boundary: when the clean step fails, projectile-compile-project does not run."
   (test-dev-fkeys-cr--with-project '("Makefile")
-    (let ((compile-calls 0)
-          (compilation-finish-functions nil))
+    (test-dev-fkeys-cr--with-compilation-buffer buf
+      (let ((compile-calls 0)
+            (compilation-finish-functions nil))
+        (cl-letf (((symbol-function 'compile) (lambda (_cmd) buf))
+                  ((symbol-function 'projectile-compile-project)
+                   (lambda (_arg) (cl-incf compile-calls))))
+          (cj/--f4-clean-rebuild-impl root)
+          (with-current-buffer buf
+            (run-hook-with-args 'compilation-finish-functions
+                                buf "exited abnormally\n"))
+          (should (= compile-calls 0)))))))
+
+(ert-deftest test-dev-fkeys-clean-rebuild-impl-dead-compile-buffer-no-global-hook ()
+  "Boundary: when `compile' returns no live buffer, nothing is installed
+anywhere — the global hook list stays empty."
+  (test-dev-fkeys-cr--with-project '("Makefile")
+    (let ((compilation-finish-functions nil))
       (cl-letf (((symbol-function 'compile) (lambda (_cmd) nil))
                 ((symbol-function 'projectile-compile-project)
-                 (lambda (_arg) (cl-incf compile-calls))))
+                 (lambda (_arg) nil)))
         (cj/--f4-clean-rebuild-impl root)
-        (run-hook-with-args 'compilation-finish-functions nil "exited abnormally\n")
-        (should (= compile-calls 0))))))
+        (should (null compilation-finish-functions))))))
 
 ;;; Error Cases
 
diff --git a/tests/test-dev-fkeys--f4-compile-and-run-impl.el b/tests/test-dev-fkeys--f4-compile-and-run-impl.el
index d59a6cd6..34e5bdf3 100644
--- a/tests/test-dev-fkeys--f4-compile-and-run-impl.el
+++ b/tests/test-dev-fkeys--f4-compile-and-run-impl.el
@@ -2,8 +2,11 @@
 
 ;;; Commentary:
 ;; Tests for the "Compile + Run" action handler. After kicking off the
-;; compile, attaches a one-shot `compilation-finish-functions' hook that
-;; runs the project on success.
+;; compile, attaches a one-shot finish hook buffer-locally in the
+;; compilation buffer projectile returns, so the global
+;; `compilation-finish-functions' is never touched.  A quit at
+;; projectile's compile prompt therefore can never leave an armed hook
+;; that a later unrelated compile would fire.
 
 ;;; Code:
 
@@ -12,6 +15,14 @@
 (add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
 (require 'dev-fkeys)
 
+(defmacro test-dev-fkeys-car--with-buffer (buf &rest body)
+  "Run BODY with BUF bound to a temp buffer standing in for a compilation buffer."
+  (declare (indent 1))
+  `(let ((,buf (generate-new-buffer " *test-compilation*")))
+     (unwind-protect
+         (progn ,@body)
+       (kill-buffer ,buf))))
+
 ;;; Normal Cases
 
 (ert-deftest test-dev-fkeys-compile-and-run-impl-invokes-projectile-compile ()
@@ -19,57 +30,77 @@
 
 Components integrated:
 - `cj/--f4-compile-and-run-impl' (unit under test)
-- `projectile-compile-project' (MOCKED via cl-letf)
-- `compilation-finish-functions' (real, scoped via let)"
-  (let ((compile-calls 0)
-        (compilation-finish-functions nil))
+- `projectile-compile-project' (MOCKED via cl-letf)"
+  (let ((compile-calls 0))
     (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) (cl-incf compile-calls))))
+               (lambda (_arg) (cl-incf compile-calls) nil)))
       (cj/--f4-compile-and-run-impl)
       (should (= compile-calls 1)))))
 
-(ert-deftest test-dev-fkeys-compile-and-run-impl-installs-finish-hook ()
-  "Normal: handler installs exactly one hook in `compilation-finish-functions'."
-  (let ((compilation-finish-functions nil))
-    (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) nil)))
-      (cj/--f4-compile-and-run-impl)
-      (should (= (length compilation-finish-functions) 1)))))
+(ert-deftest test-dev-fkeys-compile-and-run-impl-installs-hook-in-compilation-buffer ()
+  "Normal: the one-shot hook lands buffer-locally in the compilation buffer;
+the global `compilation-finish-functions' stays untouched."
+  (test-dev-fkeys-car--with-buffer buf
+    (let ((compilation-finish-functions nil))
+      (cl-letf (((symbol-function 'projectile-compile-project)
+                 (lambda (_arg) buf)))
+        (cj/--f4-compile-and-run-impl)
+        (should (null compilation-finish-functions))
+        (should (= 1 (length (remq t (buffer-local-value
+                                      'compilation-finish-functions buf)))))))))
 
 (ert-deftest test-dev-fkeys-compile-and-run-impl-hook-runs-projectile-run-on-success ()
-  "Normal: when the compile finishes successfully, the installed hook calls
-`projectile-run-project'.
+  "Normal: when the compile finishes successfully, the buffer-local hook
+calls `projectile-run-project'.
 
 Components integrated:
 - `cj/--f4-compile-and-run-impl' (unit under test)
-- `projectile-compile-project' (MOCKED — no-op)
+- `projectile-compile-project' (MOCKED — returns the compilation buffer)
 - `projectile-run-project' (MOCKED — counts calls)
-- `compilation-finish-functions' (real)
+- `compilation-finish-functions' (real, buffer-local)
 - `run-hook-with-args' (real — simulates compile.el firing the hook)"
-  (let ((run-calls 0)
-        (compilation-finish-functions nil))
-    (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) nil))
-              ((symbol-function 'projectile-run-project)
-               (lambda (_arg) (cl-incf run-calls))))
-      (cj/--f4-compile-and-run-impl)
-      (run-hook-with-args 'compilation-finish-functions nil "finished\n")
-      (should (= run-calls 1)))))
+  (test-dev-fkeys-car--with-buffer buf
+    (let ((run-calls 0)
+          (compilation-finish-functions nil))
+      (cl-letf (((symbol-function 'projectile-compile-project)
+                 (lambda (_arg) buf))
+                ((symbol-function 'projectile-run-project)
+                 (lambda (_arg) (cl-incf run-calls))))
+        (cj/--f4-compile-and-run-impl)
+        (with-current-buffer buf
+          (run-hook-with-args 'compilation-finish-functions buf "finished\n"))
+        (should (= run-calls 1))))))
 
 ;;; Boundary Cases
 
 (ert-deftest test-dev-fkeys-compile-and-run-impl-hook-skips-projectile-run-on-failure ()
   "Boundary: when the compile fails, projectile-run-project must not run.
 The hook still self-removes (covered in the make-once-hook tests)."
-  (let ((run-calls 0)
-        (compilation-finish-functions nil))
+  (test-dev-fkeys-car--with-buffer buf
+    (let ((run-calls 0)
+          (compilation-finish-functions nil))
+      (cl-letf (((symbol-function 'projectile-compile-project)
+                 (lambda (_arg) buf))
+                ((symbol-function 'projectile-run-project)
+                 (lambda (_arg) (cl-incf run-calls))))
+        (cj/--f4-compile-and-run-impl)
+        (with-current-buffer buf
+          (run-hook-with-args 'compilation-finish-functions
+                              buf "exited abnormally\n"))
+        (should (= run-calls 0))))))
+
+(ert-deftest test-dev-fkeys-compile-and-run-impl-quit-leaves-no-global-hook ()
+  "Boundary: a quit at projectile's prompt leaves no armed hook anywhere.
+This is the regression the buffer-local install exists to prevent: the
+old shape armed a global hook before the prompt, so C-g left it live and
+the next unrelated compile fired the chained run."
+  (let ((compilation-finish-functions nil))
     (cl-letf (((symbol-function 'projectile-compile-project)
-               (lambda (_arg) nil))
-              ((symbol-function 'projectile-run-project)
-               (lambda (_arg) (cl-incf run-calls))))
-      (cj/--f4-compile-and-run-impl)
-      (run-hook-with-args 'compilation-finish-functions nil "exited abnormally\n")
-      (should (= run-calls 0)))))
+               (lambda (_arg) (signal 'quit nil))))
+      (condition-case nil
+          (cj/--f4-compile-and-run-impl)
+        (quit nil))
+      (should (null compilation-finish-functions)))))
 
 (provide 'test-dev-fkeys--f4-compile-and-run-impl)
 ;;; test-dev-fkeys--f4-compile-and-run-impl.el ends here
diff --git a/tests/test-dev-fkeys--f4-make-once-hook.el b/tests/test-dev-fkeys--f4-make-once-hook.el
index b6c71dd7..4fc84e63 100644
--- a/tests/test-dev-fkeys--f4-make-once-hook.el
+++ b/tests/test-dev-fkeys--f4-make-once-hook.el
@@ -95,6 +95,21 @@ hook exactly once per compile, so the practical contract is one-shot."
       (funcall hook nil "interrupt\n"))
     (should (= called 0))))
 
+(ert-deftest test-dev-fkeys-make-once-hook-removes-itself-buffer-locally ()
+  "Boundary: a hook installed buffer-locally removes its local entry when
+run in that buffer — the shape used by the F4 chained-compile handlers."
+  (let ((buf (generate-new-buffer " *test-once-hook*"))
+        (called 0))
+    (unwind-protect
+        (let ((hook (cj/--f4-make-once-hook (lambda () (cl-incf called)))))
+          (with-current-buffer buf
+            (add-hook 'compilation-finish-functions hook nil t)
+            (funcall hook buf "finished\n")
+            (should-not (memq hook (buffer-local-value
+                                    'compilation-finish-functions buf))))
+          (should (= called 1)))
+      (kill-buffer buf))))
+
 ;;; Error Cases
 
 (ert-deftest test-dev-fkeys-make-once-hook-then-fn-error-still-removes-hook ()
diff --git a/tests/test-diff-config--ediff-options.el b/tests/test-diff-config--ediff-options.el
new file mode 100644
index 00000000..a43637d9
--- /dev/null
+++ b/tests/test-diff-config--ediff-options.el
@@ -0,0 +1,27 @@
+;;; test-diff-config--ediff-options.el --- Tests for ediff diff options -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Pins the removal of the global "-w" default for `ediff-diff-options'.
+;; With "-w", every ediff session ignores ALL whitespace, so
+;; indentation-only changes (significant in Python, Makefiles, YAML)
+;; compare as identical.  Whitespace-ignoring is a per-session toggle
+;; (ediff's `##'), not a global default.
+
+;;; Code:
+
+(require 'ert)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'diff-config)
+
+;;; Normal Cases
+
+(ert-deftest test-diff-config-ediff-options-no-global-whitespace-ignore ()
+  "Normal: after ediff loads, no global -w sits in ediff-diff-options.
+The use-package :custom values apply when the deferred package loads,
+so the assertion must run with ediff actually loaded."
+  (require 'ediff)
+  (should (not (string-match-p "-w" (or ediff-diff-options "")))))
+
+(provide 'test-diff-config--ediff-options)
+;;; test-diff-config--ediff-options.el ends here
diff --git a/tests/test-httpd-config--defer.el b/tests/test-httpd-config--defer.el
new file mode 100644
index 00000000..1a1fbbed
--- /dev/null
+++ b/tests/test-httpd-config--defer.el
@@ -0,0 +1,34 @@
+;;; test-httpd-config--defer.el --- Tests for httpd-config lazy loading -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Pins httpd-config's load-time behavior: merely loading the module must
+;; not create the www directory (that belongs to the moment simple-httpd
+;; actually loads) and must not pull in simple-httpd itself —
+;; impatient-mode requires it on demand.
+
+;;; Code:
+
+(require 'ert)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+
+;;; Boundary Cases
+
+(ert-deftest test-httpd-config-load-creates-no-www-dir ()
+  "Boundary: loading httpd-config does not create www/ in user-emacs-directory."
+  (let* ((sandbox (make-temp-file "httpd-config-test-" t))
+         (user-emacs-directory (file-name-as-directory sandbox)))
+    (unwind-protect
+        (progn
+          (require 'httpd-config)
+          (should-not (file-directory-p
+                       (expand-file-name "www" user-emacs-directory))))
+      (delete-directory sandbox t))))
+
+(ert-deftest test-httpd-config-load-does-not-load-simple-httpd ()
+  "Boundary: loading httpd-config leaves simple-httpd unloaded."
+  (require 'httpd-config)
+  (should-not (featurep 'simple-httpd)))
+
+(provide 'test-httpd-config--defer)
+;;; test-httpd-config--defer.el ends here
diff --git a/tests/test-restclient-config--keymap.el b/tests/test-restclient-config--keymap.el
new file mode 100644
index 00000000..7265c4f3
--- /dev/null
+++ b/tests/test-restclient-config--keymap.el
@@ -0,0 +1,29 @@
+;;; test-restclient-config--keymap.el --- Tests for the restclient prefix keymap -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Pins the C-; R prefix wiring.  The bindings must go through
+;; `cj/restclient-map' + `cj/register-prefix-map' (like the other C-;
+;; prefixes), not raw `global-set-key' calls that silently depend on
+;; keybindings.el having installed C-; first.
+
+;;; Code:
+
+(require 'ert)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'restclient-config)
+
+;;; Normal Cases
+
+(ert-deftest test-restclient-keymap-registered-under-custom-prefix ()
+  "Normal: cj/restclient-map is bound at R inside cj/custom-keymap."
+  (should (boundp 'cj/restclient-map))
+  (should (eq cj/restclient-map (keymap-lookup cj/custom-keymap "R"))))
+
+(ert-deftest test-restclient-keymap-binds-new-buffer-and-open-file ()
+  "Normal: the prefix map carries the two restclient commands."
+  (should (eq #'cj/restclient-new-buffer (keymap-lookup cj/restclient-map "n")))
+  (should (eq #'cj/restclient-open-file (keymap-lookup cj/restclient-map "o"))))
+
+(provide 'test-restclient-config--keymap)
+;;; test-restclient-config--keymap.el ends here
diff --git a/tests/test-test-runner--nil-global-directory.el b/tests/test-test-runner--nil-global-directory.el
new file mode 100644
index 00000000..c70de5bd
--- /dev/null
+++ b/tests/test-test-runner--nil-global-directory.el
@@ -0,0 +1,51 @@
+;;; test-test-runner--nil-global-directory.el --- Tests for the no-test-directory path -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Outside a Projectile project, `cj/test--get-test-directory' falls back
+;; to `cj/test-global-directory', which defaults to nil.  These tests pin
+;; the contract for that nil case: discovery helpers return nil instead
+;; of crashing on (file-directory-p nil), and the interactive commands
+;; signal `user-error' instead of wrong-type-argument.
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'test-runner)
+
+(defmacro test-runner-nil-dir--outside-project (&rest body)
+  "Run BODY with no project root and a nil `cj/test-global-directory'."
+  (declare (indent 0))
+  `(let ((cj/test-global-directory nil))
+     (cl-letf (((symbol-function 'cj/test--project-root)
+                (lambda () nil)))
+       ,@body)))
+
+;;; Boundary Cases
+
+(ert-deftest test-test-runner-nil-dir-get-test-directory-returns-nil ()
+  "Boundary: no project and no global dir yields nil, not an error."
+  (test-runner-nil-dir--outside-project
+    (should (null (cj/test--get-test-directory)))))
+
+(ert-deftest test-test-runner-nil-dir-get-test-files-returns-nil ()
+  "Boundary: file discovery returns nil instead of crashing on a nil dir."
+  (test-runner-nil-dir--outside-project
+    (should (null (cj/test--get-test-files)))))
+
+;;; Error Cases
+
+(ert-deftest test-test-runner-nil-dir-load-all-signals-user-error ()
+  "Error: `cj/test-load-all' signals `user-error', not wrong-type-argument."
+  (test-runner-nil-dir--outside-project
+    (should-error (cj/test-load-all) :type 'user-error)))
+
+(ert-deftest test-test-runner-nil-dir-focus-add-signals-user-error ()
+  "Error: `cj/test-focus-add' signals `user-error', not wrong-type-argument."
+  (test-runner-nil-dir--outside-project
+    (should-error (cj/test-focus-add) :type 'user-error)))
+
+(provide 'test-test-runner--nil-global-directory)
+;;; test-test-runner--nil-global-directory.el ends here
diff --git a/tests/test-vc-config--git-clone.el b/tests/test-vc-config--git-clone.el
index 3b39ece2..46ce3d40 100644
--- a/tests/test-vc-config--git-clone.el
+++ b/tests/test-vc-config--git-clone.el
@@ -2,9 +2,11 @@
 
 ;;; Commentary:
 ;; Unit tests for cj/--git-clone-dir-name (robust repo-dir derivation across
-;; HTTPS, scp-style SSH, ssh:// and local URLs) and for cj/git-clone-clipboard-url
-;; reporting a failed clone from the process exit status instead of silently
-;; assuming the directory appeared.
+;; HTTPS, scp-style SSH, ssh:// and local URLs), for the async clone process
+;; wiring in cj/git-clone-clipboard-url (make-process argv, no shell), and
+;; for the sentinel built by cj/--git-clone-make-sentinel (open on success,
+;; surface the process buffer on failure).  Sentinel tests drive real
+;; short-lived processes rather than mocking process primitives.
 
 ;;; Code:
 
@@ -14,6 +16,18 @@
 (add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
 (require 'vc-config)
 
+(defun test-vc-clone--run-sentinel (command sentinel buffer)
+  "Run COMMAND with SENTINEL and BUFFER; wait for process exit."
+  (let ((proc (make-process :name "test-vc-clone"
+                            :buffer buffer
+                            :command command
+                            :sentinel sentinel)))
+    (while (process-live-p proc)
+      (accept-process-output proc 0.05))
+    ;; Give the sentinel a chance to run after exit.
+    (accept-process-output nil 0.05)
+    proc))
+
 ;;; cj/--git-clone-dir-name — Normal Cases
 
 (ert-deftest test-vc-git-clone-dir-name-https-with-git-suffix ()
@@ -36,7 +50,7 @@
   (should (equal "repo"
                  (cj/--git-clone-dir-name "ssh://git@example.com/user/repo.git"))))
 
-;;; Boundary Cases
+;;; cj/--git-clone-dir-name — Boundary Cases
 
 (ert-deftest test-vc-git-clone-dir-name-ssh-scp-without-user ()
   "Boundary: scp-style SSH with no user path (host:repo.git) still works.
@@ -60,29 +74,110 @@ since there is no `/' separator."
   (should (equal "repo"
                  (cj/--git-clone-dir-name "  https://example.com/user/repo.git\n"))))
 
-;;; cj/git-clone-clipboard-url — Error Cases
+;;; cj/--git-clone-open — Normal / Boundary Cases
 
-(ert-deftest test-vc-git-clone-clipboard-url-reports-clone-failure ()
-  "Error: a nonzero git exit status surfaces a user-error, not silence.
-Uses a real writable temp dir as the target (so the file predicates run
-for real) and mocks only the clone process to fail."
-  (let ((target (make-temp-file "cj-clone-fail-" t)))
+(ert-deftest test-vc-git-clone-open-finds-readme ()
+  "Normal: a README in the clone is opened."
+  (let ((dir (make-temp-file "cj-clone-open-" t))
+        (opened nil))
+    (unwind-protect
+        (progn
+          (with-temp-file (expand-file-name "README.md" dir) (insert "hi"))
+          (cl-letf (((symbol-function 'find-file)
+                     (lambda (f &rest _) (setq opened f)))
+                    ((symbol-function 'dired) #'ignore))
+            (cj/--git-clone-open dir)
+            (should (equal (expand-file-name "README.md" dir) opened))))
+      (delete-directory dir t))))
+
+(ert-deftest test-vc-git-clone-open-no-readme-dires ()
+  "Boundary: with no README, the clone directory is dired."
+  (let ((dir (make-temp-file "cj-clone-open-" t))
+        (dired-dir nil))
+    (unwind-protect
+        (cl-letf (((symbol-function 'find-file)
+                   (lambda (&rest _) (error "find-file should not run")))
+                  ((symbol-function 'dired)
+                   (lambda (d &rest _) (setq dired-dir d))))
+          (cj/--git-clone-open dir)
+          (should (equal dir dired-dir)))
+      (delete-directory dir t))))
+
+;;; cj/--git-clone-make-sentinel — Normal / Error Cases
+
+(ert-deftest test-vc-git-clone-sentinel-success-opens-clone ()
+  "Normal: a zero-exit clone process opens the clone directory."
+  (let ((buffer (generate-new-buffer " *test-clone-ok*"))
+        (opened nil))
+    (unwind-protect
+        (cl-letf (((symbol-function 'cj/--git-clone-open)
+                   (lambda (d) (setq opened d)))
+                  ((symbol-function 'message) (lambda (&rest _) nil)))
+          (test-vc-clone--run-sentinel
+           '("true") (cj/--git-clone-make-sentinel "url" "/tmp/clone-dst") buffer)
+          (should (equal "/tmp/clone-dst" opened)))
+      (kill-buffer buffer))))
+
+(ert-deftest test-vc-git-clone-sentinel-failure-pops-process-buffer ()
+  "Error: a nonzero exit surfaces the process buffer, never opens the clone."
+  (let ((buffer (generate-new-buffer " *test-clone-fail*"))
+        (opened nil)
+        (popped nil))
     (unwind-protect
-        (cl-letf (((symbol-function 'call-process) (lambda (&rest _) 128))
-                  ((symbol-function 'pop-to-buffer) #'ignore)
-                  ((symbol-function 'message) #'ignore))
-          (should-error
-           (cj/git-clone-clipboard-url "https://example.com/user/repo.git" target)
-           :type 'user-error))
+        (cl-letf (((symbol-function 'cj/--git-clone-open)
+                   (lambda (d) (setq opened d)))
+                  ((symbol-function 'pop-to-buffer)
+                   (lambda (b &rest _) (setq popped b)))
+                  ((symbol-function 'message) (lambda (&rest _) nil)))
+          (test-vc-clone--run-sentinel
+           '("false") (cj/--git-clone-make-sentinel "url" "/tmp/clone-dst") buffer)
+          (should-not opened)
+          (should (eq buffer popped)))
+      (kill-buffer buffer))))
+
+;;; cj/git-clone-clipboard-url — Normal / Error Cases
+
+(ert-deftest test-vc-git-clone-clipboard-url-spawns-async-argv ()
+  "Normal: the clone runs as an async process with a plain argv, no shell.
+The `--' separator must precede the URL so a leading-dash URL cannot be
+read as a git flag."
+  (let ((target (make-temp-file "cj-clone-async-" t))
+        (spawned nil))
+    (unwind-protect
+        (cl-letf (((symbol-function 'make-process)
+                   (lambda (&rest args)
+                     (setq spawned (plist-get args :command))
+                     nil))
+                  ((symbol-function 'message) (lambda (&rest _) nil)))
+          (cj/git-clone-clipboard-url "https://example.com/user/repo.git" target)
+          (should (equal (list "git" "clone" "--"
+                               "https://example.com/user/repo.git"
+                               (expand-file-name "repo" target))
+                         spawned)))
       (delete-directory target t))))
 
 (ert-deftest test-vc-git-clone-clipboard-url-empty-clipboard-errors ()
   "Error: an empty clipboard URL aborts before any clone attempt."
-  (let ((cloned nil))
-    (cl-letf (((symbol-function 'call-process)
-               (lambda (&rest _) (setq cloned t) 0)))
+  (let ((spawned nil))
+    (cl-letf (((symbol-function 'make-process)
+               (lambda (&rest _) (setq spawned t) nil)))
       (should-error (cj/git-clone-clipboard-url "   " "/tmp") :type 'user-error))
-    (should-not cloned)))
+    (should-not spawned)))
+
+(ert-deftest test-vc-git-clone-clipboard-url-existing-destination-errors ()
+  "Error: an existing clone destination aborts before any clone attempt."
+  (let ((target (make-temp-file "cj-clone-exists-" t))
+        (spawned nil))
+    (unwind-protect
+        (progn
+          (make-directory (expand-file-name "repo" target))
+          (cl-letf (((symbol-function 'make-process)
+                     (lambda (&rest _) (setq spawned t) nil)))
+            (should-error
+             (cj/git-clone-clipboard-url "https://example.com/user/repo.git" target)
+             :type 'user-error))
+          (should-not spawned))
+      (delete-directory target t))))
 
 (provide 'test-vc-config--git-clone)
 ;;; test-vc-config--git-clone.el ends here
diff --git a/tests/test-vc-config--gutter-hunk-candidates.el b/tests/test-vc-config--gutter-hunk-candidates.el
new file mode 100644
index 00000000..65db0c3c
--- /dev/null
+++ b/tests/test-vc-config--gutter-hunk-candidates.el
@@ -0,0 +1,69 @@
+;;; test-vc-config--gutter-hunk-candidates.el --- Tests for cj/--git-gutter-hunk-candidates -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Unit tests for cj/--git-gutter-hunk-candidates, the pure helper that
+;; builds completion candidates (label . line) from git-gutter hunk start
+;; lines against the current buffer's text.  The interactive wrapper
+;; cj/goto-git-gutter-diff-hunks maps git-gutter:diffinfos onto start
+;; lines and delegates here.
+
+;;; Code:
+
+(require 'ert)
+(require 'cl-lib)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'vc-config)
+
+;;; Normal Cases
+
+(ert-deftest test-vc-gutter-hunk-candidates-labels-carry-line-text ()
+  "Normal: each candidate label contains the hunk line's text."
+  (with-temp-buffer
+    (insert "alpha\nbravo\ncharlie\n")
+    (let ((candidates (cj/--git-gutter-hunk-candidates '(2 3))))
+      (should (= 2 (length candidates)))
+      (should (string-match-p "bravo" (car (nth 0 candidates))))
+      (should (string-match-p "charlie" (car (nth 1 candidates)))))))
+
+(ert-deftest test-vc-gutter-hunk-candidates-cdr-is-start-line ()
+  "Normal: each candidate's cdr is the hunk's start line number."
+  (with-temp-buffer
+    (insert "alpha\nbravo\ncharlie\n")
+    (let ((candidates (cj/--git-gutter-hunk-candidates '(1 3))))
+      (should (equal '(1 3) (mapcar #'cdr candidates))))))
+
+;;; Boundary Cases
+
+(ert-deftest test-vc-gutter-hunk-candidates-empty-input-returns-nil ()
+  "Boundary: no hunks produce no candidates."
+  (with-temp-buffer
+    (insert "alpha\n")
+    (should (null (cj/--git-gutter-hunk-candidates '())))))
+
+(ert-deftest test-vc-gutter-hunk-candidates-first-line ()
+  "Boundary: a hunk on line 1 resolves to the first line's text."
+  (with-temp-buffer
+    (insert "alpha\nbravo\n")
+    (let ((candidates (cj/--git-gutter-hunk-candidates '(1))))
+      (should (string-match-p "alpha" (caar candidates)))
+      (should (= 1 (cdar candidates))))))
+
+(ert-deftest test-vc-gutter-hunk-candidates-unicode-line-text ()
+  "Boundary: line text with unicode survives into the label."
+  (with-temp-buffer
+    (insert "naïve — 日本語\n")
+    (let ((candidates (cj/--git-gutter-hunk-candidates '(1))))
+      (should (string-match-p "日本語" (caar candidates))))))
+
+;;; Error Cases
+
+(ert-deftest test-vc-goto-git-gutter-diff-hunks-no-hunks-user-error ()
+  "Error: the command signals `user-error' when the buffer has no hunks."
+  (with-temp-buffer
+    (setq-local git-gutter:diffinfos nil)
+    (cl-letf (((symbol-function 'require) (lambda (&rest _) nil)))
+      (should-error (cj/goto-git-gutter-diff-hunks) :type 'user-error))))
+
+(provide 'test-vc-config--gutter-hunk-candidates)
+;;; test-vc-config--gutter-hunk-candidates.el ends here
diff --git a/tests/test-vc-config--timemachine-commands.el b/tests/test-vc-config--timemachine-commands.el
new file mode 100644
index 00000000..36a71695
--- /dev/null
+++ b/tests/test-vc-config--timemachine-commands.el
@@ -0,0 +1,36 @@
+;;; test-vc-config--timemachine-commands.el --- Tests for git-timemachine command wiring -*- lexical-binding: t -*-
+
+;;; Commentary:
+;; Guards the git-timemachine autoload surface in vc-config.el.  The
+;; upstream package defines no `git-timemachine-show-selected-revision';
+;; an autoload for it in :commands creates a phantom M-x command that
+;; errors after loading the package.  The real selector lives in the
+;; cj/ namespace.
+
+;;; Code:
+
+(require 'ert)
+
+(add-to-list 'load-path (expand-file-name "modules" user-emacs-directory))
+(require 'vc-config)
+
+;;; Normal Cases
+
+(ert-deftest test-vc-timemachine-selected-revision-cj-command-defined ()
+  "Normal: the cj/ selected-revision selector is defined by vc-config."
+  (should (fboundp 'cj/git-timemachine-show-selected-revision)))
+
+(ert-deftest test-vc-timemachine-entry-command-defined ()
+  "Normal: the cj/git-timemachine entry command is defined."
+  (should (commandp 'cj/git-timemachine)))
+
+;;; Error Cases
+
+(ert-deftest test-vc-timemachine-no-phantom-package-autoload ()
+  "Error: no autoload exists for a function the package never defines.
+An autoload stub for `git-timemachine-show-selected-revision' would
+surface in M-x and signal void-function after the package loads."
+  (should-not (fboundp 'git-timemachine-show-selected-revision)))
+
+(provide 'test-vc-config--timemachine-commands)
+;;; test-vc-config--timemachine-commands.el ends here