BHW Emacs Configuration

;;---------------------------------------------------------------------------
(after! consult
  (require 'org-node)

  ;; `abbreviate-file-name' recompiles `directory-abbrev-alist' regexps on
  ;; every call: 4.0s over the ~164k candidates a common bigram like "do"
  ;; produces. All Find candidates are rooted at $HOME, so a literal prefix
  ;; swap is equivalent and ~100x cheaper.
  (defconst bhw/consult--home-prefix (expand-file-name "~/")
    "Expanded $HOME prefix that `bhw/consult--abbrev-home' swaps for ~/.")

  (defun bhw/consult--abbrev-home (path)
    "Replace a literal `bhw/consult--home-prefix' in PATH with ~/."
    (if (string-prefix-p bhw/consult--home-prefix path)
        (concat "~/" (substring path (length bhw/consult--home-prefix)))
      path))

  (defun bhw/consult--unabbrev-home-input (input)
    "Expand a leading ~/ in every whitespace-separated token of INPUT.
`bhw/consult--abbrev-home' abbreviates only the *display* string; `fd'
still filters the unabbreviated absolute paths it emits, so a token typed
as ~/dir/file (e.g. copied back out of the candidate list) could never
match.  Rewrite it to the expanded prefix before the builder compiles the
input into `--and' patterns."
    (replace-regexp-in-string
     (rx (or bos (any " \t")) (group "~/"))
     bhw/consult--home-prefix input t t 1))

  (defvar bhw/consult-source-filesystem
    `(:name     "Find"
      :narrow   ?f
      :category file
      :face     consult-file
      :history  file-name-history
      :action   ,#'consult--file-action
      :state    ,#'consult--file-preview
      ;; Async: `fd' filters by the typed input, so nothing is materialized
      ;; until you type >= 3 chars (`:min-input' below — Doom lowers the
      ;; global `consult-async-min-input' to 2, and common bigrams match
      ;; six-figure candidate sets against `--full-path'). `--max-results'
      ;; bounds the worst-case flood consult must ingest on the main thread.
      ;; `--no-ignore-vcs' because `fd' otherwise honors every enclosing
      ;; .gitignore: ~/project-maria/.gitignore lists *.pdf/*.tex/*.bbl, which
      ;; made ~28 real files in that tree unreachable from `consult-buffer'
      ;; while `consult-recent-file' (plain `recentf-list') still found them.
      ;; It does NOT disable the global ignore file (~/.config/fd/ignore), so
      ;; Trash and /mnt/{c,e} stay excluded -- only `-I' would drop those too.
      ;; The `let*' bakes our flags into the builder closure WITHOUT mutating
      ;; the global `consult-fd-args' (so plain `M-x consult-fd' is
      ;; unaffected). `--search-path' yields absolute paths;
      ;; `bhw/consult--abbrev-home' restores the ~/ display and
      ;; `bhw/consult--unabbrev-home-input' undoes it on the way back in.
      :async
      ,(let* ((consult-fd-args
               '((if (executable-find "fdfind" 'remote) "fdfind" "fd")
                 "--full-path --color=never --hidden --follow --type f --exclude .git --no-ignore-vcs --max-results=5000"))
              (builder (consult--fd-make-builder (list (expand-file-name "~")))))
         (consult--process-collection
             (lambda (input)
               (funcall builder (bhw/consult--unabbrev-home-input input)))
           :transform (consult--async-map #'bhw/consult--abbrev-home)
           :highlight t
           :file-handler t
           :min-input 3))))

  (defvar bhw/consult-source-project-maria
    `(:name     "Project-Maria rg"
      :narrow   ?m
      :category consult-grep
      :history  consult--grep-history
      :state    ,#'consult--grep-state
      :action   ,(lambda (c) (consult--jump (consult--grep-position c)))
      :async
      ;; Content grep over prose: a 2-char input like "th" returns ~71k
      ;; match lines (12MB) for the main thread to parse and propertize.
      ;; Require 4 chars and cap matches per file; the `let*' shadows
      ;; `consult-ripgrep-args' only for this builder (args are read at
      ;; builder-creation time), leaving `M-x consult-ripgrep' untouched.
      ,(let* ((consult-ripgrep-args (concat consult-ripgrep-args " --max-count=10"))
              (builder (consult--ripgrep-make-builder (list +project-maria-dir+))))
         (consult--process-collection builder
           :transform (consult--grep-format builder)
           :file-handler t
           :min-input 4))))

  ;; `mapatoms' over the full obarray (~128k symbols) building ~13k command-name
  ;; strings costs ~85ms and triggers GC on EVERY consult-buffer open.  The
  ;; command set is effectively static between `load's, so cache the list and
  ;; invalidate it only when new code is loaded (rare after startup) via a
  ;; *named* `after-load-functions' hook (named so `doom/reload' re-adds it
  ;; idempotently instead of leaking duplicate anonymous closures).
  (defvar bhw/consult--emacs-commands-cache nil
    "Cached list of command-name strings for `bhw/consult-source-emacs-commands'.")

  (defun bhw/consult--emacs-commands ()
    "Return all command names as strings, rebuilding the cache on demand."
    (or bhw/consult--emacs-commands-cache
        (setq bhw/consult--emacs-commands-cache
              (let (cmds)
                (mapatoms (lambda (s) (when (commandp s) (push (symbol-name s) cmds))))
                cmds))))

  (defun bhw/consult--invalidate-emacs-commands-cache (&rest _)
    "Drop the cached Emacs-commands list so it is rebuilt after new code loads."
    (setq bhw/consult--emacs-commands-cache nil))
  (add-hook 'after-load-functions #'bhw/consult--invalidate-emacs-commands-cache)

  (defvar bhw/consult-source-emacs-commands
    (list :name     "Emacs Commands"
          :narrow   ?e
          :category 'command
          :items    #'bhw/consult--emacs-commands
          :action   (lambda (cmd-str) (command-execute (intern-soft cmd-str))))
    "Source for Emacs commands, used in `consult-buffer'.")

  (defvar org-node-history nil
    "History list for org-node selections in `consult-buffer'. The `:history 'org-node-history` property in `bhw/consult-source-org-node` tells `consult` to record selections into the variable `org-node-history`. But that variable was never declared with `defvar`, so it was void. When `consult--multi` tried to call `(add-to-history org-node-history \"Ecclesiastes 3:1\")`, Emacs raised a `void-variable` error.")

  (defvar bhw/consult-source-org-node
    (list :name     "Org Node"
          :narrow   ?n
          :category 'org-node
          :face     'consult-file
          :history  'org-node-history
          :items    (lambda ()
                      (org-node-cache-ensure)
                      (hash-table-keys org-node--candidate<>entry))
          :action   (lambda (cand)
                      (require 'org-id)
                      (let ((node (gethash cand org-node--candidate<>entry)))
                        (if node
                            (org-node-goto node)
                          ;; Fallback if the user somehow selects a non-existent item
                          ;; though :new usually handles creation
                          (org-node-create cand (org-id-new)))))
          :new      (lambda (cand)
                      (require 'org-id)
                      ;; Handle blank input for creation specifically
                      (let ((title (if (string-blank-p cand)
                                       (funcall org-node-blank-input-title-generator)
                                     cand)))
                        (org-node-create title (org-id-new)))))
    "Source for `org-node' to be used in `consult-buffer'.")

  ;; Replacing `consult-buffer-sources' wholesale (below) dropped the recentf
  ;; source, which is why `consult-recent-file' could find files `SPC SPC'
  ;; could not.  Put it back: it is the only source that reaches files outside
  ;; $HOME, and it costs ~200 candidates built with the *fast* abbreviator.
  ;; Upstream narrows it with ?f, already claimed by the Find source, so use ?r
  ;; on a shallow copy -- `plist-put' then writes to our cons cells, leaving the
  ;; global `consult-source-recent-file' untouched for other consult commands.
  (defvar bhw/consult-source-recent-file
    (plist-put (copy-sequence consult-source-recent-file) :narrow ?r)
    "Copy of `consult-source-recent-file' narrowed with ?r instead of ?f.")

  (setf consult-buffer-sources '(consult-source-buffer
                                 bhw/consult-source-recent-file
                                 bhw/consult-source-org-node
                                 bhw/consult-source-project-maria
                                 bhw/consult-source-filesystem
                                 bhw/consult-source-emacs-commands))

  ;; Perl split routes plain input to the async source only, leaving sync sources unfiltered.
  ;; Named advice so re-`load'ing this config replaces it instead of stacking
  ;; anonymous duplicates (same rationale as the named hook above).
  (defun bhw/consult-buffer-no-async-split-a (orig &rest args)
    "Call ORIG (`consult-buffer') with `consult-async-split-style' disabled."
    (let ((consult-async-split-style 'none))
      (apply orig args)))
  (advice-add 'consult-buffer :around #'bhw/consult-buffer-no-async-split-a))

  $ grep -E -b -o '^\(setq [^ ]+' ~/.config/emacs/.local/cache/savehist

  (setf history-length 25
        savehist-save-minibuffer-history nil
        savehist-autosave-interval nil
        kill-ring-max 200
        savehist-mode nil)
  (delq 'mark-ring savehist-additional-variables)
  (delq 'global-mark-ring savehist-additional-variables)
  (delq 'search-ring savehist-additional-variables)
  (delq 'regexp-search-ring savehist-additional-variables)
  (delq 'extended-command-history savehist-additional-variables)
  (delq 'kill-ring savehist-additional-variables)
  (put 'bibtex-completion-cache 'history-length 10)
  (push 'bibtex-completion-cache savehist-additional-variables)
  (push 'helm-ff-history savehist-additional-variables)
  (push 'org-clock-history savehist-additional-variables)
  ;; Emacs profiler shows `savehist-autosave' is very performance intensive.
  (add-hook 'kill-emacs-hook #'savehist-save) ; Savehist only on exit.

(after! projectile
  ;; Prune stale (deleted) projects whenever a switch-project prompt builds
  ;; its candidate list, so they can never appear.  Cheap: one
  ;; `file-readable-p' per local project; remote projects are skipped.
  ;; M-x projectile-cleanup-known-projects remains for manual runs.
  (setq projectile-auto-cleanup-known-projects t))

  ;; If bash $top shows high emacs memory usage, try the following.
  ;; Not sure if they work tbh.
  (pdf-cache-clear-data)
  (garbage-collect)

;;---------------------------------------------------------------------------
;; Disable evil-collection's pdf bindings so we have full control over
;; pdf-view-mode-map. Must run before `evil-collection-init', so we use
;; Doom's `+evil-collection-disabled-list' rather than mutating
;; `evil-collection-mode-list' inside `after!' (which fires too late —
;; the `eval-after-load 'pdf-view' hook is already registered, and
;; evil-collection-pdf-setup later tries to bind `sb' under `s', which
;; we've rebound to `avy-goto-word-or-subword-1').
(add-to-list '+evil-collection-disabled-list 'pdf)

(map! :after pdf-tools
      :map pdf-view-mode-map
      :n "i"              #'org-noter-insert-note
      :n "M-i"            #'bhw/org-noter-insert-precise-quote
      :n "d"              #'pdf-view-scroll-up-or-next-page
      :n "u"              #'pdf-view-scroll-down-or-previous-page
      :n "s"              #'avy-goto-word-or-subword-1
      :n "f"              #'pdf-view-set-slice-from-bounding-box
      :n ";"              #'pdf-occur
      :n "q"              #'bhw/org-noter-quit
      :n "gt"             #'pdf-view-goto-page
      :n "w"              #'bhw/pdf-view-fit-width
      :n "y"              #'bhw/pdf-view-yank
      :n [down-mouse-1]   #'bhw/pdf-view-mouse-set-region
      :n [C-down-mouse-1] #'pdf-view-mouse-extend-region
      :n [M-down-mouse-1] #'pdf-view-mouse-set-region-rectangle)

;; Prevent Evil from entering visual-mode when pdf-view activates the
;; mark for text selection.  Without this, Evil hijacks the region and
;; tries to select the PDF image object, breaking click-drag selection.
;; (Mirrors evil-collection-pdf-disable-visual-mode.)
(add-hook! 'pdf-view-mode-hook
  (pdf-view-midnight-minor-mode)
  (run-at-time "0.1 sec" nil (lambda () (when (derived-mode-p 'pdf-view-mode)
                                          (pdf-view-redisplay t))))
  (remove-hook 'activate-mark-hook 'evil-visual-activate-hook t))

(defun bhw/pdf-view-fit-width ()
  "Fit PDF page width, re-displaying first to avoid stale image errors."
  (interactive)
  (pdf-view-redisplay t)
  (pdf-view-fit-width-to-window))

(defun bhw/pdf-view-mouse-set-region (event)
  "Start a PDF text selection, re-displaying first to avoid stale image errors."
  (interactive "@e")
  (pdf-view-redisplay t)
  (pdf-view-mouse-set-region event))

(defun bhw/pdf-view-yank ()
  "Yank the text of the active PDF region into the kill ring."
  (interactive)
  (pdf-view-assert-active-region)
  (let ((txt (pdf-view-active-region-text)))
    (pdf-view-deactivate-region)
    (kill-new (mapconcat #'identity txt "\n"))
    (message "Yanked %d characters." (length (car kill-ring)))))

;; Fix: `pdf-view-image-size' passes the raw display property to the C
;; primitive `image-size' when DISPLAYED-P is nil.  After slicing
;; (`pdf-view-set-slice-from-bounding-box'), the display property
;; becomes ((slice X Y W H) (image …)) — a compound form that the C
;; primitive `image-size' cannot handle (it expects (image …)).  This
;; advice unwraps the image spec from the sliced form so `image-size'
;; receives a bare (image …) descriptor.
(defadvice! bhw/pdf-view-image-size-handle-slice-a (fn &optional displayed-p window page)
  :around #'pdf-view-image-size
  (if displayed-p
      ;; `image-display-size' already handles the sliced compound form.
      (funcall fn displayed-p window page)
    ;; Replicate the display-prop lookup that `pdf-view-image-size' does
    ;; internally, but unwrap any slice wrapper before calling `image-size'.
    (let ((display-prop (if pdf-view-roll-minor-mode
                            (let ((w (if (windowp window) window (selected-window))))
                              (overlay-get (pdf-roll-page-overlay
                                            (or page (pdf-view-current-page w)) w)
                                           'display))
                          (image-get-display-property))))
      (image-size (if (eq (car-safe (car display-prop)) 'slice)
                      (cadr display-prop)   ; ((slice …) (image …)) → (image …)
                    display-prop)           ; already (image …)
                  t))))

(after! pdf-tools
  (setf pdf-view-use-scaling nil
        pdf-view-max-image-width 4800
        pdf-cache-image-limit 512
        pdf-cache-prefetch-delay 0.3
        ;; see also `pdf-view-midnight-minor-mode'
        pdf-view-midnight-invert nil
        pdf-tools-enabled-modes
        '(pdf-view-dark-minor-mode
          pdf-history-minor-mode
          pdf-isearch-minor-mode
          pdf-links-minor-mode
          pdf-misc-minor-mode
          pdf-misc-size-indication-minor-mode
          pdf-occur-global-minor-mode))
  (pdf-cache-prefetch-minor-mode -1))

  (setf
   pdf-view-use-scaling t
   pdf-view-display-size 'fit-width
   pdf-view-resize-factor 1.1
   image-cache-eviction-delay 128
   pdf-cache-image-limit 128
   pdf-view-restore-filename "~/.emacs.d/.cache/.pdf-view-restore")
  ;; Custom function to allow double page scrolling by calling
  ;; my-pdf-view-double-scroll-horizontal-view
  (defun my-pdf-view-double-scroll-up-or-next-page (&optional arg)
    "Scroll page up ARG lines if possible, else go to the next page.
  When `pdf-view-continuous' is non-nil, scrolling upward at the
  bottom edge of the page moves to the next page.  Otherwise, go to
  next page only on typing SPC (ARG is nil)."
    (interactive "P")
    (if (or pdf-view-continuous (null arg))
        (let ((hscroll (window-hscroll))
              (cur-page (pdf-view-current-page)))
          (when (or (= (window-vscroll) (image-scroll-up arg))
                    ;; Workaround rounding/off-by-one issues.
                    (memq pdf-view-display-size
                          '(fit-height fit-page)))
            (pdf-view-next-page 2)
            (when (/= cur-page (pdf-view-current-page))
              (image-bob)
              (image-bol 1))
            (set-window-hscroll (selected-window) hscroll)))
      (image-scroll-up arg)))
  (defun my-pdf-view-double-scroll-horizontal-view ()
    (interactive)
    (my-pdf-view-double-scroll-up-or-next-page)
    (other-window 1)
    (my-pdf-view-double-scroll-up-or-next-page)
    (other-window 1))
  ;; add spacemacs major mode keybind
  (spacemacs/set-leader-keys-for-major-mode 'pdf-view-mode "d" 'my-pdf-view-double-scroll-horizontal-view)
  ;; Allow rotating of sheet music in pdfs
  (defun pdf-view--rotate (&optional counterclockwise-p page-p)
    "Rotate PDF 90 degrees.  Requires pdftk to work.\n
  Clockwise rotation is the default; set COUNTERCLOCKWISE-P to
  non-nil for the other direction.  Rotate the whole document by
  default; set PAGE-P to non-nil to rotate only the current page.
  \nWARNING: overwrites the original file, so be careful!"
    ;; error out when pdftk is not installed
    (if (null (executable-find "pdftk"))
        (error "Rotation requires pdftk")
      ;; only rotate in pdf-view-mode
      (when (eq major-mode 'pdf-view-mode)
        (let* ((rotate (if counterclockwise-p "left" "right"))
               (file   (format "\"%s\"" (pdf-view-buffer-file-name)))
               (page   (pdf-view-current-page))
               (pages  (cond ((not page-p)                        ; whole doc?
                              (format "1-end%s" rotate))
                             ((= page 1)                          ; first page?
                              (format "%d%s %d-end"
                                      page rotate (1+ page)))
                             ((= page (pdf-info-number-of-pages)) ; last page?
                              (format "1-%d %d%s"
                                      (1- page) page rotate))
                             (t                                   ; interior page?
                              (format "1-%d %d%s %d-end"
                                      (1- page) page rotate (1+ page))))))
          ;; empty string if it worked
          (if (string= "" (shell-command-to-string
                           (format (concat "pdftk %s cat %s "
                                           "output %s.NEW "
                                           "&& mv %s.NEW %s")
                                   file pages file file file)))
              (pdf-view-revert-buffer nil t)
            (error "Rotation error!"))))))

  (defun pdf-view-rotate-clockwise (&optional arg)
    "Rotate PDF page 90 degrees clockwise.  With prefix ARG, rotate
  entire document."
    (interactive "P")
    (pdf-view--rotate nil (not arg)))

  (defun pdf-view-rotate-counterclockwise (&optional arg)
    "Rotate PDF page 90 degrees counterclockwise.  With prefix ARG,
  rotate entire document."
    (interactive "P")
    (pdf-view--rotate :counterclockwise (not arg)))

  (define-key spacemacs-pdf-view-mode-map (kbd "R") 'pdf-view-rotate-clockwise)

;;---------------------------------------------------------------------------
(after! magit
  (map! :map magit-status-mode-map
        "SPC" #'doom/leader
        "j" #'evil-next-line
        "k" #'evil-previous-line
        "h" #'evil-backward-char
        "l" #'evil-forward-char
        "p" #'magit-push
        "v" #'evil-visual-line
        "V" #'evil-visual-line
        "gg" #'evil-goto-first-line
        "G" #'evil-goto-line))

  (setf forge-owned-accounts '(("your-gh-username" :remote-name "origin"))
        magit-save-repository-buffers 'dontask)

{
  "permissions": {
    "defaultMode": "bypassPermissions"
  }
}

  ssh oci-a1-flex
  mkdir /opt/llava
  cd /opt/llava
  curl "DOWNLOAD_LINK" -L -O
  chmod +x llava-v1.5-7b-q4.llamafile
  # https://github.com/Mozilla-Ocho/llamafile?tab=readme-ov-file#gotchas
  sudo wget -O /usr/bin/ape https://cosmo.zip/pub/cosmos/bin/ape-$(uname -m).elf
  sudo chmod +x /usr/bin/ape
  sudo sh -c "echo ':APE:M::MZqFpD::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"
  sudo sh -c "echo ':APE-jart:M::jartsr::/usr/bin/ape:' >/proc/sys/fs/binfmt_misc/register"

  [Unit]
  Description=Run Large Language Model locally through llama.cpp and Cosmopolitan Libc.

  [Service]
  Type=exec
  User=root
  WorkingDirectory=/opt/llava
  ExecStart=/opt/llava/llava-v1.5-7b-q4.llamafile -ngl 9999 --nobrowser --port 8090 --embedding
  Restart=on-failure
  RestartSec=30s

  [Install]
  WantedBy=multi-user.target

;;---------------------------------------------------------------------------
(use-package! claude-code-ide
  :defer t
  :init
  ;; The binding lives in :init so it exists before the package loads;
  ;; `claude-code-ide-menu' is autoloaded, and first use runs :config below,
  ;; which registers the MCP tools before any session starts.
  (map! :leader
        :desc "claude-code-ide-menu" "d" #'claude-code-ide-menu)
  :config
  ;; Use the ghostel terminal backend (installed below) instead of the
  ;; default 'vterm, whose native module isn't compiled in this setup.
  (setq claude-code-ide-terminal-backend 'ghostel)

  ;; Register the 5 built-in Emacs MCP tools (xref-find-references,
  ;; xref-find-apropos, project-info, imenu-list-symbols, treesit-info)
  ;; and set `claude-code-ide-enable-mcp-server' to t.
  (claude-code-ide-emacs-tools-setup)

  ;; --- Workspace-scoped session directory ----------------------------------

  (defun bhw/claude-code-ide--workspace-root (stamped buffers)
    "Resolve a workspace's project root from STAMPED and BUFFERS.
STAMPED is the workspace's `+workspace-project' persp parameter and
wins when it still names a live directory; a workspace outlives the
directory it was opened on.  BUFFERS is the workspace's buffer list,
from which the most widely shared project root is taken, recency
breaking ties.  Returns nil when neither yields a project."
    (when-let* ((root
                 (or (and (stringp stamped) (file-directory-p stamped) stamped)
                     (let ((tally (make-hash-table :test #'equal))
                           (roots nil))
                       ;; `buffer-list' is MRU-ordered and a persp's buffer
                       ;; list can hold killed buffers, so walk the
                       ;; intersection rather than BUFFERS itself.
                       (dolist (buf (buffer-list))
                         (when (and (memq buf buffers)
                                    (or (buffer-file-name buf)
                                        (provided-mode-derived-p
                                         (buffer-local-value 'major-mode buf)
                                         'dired-mode)))
                           (when-let* ((r (doom-project-root
                                           (buffer-local-value 'default-directory buf))))
                             (unless (gethash r tally) (push r roots))
                             (puthash r (1+ (gethash r tally 0)) tally))))
                       ;; `sort' is stable, so equal counts keep MRU order.
                       (car (sort (nreverse roots)
                                  (lambda (a b)
                                    (> (gethash a tally) (gethash b tally)))))))))
      (expand-file-name (file-name-as-directory root))))

  (defun bhw/claude-code-ide--workspace-project-root ()
    "Return the project root of the current Doom workspace, or nil.
Prefers the `+workspace-project' persp parameter that
`+workspaces-switch-to-project-h' stamps onto a workspace opened from
a project switch; hand-made workspaces carry no such parameter and are
resolved from their buffers.  Returns nil outside persp-mode and in a
workspace with no project (an empty `main', say), leaving upstream's
buffer-local lookup in charge."
    (when-let* (((bound-and-true-p persp-mode))
                ((fboundp 'get-current-persp))
                (persp (get-current-persp)))
      (bhw/claude-code-ide--workspace-root
       (persp-parameter '+workspace-project persp)
       (persp-buffers persp))))

  (defadvice! bhw/claude-code-ide-workspace-dir-a (&rest _)
    "Key Claude sessions to the workspace's project, not the current buffer.
Workspaces are per-project here, so opening a file from another
project inside one must not start (or address) a second session; the
workspace outranks whatever buffer happens to be current."
    :before-until #'claude-code-ide--get-working-directory
    (bhw/claude-code-ide--workspace-project-root))

  ;; --- Shared tool helpers -------------------------------------------------

  (defun bhw/claude-mcp--user-buffer ()
    "The buffer the user is working in, never the Claude terminal.
The session's :last-active-buffer is only maintained for file buffers
inside the session's project dir, so fall back to the most recently
used window showing neither the terminal nor a minibuffer, then to
frame MRU buffer order.  Returns nil if nothing qualifies."
    (let* ((context (claude-code-ide-mcp-server-get-session-context))
           (terminal (plist-get context :buffer))
           (last (plist-get context :last-active-buffer)))
      (or (and last (buffer-live-p last) last)
          (cl-loop for win in (sort (window-list nil 'no-minibuf)
                                    (lambda (a b)
                                      (> (window-use-time a)
                                         (window-use-time b))))
                   for buf = (window-buffer win)
                   unless (or (eq buf terminal) (minibufferp buf))
                   return buf)
          (cl-loop for buf in (buffer-list (selected-frame))
                   unless (or (eq buf terminal) (minibufferp buf)
                              (string-prefix-p " " (buffer-name buf)))
                   return buf))))

  (defun bhw/claude-mcp--brief (value)
    "Render VALUE for tool output: short, propertyless, no raw lisp objects."
    (let ((s (cond ((stringp value) (substring-no-properties value))
                   ((markerp value)
                    (if (marker-buffer value)
                        (format "%s:%d" (buffer-name (marker-buffer value))
                                (marker-position value))
                      "(marker: no buffer)"))
                   ((or (bufferp value) (framep value) (windowp value)
                        (processp value) (compiled-function-p value))
                    (format "#<%s>" (type-of value)))
                   (t (format "%S" value)))))
      (if (> (length s) 200) (concat (substring s 0 200) "…") s)))

  (defun bhw/claude-mcp--join-capped (lines max)
    "Join LINES, capping at MAX with an explicit \"(+N more)\" indicator."
    (let ((n (length lines)))
      (if (<= n max)
          (string-join lines "\n")
        (concat (string-join (seq-take lines max) "\n")
                (format "\n(+%d more; pass a larger limit to see all)"
                        (- n max))))))

  (defun bhw/claude-mcp--match-all-p (tokens haystack)
    "Non-nil when every literal token in TOKENS occurs in HAYSTACK."
    (cl-every (lambda (tok) (string-match-p (regexp-quote tok) haystack))
              tokens))

  (defun bhw/claude-mcp-register (&rest slots)
    "Register an MCP tool, replacing any existing spec with the same :name.
`claude-code-ide-make-tool' dedupes via `add-to-list' by whole-spec
`equal', so editing a tool then `doom/reload' would otherwise leave two
specs advertising the same name, and tools/list would list both."
    (let ((name (plist-get slots :name)))
      (setq claude-code-ide-mcp-server-tools
            (cl-remove-if (lambda (spec)
                            (and (keywordp (car-safe spec))
                                 (equal (plist-get spec :name) name)))
                          claude-code-ide-mcp-server-tools)))
    (apply #'claude-code-ide-make-tool slots))

  ;; --- Custom MCP tools ----------------------------------------------------
  ;; Editor state

  (defun bhw/claude-mcp-current-buffer-info ()
    "Return file, mode, position, modified and region state of the user's buffer.
The session context's :buffer is the ghostel terminal running Claude
itself, so resolution goes through `bhw/claude-mcp--user-buffer'."
    (let ((buffer (bhw/claude-mcp--user-buffer)))
      (if (not buffer)
          "ERROR: no user buffer identified (only the Claude terminal is visible)"
        (with-current-buffer buffer
          (format "Buffer: %s\nFile: %s\nMode: %s\nLine: %d\nColumn: %d\nModified: %s\nRegion active: %s"
                  (buffer-name)
                  (or (buffer-file-name) "(no file)")
                  major-mode
                  (line-number-at-pos)
                  (current-column)
                  (if (buffer-modified-p) "yes" "no")
                  (if (use-region-p) "yes" "no"))))))

  (defun bhw/claude-mcp-current-selection ()
    "Return active region text from the user's buffer, or a no-region message."
    (let ((buffer (bhw/claude-mcp--user-buffer)))
      (if (not buffer)
          "ERROR: no user buffer identified (only the Claude terminal is visible)"
        (with-current-buffer buffer
          (if (use-region-p)
              (buffer-substring-no-properties (region-beginning) (region-end))
            (format "No active region in %s" (buffer-name)))))))

  (defun bhw/claude-mcp-list-buffers (&optional include_non_file limit)
    "Return open buffers, most recently used first, one record per line."
    (let* ((max (or limit 50))
           (lines
            (cl-loop for buf in (buffer-list (selected-frame)) ; MRU order
                     for name = (buffer-name buf)
                     for file = (buffer-file-name buf)
                     when (and (not (string-prefix-p " " name))
                               (or file include_non_file))
                     collect (format "%s | %s | %s%s"
                                     name
                                     (or file "(no file)")
                                     (buffer-local-value 'major-mode buf)
                                     (if (and file (buffer-modified-p buf))
                                         " | MODIFIED" "")))))
      (if lines
          (bhw/claude-mcp--join-capped lines max)
        "No matching buffers")))

  ;; Org-node (ID nodes via the public org-mem API)

  (defun bhw/claude-mcp-org-node-find (query &optional limit)
    "Match org-node entries whose title contains every token of QUERY.
Case-insensitive; returns `title | file | id' lines, LIMIT (default 20)."
    (require 'org-node)
    (org-node-cache-ensure)
    (let* ((tokens (split-string (downcase (or query "")) "[ \t]+" t))
           (max (or limit 20))
           (matches
            (cl-loop for entry in (org-mem-all-id-nodes)
                     for title = (or (org-mem-entry-title entry) "")
                     when (bhw/claude-mcp--match-all-p tokens (downcase title))
                     collect (format "%s | %s | %s"
                                     title
                                     (org-mem-entry-file entry)
                                     (or (org-mem-entry-id entry) "")))))
      (if matches
          (bhw/claude-mcp--join-capped matches max)
        (format "No org-node matches for %S" query))))

  ;; Org agenda / clock

  (defun bhw/claude-mcp--org-todo-row ()
    "Format the heading at point as one agenda-todo record, or nil to skip."
    (let ((state (org-get-todo-state)))
      (when state
        (let ((heading (org-get-heading t t nil t)) ; keep the priority cookie
              (path (org-get-outline-path))
              (tags (org-get-tags))
              (sched (org-entry-get nil "SCHEDULED"))
              (dl (org-entry-get nil "DEADLINE"))
              (effort (org-entry-get nil "EFFORT")))
          (concat
           (format "%s:%d | %s %s"
                   (or (buffer-file-name) (buffer-name))
                   (line-number-at-pos)
                   (substring-no-properties state)
                   (substring-no-properties heading))
           (and path (format " | path: %s" (string-join path " > ")))
           (and tags (format " | tags: %s"
                             (mapconcat #'substring-no-properties tags ":")))
           (and sched (format " | sched: %s" sched))
           (and dl (format " | deadline: %s" dl))
           (and effort (format " | effort: %s" effort)))))))

  (defun bhw/claude-mcp-org-agenda-todos (&optional keywords limit)
    "List agenda entries by todo state, one record per line.
KEYWORDS is a space/comma-separated list of todo keywords, \"all\", or
nil/\"not-done\" (the default) for every not-done state in one pass."
    (require 'org)
    (let* ((wanted (cond ((member keywords '(nil "" "not-done")) 'not-done)
                         ((equal keywords "all") 'all)
                         (t (split-string keywords "[ ,]+" t))))
           (max (or limit 100))
           (rows (delq nil
                       (org-map-entries
                        (lambda ()
                          (let ((state (org-get-todo-state)))
                            (when (pcase wanted
                                    ('not-done (org-entry-is-todo-p))
                                    ('all state)
                                    (_ (member state wanted)))
                              (bhw/claude-mcp--org-todo-row))))
                        nil 'agenda))))
      (if rows
          (bhw/claude-mcp--join-capped rows max)
        (format "No matching entries (keywords=%s)" (or keywords "not-done")))))

  (defun bhw/claude-mcp-org-clock-status ()
    "Return the current org clock with its location, or the last history entry."
    (require 'org-clock)
    (cond
     ((org-clocking-p)
      (let* ((elapsed (float-time (time-since org-clock-start-time)))
             (h (floor (/ elapsed 3600)))
             (m (floor (/ (mod elapsed 3600) 60)))
             (buf (marker-buffer org-clock-marker))
             (where (and (buffer-live-p buf)
                         (with-current-buffer buf
                           (save-excursion
                             (goto-char org-clock-marker)
                             (format "%s:%d%s"
                                     (or (buffer-file-name) (buffer-name))
                                     (line-number-at-pos)
                                     (if-let* ((id (org-entry-get nil "ID")))
                                         (format " (id: %s)" id)
                                       "")))))))
        (format "Clocked in: %s\nStarted: %s\nElapsed: %dh%02dm%s"
                (substring-no-properties (or org-clock-current-task ""))
                (format-time-string "%F %T" org-clock-start-time)
                h m
                (if where (format "\nAt: %s" where) ""))))
     ((and (boundp 'org-clock-history) org-clock-history)
      (let* ((m (car org-clock-history))
             (buf (and (markerp m) (marker-buffer m))))
        (if (buffer-live-p buf)
            (with-current-buffer buf
              (save-excursion
                (goto-char m)
                (format "No clock running. Last task: %s at %s:%d%s"
                        (substring-no-properties (org-get-heading t t t t))
                        (or (buffer-file-name) (buffer-name))
                        (line-number-at-pos)
                        (if-let* ((id (org-entry-get nil "ID")))
                            (format " (id: %s)" id)
                          ""))))
          "No clock running. History markers point to dead buffers.")))
     (t "No clock active and history empty")))

  ;; Citar bibliography

  (defun bhw/claude-mcp-citar-lookup (query &optional limit)
    "Match bibliography entries containing every token of QUERY.
Case-insensitive over citekey, author, and title; LIMIT default 20."
    (require 'citar)
    (let* ((tokens (split-string (downcase (or query "")) "[ \t]+" t))
           (max (or limit 20))
           (matches '()))
      (maphash
       (lambda (key entry)
         (let* ((title (or (cdr (assoc "title" entry)) ""))
                (author (or (cdr (assoc "author" entry)) ""))
                (year (or (cdr (assoc "year" entry))
                          (cdr (assoc "date" entry)) ""))
                (haystack (downcase (concat key " " author " " title))))
           (when (bhw/claude-mcp--match-all-p tokens haystack)
             (push (format "@%s | %s | %s | %s" key author year title)
                   matches))))
       (citar-get-entries))
      (if matches
          (bhw/claude-mcp--join-capped (nreverse matches) max)
        (format "No bibliography matches for %S" query))))

  ;; Introspection

  (defun bhw/claude-mcp-describe-symbols (symbols)
    "Report feature, function, and variable state for each name in SYMBOLS."
    (mapconcat
     (lambda (name)
       (let ((sym (intern-soft name)))
         (if (null sym)
             (format "%s: not interned%s" name
                     (if-let* ((lib (locate-library name)))
                         (format "; library at %s (not loaded)" lib)
                       ""))
           (string-join
            (list
             (format "%s:" name)
             (format "  feature: %s"
                     (cond ((featurep sym) "loaded")
                           ((locate-library name)
                            (format "not loaded (library: %s)"
                                    (locate-library name)))
                           (t "no such feature/library")))
             (format "  function: %s"
                     (cond ((not (fboundp sym)) "void")
                           ((autoloadp (symbol-function sym))
                            "autoload (not yet loaded)")
                           (t (let (adv)
                                (advice-mapc (lambda (f _) (push f adv)) sym)
                                (if adv
                                    (format "defined; advised by %s"
                                            (mapconcat #'bhw/claude-mcp--brief
                                                       adv ", "))
                                  "defined")))))
             (format "  variable: %s"
                     (if (boundp sym)
                         (format "bound = %s"
                                 (bhw/claude-mcp--brief (symbol-value sym)))
                       "void")))
            "\n"))))
     (split-string symbols "[ ,]+" t)
     "\n"))

  (defun bhw/claude-mcp-buffer-sync (file &optional action)
    "Report whether FILE's buffer is modified/stale; ACTION \"revert\" syncs it.
Refuses to revert a buffer with unsaved edits."
    (let ((buf (get-file-buffer (expand-file-name file))))
      (if (null buf)
          (format "%s: not visited by any buffer; disk contents are authoritative"
                  file)
        (with-current-buffer buf
          (let ((modified (buffer-modified-p))
                (stale (not (verify-visited-file-modtime (current-buffer)))))
            (cond
             ((not (equal action "revert"))
              (format "%s: %s in Emacs; %s disk" file
                      (if modified "MODIFIED (unsaved edits)" "unmodified")
                      (if stale "STALE against" "in sync with")))
             (modified
              (format "ERROR: %s has unsaved edits in Emacs; refusing to revert. Ask the user to save or discard first."
                      file))
             ((not stale)
              (format "%s: already in sync; no revert needed" file))
             (t
              (revert-buffer 'ignore-auto 'noconfirm 'preserve-modes)
              (when (derived-mode-p 'org-mode)
                (org-element-cache-reset))
              (format "%s: reverted from disk%s" file
                      (if (derived-mode-p 'org-mode)
                          " (org-element cache reset)"
                        "")))))))))

  (defun bhw/claude-mcp-key-lookup (key &optional mode state)
    "Resolve KEY per keymap layer, optionally in MODE and evil STATE.
Uses an existing live buffer in MODE; never instantiates the mode."
    (let ((keyseq (condition-case nil (kbd key) (error nil))))
      (if (null keyseq)
          (format "ERROR: cannot parse key %S with kbd" key)
        (let* ((mode-sym (and mode (intern-soft mode)))
               (buf (if mode-sym
                        (cl-find-if (lambda (b)
                                      (eq (buffer-local-value 'major-mode b)
                                          mode-sym))
                                    (buffer-list))
                      (bhw/claude-mcp--user-buffer))))
          (cond
           ((and mode-sym (null buf))
            (format "ERROR: no live buffer in %s; open one and retry" mode))
           ((null buf) "ERROR: no user buffer to resolve against")
           (t
            (with-current-buffer buf
              (let ((state-sym (and state (intern-soft state)))
                    lines)
                (push (format "effective in %s (%s%s): %s"
                              (buffer-name) major-mode
                              (if (bound-and-true-p evil-state)
                                  (format ", evil %s" evil-state)
                                "")
                              (bhw/claude-mcp--brief (key-binding keyseq)))
                      lines)
                (when (and state-sym (fboundp 'evil-get-auxiliary-keymap))
                  (when-let* ((aux (and (current-local-map)
                                        (evil-get-auxiliary-keymap
                                         (current-local-map) state-sym))))
                    (push (format "evil %s + local map: %s" state
                                  (bhw/claude-mcp--brief
                                   (lookup-key aux keyseq)))
                          lines))
                  (when-let* ((gmap (evil-state-property state-sym :keymap t)))
                    (push (format "evil %s global: %s" state
                                  (bhw/claude-mcp--brief
                                   (lookup-key gmap keyseq)))
                          lines)))
                (push (format "local map: %s"
                              (bhw/claude-mcp--brief
                               (and (current-local-map)
                                    (lookup-key (current-local-map) keyseq))))
                      lines)
                (push (format "global map: %s"
                              (bhw/claude-mcp--brief
                               (lookup-key global-map keyseq)))
                      lines)
                (string-join (nreverse lines) "\n")))))))))

  ;; Reload / diagnostics

  (defvar bhw/claude-mcp--reload-requested-at nil
    "When the last doom-reload MCP call kicked off, for status polling.")

  (defun bhw/claude-mcp-doom-reload (&optional tangle)
    "Start `doom/reload' (optionally tangling dotemacs.org first); async.
Returns immediately; poll the doom-reload-status tool for the outcome."
    (catch 'bhw/done
      (when tangle
        (let* ((org-file (expand-file-name "~/project-maria/blog/dotemacs.org"))
               (buf (get-file-buffer org-file)))
          (when (and buf (buffer-modified-p buf))
            (throw 'bhw/done
                   "ERROR: dotemacs.org has unsaved edits in Emacs; refusing to tangle over them"))
          (when (and buf (not (verify-visited-file-modtime buf)))
            (with-current-buffer buf
              (revert-buffer 'ignore-auto 'noconfirm)))
          (let ((org-confirm-babel-evaluate nil))
            (with-current-buffer (or buf (find-file-noselect org-file))
              (org-babel-tangle)))))
      (setq bhw/claude-mcp--reload-requested-at (float-time))
      (doom/reload) ; async: `doom sync' compiles in *compilation*, hooks follow
      (format "%sdoom/reload started (doom sync running in *compilation*). Poll doom-reload-status in ~30s."
              (if tangle "tangled dotemacs.org; " ""))))

  (defun bhw/claude-mcp-doom-reload-status ()
    "Report the outcome of the last doom-reload kicked off via MCP."
    (let ((t0 bhw/claude-mcp--reload-requested-at))
      (cond
       ((null t0) "no reload requested via MCP this session")
       ((and bhw/config-load-stamp (> bhw/config-load-stamp t0))
        (format "reload OK (config.el load stamp fresh); tests: %s"
                (if (and bhw/config-tests-last-report
                         (> (car bhw/config-tests-last-report) t0))
                    (cdr bhw/config-tests-last-report)
                  "no test report yet")))
       ((and bhw/config-reload-start-time (> bhw/config-reload-start-time t0))
        (format "reload FAILED partway: reload ran but the load stamp is stale; tests: %s. Check *Messages*."
                (if (and bhw/config-tests-last-report
                         (> (car bhw/config-tests-last-report) t0))
                    (cdr bhw/config-tests-last-report)
                  "no test report")))
       ((let ((b (get-buffer "*compilation*")))
          (and b (get-buffer-process b)))
        "doom sync still running")
       (t "doom sync finished but reload hooks never ran -- sync likely FAILED; check *compilation*"))))

  (defun bhw/claude-mcp-messages-tail (&optional n errors_only)
    "Return the last N lines of *Messages* (default 40).
With ERRORS_ONLY, keep only lines that look like errors or warnings."
    (with-current-buffer (messages-buffer)
      (let* ((lines (split-string (buffer-substring-no-properties
                                   (point-min) (point-max))
                                  "\n" t))
             (lines (if errors_only
                        (seq-filter
                         (lambda (l)
                           (string-match-p
                            "\\b\\(?:[Ee]rror\\|[Ww]arning\\|failed\\|FAILED\\|void\\)"
                            l))
                         lines)
                      lines))
             (tail (last lines (or n 40))))
        (if tail (string-join tail "\n") "no matching messages"))))

  (defun bhw/claude-mcp-last-backtrace ()
    "Return the head of the *Backtrace* buffer, if one exists."
    (if-let* ((buf (get-buffer "*Backtrace*")))
        (with-current-buffer buf
          (let ((end (min (point-max) (+ (point-min) 8000))))
            (concat (buffer-substring-no-properties (point-min) end)
                    (when (< end (point-max)) "\n(truncated at 8000 chars)"))))
      "no *Backtrace* buffer exists"))

  ;; --- Tool registrations --------------------------------------------------
  ;; All through `bhw/claude-mcp-register' so `doom/reload' replaces rather
  ;; than duplicates specs.  The schema emitter drops :enum, so argument
  ;; vocabularies must be spelled out in :description text.

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-current-buffer-info
   :name "current-buffer-info"
   :description "Get the buffer the user is working in (never the Claude terminal): file path, major mode, line, column, modified flag, and whether a region is active. Use this to learn what the user is looking at right now."
   :args nil)

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-current-selection
   :name "current-selection"
   :description "Return the text of the user's active region (selection) in Emacs, or a no-region message. Use this when the user references \"this\" or \"the selection\"."
   :args nil)

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-list-buffers
   :name "list-buffers"
   :description "List the user's open Emacs buffers, most recently used first, as `name | file | mode' lines; modified file buffers are flagged MODIFIED. Truncated output ends with a `(+N more)' line."
   :args '((:name "include_non_file"
            :type boolean
            :description "Also include buffers not visiting a file (default false)"
            :optional t)
           (:name "limit"
            :type integer
            :description "Maximum lines to return (default 50)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-org-node-find
   :name "org-node-find"
   :description "Search the user's org-node knowledge base (org ID nodes). Every whitespace-separated token of the query must occur in the node title (case-insensitive, any order). Returns `title | file | id' lines; truncated output ends with `(+N more)'."
   :args '((:name "query"
            :type string
            :description "Tokens to match against node titles")
           (:name "limit"
            :type integer
            :description "Maximum results (default 20)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-org-agenda-todos
   :name "org-agenda-todos"
   :description "List todo entries across the user's org agenda files as one `file:line | STATE heading | path | tags | sched | deadline | effort' record per line. keywords: space/comma-separated todo states (TODO PROJ APPT PROG WAIT DONE CXLD) or \"all\"; default is every not-done state in a single call. Truncated output ends with `(+N more)'."
   :args '((:name "keywords"
            :type string
            :description "Todo states to include, e.g. \"TODO\", \"TODO WAIT\", or \"all\". Default: all not-done states."
            :optional t)
           (:name "limit"
            :type integer
            :description "Maximum entries to return (default 100)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-org-clock-status
   :name "org-clock-status"
   :description "Return the user's currently clocked-in org task with elapsed time and its file:line (plus ID when present), or the most recent clock history entry if no clock is running."
   :args nil)

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-citar-lookup
   :name "citar-lookup"
   :description "Search the user's citar bibliography (project-jerome.bib). Every whitespace-separated token of the query must occur in the citekey, author, or title (case-insensitive). Returns `@citekey | author | year | title' lines; truncated output ends with `(+N more)'."
   :args '((:name "query"
            :type string
            :description "Tokens to match against citekey, author, and title")
           (:name "limit"
            :type integer
            :description "Maximum results (default 20)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-describe-symbols
   :name "describe-symbols"
   :description "Inspect Emacs symbols without writing elisp: for each name, report whether the feature/library is loaded, the function state (void, autoload, or defined, plus any advice), and the variable's current value (abbreviated). Prefer this over executeCode for featurep/boundp/fboundp/advice probes."
   :args '((:name "symbols"
            :type string
            :description "Space or comma-separated symbol names")))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-buffer-sync
   :name "buffer-sync"
   :description "Check whether a file's Emacs buffer has unsaved edits or is stale against disk, and optionally revert it. action \"check\" (the default) only reports; action \"revert\" reverts a stale, unmodified buffer (org buffers also get their org-element cache reset) and refuses when there are unsaved edits. Call before editing a file the user may have open in Emacs."
   :args '((:name "file"
            :type string
            :description "Absolute or ~-relative path of the file")
           (:name "action"
            :type string
            :description "\"check\" (default) or \"revert\""
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-key-lookup
   :name "key-lookup"
   :description "Resolve a key sequence (kbd syntax, e.g. \"C-c C-c\" or \"; s\") layer by layer: effective binding, evil auxiliary/global maps for a given state, local map, global map. Optional mode (e.g. \"org-agenda-mode\"; resolved in an existing live buffer of that mode) and evil state (\"normal\", \"insert\", \"visual\", \"motion\", \"emacs\")."
   :args '((:name "key"
            :type string
            :description "Key sequence in kbd syntax")
           (:name "mode"
            :type string
            :description "Major mode name to resolve in (needs a live buffer in that mode)"
            :optional t)
           (:name "state"
            :type string
            :description "Evil state name (normal, insert, visual, motion, emacs)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-doom-reload
   :name "doom-reload"
   :description "Kick off doom/reload (asynchronous: doom sync, then config re-eval and the ERT suite) and return immediately. With tangle=true, org-babel-tangle dotemacs.org first (refuses if its buffer has unsaved edits). Poll doom-reload-status for the outcome. Redefines live tool functions mid-session. Prefer this over hand-rolled tangle/reload elisp."
   :args '((:name "tangle"
            :type boolean
            :description "Tangle ~/project-maria/blog/dotemacs.org before reloading (default false)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-doom-reload-status
   :name "doom-reload-status"
   :description "Report the outcome of the last doom-reload tool call: still running, reload OK with the ERT summary (\"N/N passed\"), failed partway (stale load stamp), or doom sync failure. Poll ~30s after doom-reload."
   :args nil)

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-messages-tail
   :name "messages-tail"
   :description "Return the last N lines of the *Messages* buffer (default 40), optionally filtered to error/warning-looking lines. Use this instead of dumping *Messages* via executeCode."
   :args '((:name "n"
            :type integer
            :description "How many lines (default 40)"
            :optional t)
           (:name "errors_only"
            :type boolean
            :description "Keep only lines containing error/warning/failed/void (default false)"
            :optional t)))

  (bhw/claude-mcp-register
   :function #'bhw/claude-mcp-last-backtrace
   :name "last-backtrace"
   :description "Return the most recent Emacs *Backtrace* buffer contents (first 8000 chars), or a message if none exists."
   :args nil))

;; --- Upstream MCP HTTP transport fixes -------------------------------------
;; `claude-code-ide-mcp-http-server.el' signals `json-rpc-error' in three places
;; but never defines it.  An undefined error symbol has no `error-conditions',
;; so the (error ...) clause of the `condition-case' in --handle-post cannot
;; match it and the signal escapes the web-server process filter as
;; "error in process filter: ... peculiar error: -32601, \"Method not found\"".
;; The request then gets no reply and its connection is never closed.
;;
;; The server is required lazily by `claude-code-ide-mcp-server.el', so `after!'
;; installs both fixes before the first --dispatch call.
(after! claude-code-ide-mcp-http-server
  (define-error 'json-rpc-error "JSON-RPC error" 'error)

  ;; Only initialize/tools-list/tools-call are implemented upstream, but Claude
  ;; Code probes resources and prompts after initialize.  Answer with empty
  ;; sets instead of falling through to "Method not found".  Empty vector and
  ;; hash-table rather than nil, since `json-encode' renders nil as "null".
  (defadvice! bhw/claude-code-ide-mcp-answer-probes-a (fn method params)
    "Answer the MCP capability probes upstream's `--dispatch' doesn't implement."
    :around #'claude-code-ide-mcp-http-server--dispatch
    (pcase method
      ("resources/list"           '((resources . [])))
      ("resources/templates/list" '((resourceTemplates . [])))
      ("prompts/list"             '((prompts . [])))
      ("ping"                     (make-hash-table :test 'equal))
      (_ (funcall fn method params))))

  ;; Upstream parses tool-call bodies with `json-parse-string' and no
  ;; :false-object, so JSON false arrives as the truthy keyword :false and
  ;; null as :null; a boolean argument explicitly passed as false would
  ;; otherwise read as t.  Normalize at the one choke point every tool
  ;; call's arguments pass through.
  (defadvice! bhw/claude-mcp-decode-json-atoms-a (args)
    "Map JSON false/null atoms to nil in validated tool arguments."
    :filter-return #'claude-code-ide-mcp-http-server--validate-args
    (mapcar (lambda (v) (if (memq v '(:false :null)) nil v)) args)))

  mkdir /home/ben/.stardict/
  ln -s /home/ben/project-jerome/400-philology/420-english-anglosaxon-languages/.stardict/dic /home/ben/.stardict/

;;---------------------------------------------------------------------------
(map! :leader
      :desc "lexic-search-word-at-point" "sx" #'lexic-search-word-at-point
      :desc "lexic-search"               "sX" #'lexic-search)

(after! lexic
  (map! :map lexic-mode-map
        "SPC" #'doom/leader
        "j"   #'evil-next-line
        "k"   #'evil-previous-line
        "h"   #'evil-backward-char
        "l"   #'evil-forward-char
        "q"   #'lexic-return-from-lexic
        "RET" #'lexic-search-word-at-point
        "a"   #'outline-show-all
        "o"   #'lexic-toggle-entry
        "d"   #'lexic-next-entry
        "u"   #'lexic-previous-entry
        "p"   #'lexic-search-history-backwards
        "n"   #'lexic-search-history-forwards)
  (setf lexic-dictionary-specs '
        (("Webster's Revised Unabridged Dictionary (1913)"
          :short "===========================================================\n Webster's Revised Unabridged Dictionary (1913)\n==========================================================="
          :formatter lexic-format-webster
          :priority 1)
         ("Soule's Dictionary of English Synonyms"
          :short "===========================================================\n Soule's Dictionary of English Synonyms (1871)\n==========================================================="
          :formatter lexic-format-soule
          :priority 2)
         ("Online Etymology Dictionary"
          :short "===========================================================\n Online Etymology Dictionary (2000)\n==========================================================="
          :formatter lexic-format-online-etym
          :priority 3)
         ("Oxford English Dictionary 2nd Ed P1"
          :short "===========================================================\n Oxford English Dictionary 2nd Ed. (1989)\n==========================================================="
          :formatter lexic-format-online-etym
          :priority 4)
         ("Oxford English Dictionary 2nd Ed P2"
          :short "===========================================================\n Oxford English Dictionary 2nd Ed. (1989)\n==========================================================="
          :formatter lexic-format-online-etym
          :priority 5)
         ("latin-english"
          :short "===========================================================\n Latin > English\n==========================================================="
          :formatter lexic-format-online-etym
          :priority 6))))

;;---------------------------------------------------------------------------
(map! :leader
      :desc "citar-open" "s SPC" #'citar-open)

(after! citar
  (setf
   citar-bibliography (list (concat +project-maria-dir+ "project-jerome.bib"))
   citar-notes-paths (list (concat +project-maria-dir+ "bibtex-notes"))
   citar-library-paths
   ;; Excluded trees are pruned DURING the walk (the PREDICATE arg stops
   ;; recursion), not filtered after it: email-archive alone holds tens of
   ;; thousands of files that the old post-hoc filter walked and then threw
   ;; away.  A pruned directory is still returned when INCLUDE-DIRECTORIES is
   ;; set, hence the final filter also checks membership.
   (let* ((base (expand-file-name "~/project-jerome"))
          (excluded (mapcar (lambda (d)
                              (directory-file-name (expand-file-name d)))
                            '("~/project-jerome/email-archive"
                              "~/project-jerome/org-attach-data"
                              "~/project-jerome/keepass-database")))
          (prune (lambda (d)
                   (not (member (directory-file-name (expand-file-name d))
                                excluded)))))
     (cons base
           (cl-delete-if-not
            (lambda (f) (and (funcall prune f) (file-directory-p f)))
            (directory-files-recursively base "" t prune))))))

;;---------------------------------------------------------------------------
;; Org Cite + biblatex-chicago (CMOS 17 Notes & Bibliography)
(after! oc
  (setf org-cite-global-bibliography
        (list (concat +project-maria-dir+ "project-jerome.bib"))
        org-cite-export-processors
        '((latex biblatex)
          (t basic))
        org-cite-insert-processor 'citar
        org-cite-follow-processor 'citar
        org-cite-activate-processor 'citar))

(after! ox-latex
  ;; Per-document opt-in: #+LATEX_CLASS: chicago-nb
  (add-to-list
   'org-latex-classes
   '("chicago-nb"
     "\\documentclass[12pt]{article}
[NO-DEFAULT-PACKAGES]
\\usepackage{graphicx}
\\usepackage{longtable}
\\usepackage{wrapfig}
\\usepackage{rotating}
\\usepackage[normalem]{ulem}
\\usepackage{amsmath}
\\usepackage{amssymb}
\\usepackage{capt-of}
\\usepackage[margin=1in]{geometry}
\\usepackage{setspace}\\doublespacing
\\usepackage{fontspec}
\\setmainfont{TeX Gyre Termes}
\\usepackage{csquotes}
\\usepackage[notes,backend=biber,babel=other,autolang=hyphen,strict]{biblatex-chicago}
\\addbibresource{/home/ben/project-maria/project-jerome.bib}
\\usepackage{hyperref}
\\makeatletter
\\let\\@course\\@empty
\\newcommand{\\course}[1]{\\gdef\\@course{#1}}
\\renewcommand{\\maketitle}{%
  \\begin{titlepage}%
    \\thispagestyle{empty}%
    \\begin{center}
      \\vspace*{0.28\\textheight}
      \\@title\\par
      \\vspace*{\\stretch{2}}
      \\@author\\par
      \\ifx\\@course\\@empty\\else\\vspace{1em}\\@course\\par\\fi
      \\vspace{1em}\\@date\\par
      \\vspace*{\\stretch{1}}
    \\end{center}%
  \\end{titlepage}}
\\makeatother
\\defbibheading{bibliography}[\\bibname]{%
  \\clearpage
  \\begin{center}\\textbf{#1}\\end{center}
  \\markboth{#1}{#1}}
[NO-PACKAGES]
[EXTRA]"
     ("\\section{%s}" . "\\section*{%s}")
     ("\\subsection{%s}" . "\\subsection*{%s}")
     ("\\subsubsection{%s}" . "\\subsubsection*{%s}")
     ("\\paragraph{%s}" . "\\paragraph*{%s}")
     ("\\subparagraph{%s}" . "\\subparagraph*{%s}")))

  (defun bhw/org-latex-export-to-pdf-chicago-nb (orig-fn &rest args)
    "Run lualatex+biber when the current org buffer uses LATEX_CLASS chicago-nb.
The hook variant runs inside the export copy buffer, so a `setq-local'
there is discarded before `org-latex-compile' reads the variable.
A dynamic `let' binding here propagates through the whole export pipeline."
    (if (save-excursion
          (goto-char (point-min))
          (re-search-forward
           "^#\\+LATEX_CLASS:[ \t]+chicago-nb\\b" nil t))
        (let ((org-latex-pdf-process
               '("latexmk -f -pdflua -interaction=nonstopmode -output-directory=%o %f"
                 "latexmk -c -output-directory=%o %f")))
          (apply orig-fn args))
      (apply orig-fn args)))
  (advice-add 'org-latex-export-to-pdf :around
              #'bhw/org-latex-export-to-pdf-chicago-nb))

  # See expenses divided by month and accounts
  ledger -M register Income:* Expenses:*

  # See expenses divided by month and accounts
  ledger balance --real

;;---------------------------------------------------------------------------
(after! sly
  (setq sly-contribs (delq 'sly-quicklisp sly-contribs)))

(setf common-lisp-hyperspec-root
      (concat "file://" +project-jerome-dir+
              "000-generalities-information-computers/000-computer-science/HyperSpec/"))
;; https://emacs.stackexchange.com/questions/62536/what-does-making-browse-url
;; -browser-function-local-to-eww-while-let-bound-m
(advice-add 'hyperspec-lookup
            :around
            (lambda (orig-fun &rest args)
              (setq-local browse-url-browser-function 'eww-browse-url)
              (apply orig-fun args)))

;;---------------------------------------------------------------------------
(after! evil-org
  (remove-hook 'org-tab-first-hook #'+org-cycle-only-current-subtree-h))

(after! org
  (add-hook! 'org-mode-hook (electric-indent-local-mode -1))
  (add-hook! 'org-mode-hook
    (add-hook 'completion-at-point-functions #'cape-file -10 t))

  (advice-remove #'org-mark-ring-push #'doom-set-jump-a)
  (setf org-adapt-indentation nil
        org-startup-indented nil
        ;; Be strict about extensions: match ".org" and ".org.gpg" only.
        org-id-extra-files (directory-files-recursively +project-maria-dir+ "\\.org\\(\\.gpg\\)?$"))
  (require 'cl-lib)

  ;; Adapted snippet (originally `afs/org-replace-link-by-link-description').
  (defun bhw/org-replace-link-by-link-description ()
    "Replace an org link by its description or if empty its address"
    (interactive)
    (if (org-in-regexp org-link-bracket-re 1)
        (save-excursion
          (let ((remove (list (match-beginning 0) (match-end 0)))
                (description
                 (if (match-end 2)
                     (org-match-string-no-properties 2)
                   (org-match-string-no-properties 1))))
            (apply 'delete-region remove)
            (insert description)))))

  (map! :leader
        :desc "Agenda" "a" #'bhw/custom-agenda))