pi-coding-agent-input-test.el

;;; pi-coding-agent-input-test.el --- Tests for pi-coding-agent-input -*- lexical-binding: t; -*-

;; Copyright (C) 2026 Daniel Nouri

;; Author: Daniel Nouri <daniel.nouri@gmail.com>

;;; Commentary:

;; Tests for input history, history isearch, send/abort commands,
;; message queuing, file reference completion, path completion,
;; and slash command completion — the input buffer layer.

;;; Code:

(require 'ert)
(require 'pi-coding-agent)
(require 'pi-coding-agent-test-common)

;;; Sending Prompts

(ert-deftest pi-coding-agent-test-send-extracts-text ()
  "pi-coding-agent-send extracts text from input buffer and clears it."
  (let ((sent-text nil))
    (pi-coding-agent-test-with-mock-session "/tmp/pi-coding-agent-test-send1/"
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (setq sent-text text)
                   (when on-success (funcall on-success)))))
        (with-current-buffer "*pi-coding-agent-input:/tmp/pi-coding-agent-test-send1/*"
          (insert "Hello, pi!")
          (pi-coding-agent-send)
          (should (equal sent-text "Hello, pi!"))
          (should (string-empty-p (buffer-string))))))))

(ert-deftest pi-coding-agent-test-send-empty-is-noop ()
  "pi-coding-agent-send with empty buffer does nothing."
  (let ((send-called nil))
    (pi-coding-agent-test-with-mock-session "/tmp/pi-coding-agent-test-send2/"
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (_) (setq send-called t))))
        (with-current-buffer "*pi-coding-agent-input:/tmp/pi-coding-agent-test-send2/*"
          (pi-coding-agent-send)
          (should-not send-called))))))

(ert-deftest pi-coding-agent-test-send-whitespace-only-is-noop ()
  "pi-coding-agent-send with only whitespace does nothing."
  (let ((send-called nil))
    (pi-coding-agent-test-with-mock-session "/tmp/pi-coding-agent-test-send3/"
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (_) (setq send-called t))))
        (with-current-buffer "*pi-coding-agent-input:/tmp/pi-coding-agent-test-send3/*"
          (insert "   \n\t  ")
          (pi-coding-agent-send)
          (should-not send-called))))))

(ert-deftest pi-coding-agent-test-send-queues-locally-while-streaming ()
  "pi-coding-agent-send adds to local queue while streaming, no RPC sent."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-stream*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-stream-input*"))
        (rpc-called nil)
        (message-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "My message")
            (cl-letf (((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq rpc-called t)))
                      ((symbol-function 'message)
                       (lambda (fmt &rest _)
                         (when (and fmt (string-match-p "queued" (downcase fmt)))
                           (setq message-shown t)))))
              (pi-coding-agent-send))
            ;; Should NOT have called RPC (local queue instead)
            (should-not rpc-called)
            ;; Should have added to local queue in chat buffer
            (with-current-buffer chat-buf
              (should (equal pi-coding-agent--followup-queue '("My message"))))
            ;; Should have shown queued message
            (should message-shown)
            ;; Input should be cleared (message accepted)
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-queues-locally-while-sending ()
  "pi-coding-agent-send adds to local queue while waiting for agent_start."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-sending*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-sending-input*"))
        (rpc-called nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'sending)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Queued while retry is starting")
            (cl-letf (((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq rpc-called t)))
                      ((symbol-function 'message) #'ignore))
              (pi-coding-agent-send))
            (should-not rpc-called)
            (with-current-buffer chat-buf
              (should (equal pi-coding-agent--followup-queue
                             '("Queued while retry is starting"))))
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-refuses-during-session-transition ()
  "A prompt typed while switching sessions is not queued into either session."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-send-transition*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-send-transition-input*"))
        (shown-message nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue nil)
            (pi-coding-agent--begin-session-transition 'mock-proc))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "not yet")
            (cl-letf (((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (setq shown-message (apply #'format fmt args)))))
              (pi-coding-agent-send))
            (should (equal (buffer-string) "not yet")))
          (with-current-buffer chat-buf
            (should (null pi-coding-agent--followup-queue)))
          (should (equal shown-message
                         "Pi: Cannot send while session is switching")))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-refuses-builtin-command-while-busy ()
  "Client-side slash commands are not hidden in the follow-up queue."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-builtin-busy*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-builtin-busy-input*"))
        (shown-message nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "/new")
            (cl-letf (((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (setq shown-message (apply #'format fmt args)))))
              (pi-coding-agent-send))
            (should (equal (buffer-string) "/new")))
          (with-current-buffer chat-buf
            (should (null pi-coding-agent--followup-queue)))
          (should (equal shown-message "Pi: Cannot queue /new while Pi is busy")))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-queues-locally-while-compacting ()
  "pi-coding-agent-send adds to local queue while compacting, no RPC sent."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-compact*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-compact-input*"))
        (rpc-called nil)
        (message-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'compacting)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "My message during compaction")
            (cl-letf (((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq rpc-called t)))
                      ((symbol-function 'message)
                       (lambda (fmt &rest _)
                         (when (and fmt (string-match-p "queued" (downcase fmt)))
                           (setq message-shown t)))))
              (pi-coding-agent-send))
            ;; Should NOT have called RPC (local queue instead)
            (should-not rpc-called)
            ;; Should have added to local queue in chat buffer
            (with-current-buffer chat-buf
              (should (equal pi-coding-agent--followup-queue '("My message during compaction"))))
            ;; Should have shown queued message
            (should message-shown)
            ;; Input should be cleared (message accepted)
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-slash-compact-handled-locally-not-sent-as-prompt ()
  "/compact in input buffer invokes pi-coding-agent-compact locally, not sent to pi."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-slash-compact*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-slash-compact-input*"))
        (compact-called nil)
        (compact-args nil)
        (prompt-sent nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "/compact")
            (cl-letf (((symbol-function 'pi-coding-agent-compact)
                       (lambda (&optional args) (setq compact-called t compact-args args)))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (_) (setq prompt-sent t))))
              (pi-coding-agent-send))
            ;; Should have called compact function with no args
            (should compact-called)
            (should (null compact-args))
            ;; Should NOT have sent as prompt
            (should-not prompt-sent)
            ;; Input should be cleared
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-slash-compact-with-args-passes-instructions ()
  "/compact with args passes custom instructions to compact function."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-slash-compact-args*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-slash-compact-args-input*"))
        (compact-called nil)
        (compact-args nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "/compact focus on the API design decisions")
            (cl-letf (((symbol-function 'pi-coding-agent-compact)
                       (lambda (&optional args) (setq compact-called t compact-args args))))
              (pi-coding-agent-send))
            ;; Should have called compact function with custom instructions
            (should compact-called)
            (should (equal compact-args "focus on the API design decisions"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-compaction-success-without-retry-sends-queued-message ()
  "Successful non-retry compaction schedules the oldest queued follow-up.
Uses :false (JSON false representation) to verify boolean normalization."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-text nil)
          drain-callback
          drain-args)
      (setq pi-coding-agent--status 'compacting)
      (setq pi-coding-agent--followup-queue '("queued message"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (setq sent-text text)
                   (when on-success (funcall on-success))))
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest args)
                   (setq drain-callback fn
                         drain-args args)
                   'fake-drain-timer)))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "threshold"
           :aborted :false
           :willRetry :false
           :result (:tokensBefore 1000 :summary "Summary" :timestamp 1234567890000)))
        (should (eq pi-coding-agent--status 'idle))
        (should (functionp drain-callback))
        (should (equal pi-coding-agent--followup-queue '("queued message")))
        (should (null sent-text))
        (apply drain-callback drain-args))
      ;; Queue should be empty after processing.
      (should (null pi-coding-agent--followup-queue))
      ;; The queued message should have been sent.
      (should (equal sent-text "queued message")))))

(ert-deftest pi-coding-agent-test-compaction-success-without-retry-preserves-fifo ()
  "Successful non-retry compaction schedules one follow-up in FIFO order."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-text nil)
          drain-callback
          drain-args)
      (setq pi-coding-agent--status 'compacting)
      (dolist (text '("First" "Second" "Third"))
        (pi-coding-agent--push-followup text))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (setq sent-text text)
                   (when on-success (funcall on-success))))
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest args)
                   (setq drain-callback fn
                         drain-args args)
                   'fake-drain-timer)))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "manual"
           :aborted :false
           :willRetry :false
           :result (:tokensBefore 1000 :summary "Summary")))
        (should (equal pi-coding-agent--followup-queue '("Third" "Second" "First")))
        (should (null sent-text))
        (apply drain-callback drain-args))
      (should (equal sent-text "First"))
      (should (equal pi-coding-agent--followup-queue '("Third" "Second"))))))

(ert-deftest pi-coding-agent-test-overflow-compaction-will-retry-preserves-followup-queue ()
  "Overflow compaction with automatic retry keeps local follow-ups queued."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-text nil))
      (setq pi-coding-agent--status 'compacting)
      (setq pi-coding-agent--followup-queue '("queued behind retry"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (setq sent-text text)
                   (when on-success (funcall on-success)))))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "overflow"
           :aborted :false
           :willRetry t
           :result (:tokensBefore 1000 :summary "Summary"))))
      (should (eq pi-coding-agent--status 'sending))
      (should (equal pi-coding-agent--followup-queue '("queued behind retry")))
      (should (null sent-text)))))

(ert-deftest pi-coding-agent-test-overflow-compaction-retry-drains-queue-after-agent-end ()
  "Queued follow-ups wait for Pi's automatic retry turn to finish."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-prompts nil)
          drain-callback
          drain-args)
      (setq pi-coding-agent--status 'compacting)
      (setq pi-coding-agent--followup-queue '("queued behind retry"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (push text sent-prompts)
                   (when on-success (funcall on-success))))
                ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest args)
                   (setq drain-callback fn
                         drain-args args)
                   'fake-drain-timer)))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "overflow"
           :aborted :false
           :willRetry t
           :result (:tokensBefore 1000 :summary "Summary")))
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue '("queued behind retry")))
        (should (null drain-callback))
        (pi-coding-agent--handle-display-event '(:type "agent_start"))
        (should (eq pi-coding-agent--status 'streaming))
        (pi-coding-agent--handle-display-event '(:type "agent_end" :messages []))
        (should (functionp drain-callback))
        (apply drain-callback drain-args))
      (should (equal (reverse sent-prompts) '("queued behind retry")))
      (should (null pi-coding-agent--followup-queue)))))

(ert-deftest pi-coding-agent-test-compaction-end-before-agent-start-defers-followup-drain ()
  "Queued follow-ups do not overtake Pi work that starts after compaction_end."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-prompts nil)
          first-drain-callback
          first-drain-args
          second-drain-callback
          second-drain-args)
      (setq pi-coding-agent--status 'compacting
            pi-coding-agent--followup-queue '("local follow-up after Pi queue"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (push text sent-prompts)
                   (when on-success (funcall on-success))))
                ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest args)
                   (if first-drain-callback
                       (setq second-drain-callback fn
                             second-drain-args args)
                     (setq first-drain-callback fn
                           first-drain-args args))
                   'fake-drain-timer)))
        ;; Pi can emit compaction_end and then immediately begin work it already
        ;; owns.  Local follow-ups must wait for that visible agent turn.
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "threshold"
           :aborted :false
           :willRetry :false
           :result (:tokensBefore 1000 :summary "Summary")))
        (should (eq pi-coding-agent--status 'idle))
        (should (functionp first-drain-callback))
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("local follow-up after Pi queue")))
        (pi-coding-agent--handle-display-event '(:type "agent_start"))
        ;; A stale scheduled drain may still fire, but streaming status makes it
        ;; a no-op.
        (apply first-drain-callback first-drain-args)
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("local follow-up after Pi queue")))
        (pi-coding-agent--handle-display-event '(:type "agent_end" :messages []))
        (should (functionp second-drain-callback))
        (apply second-drain-callback second-drain-args))
      (should (equal (reverse sent-prompts)
                     '("local follow-up after Pi queue")))
      (should (null pi-coding-agent--followup-queue)))))

(ert-deftest pi-coding-agent-test-agent-end-before-compaction-defers-followup-drain ()
  "Queued follow-ups do not overtake compaction that starts after agent_end."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-prompts nil)
          drain-callback
          drain-args)
      (setq pi-coding-agent--status 'streaming
            pi-coding-agent--followup-queue '("queued until compaction settles"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (push text sent-prompts)
                   (when on-success (funcall on-success))))
                ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest args)
                   (setq drain-callback fn
                         drain-args args)
                   'fake-drain-timer)))
        ;; Pi emits agent_end before post-run compaction_start.  The local
        ;; queue must wait long enough for that compaction event to claim the
        ;; next ordering slot.
        (pi-coding-agent--handle-display-event '(:type "agent_end" :messages []))
        (should (eq pi-coding-agent--status 'idle))
        (should (functionp drain-callback))
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("queued until compaction settles")))
        (pi-coding-agent--handle-display-event '(:type "compaction_start" :reason "threshold"))
        ;; A stale scheduled drain may still fire, but compacting status makes
        ;; it a no-op.
        (apply drain-callback drain-args)
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("queued until compaction settles")))
        (setq drain-callback nil
              drain-args nil)
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "threshold"
           :aborted :false
           :willRetry :false
           :result (:tokensBefore 1000 :summary "Summary")))
        (should (functionp drain-callback))
        (apply drain-callback drain-args))
      (should (equal (reverse sent-prompts)
                     '("queued until compaction settles")))
      (should (null pi-coding-agent--followup-queue)))))

(ert-deftest pi-coding-agent-test-preflight-compaction-keeps-followups-behind-prompt ()
  "Compaction during prompt preflight must not drain local follow-ups."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-prompts nil)
          drain-callback)
      (setq pi-coding-agent--status 'sending
            pi-coding-agent--pre-compaction-status nil
            pi-coding-agent--followup-queue '("queued behind original prompt"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (push text sent-prompts)
                   (when on-success (funcall on-success))))
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest _args)
                   (setq drain-callback fn)
                   'fake-drain-timer)))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_start" :reason "threshold"))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "threshold"
           :aborted :false
           :willRetry :false
           :result (:tokensBefore 1000 :summary "Summary")))
        (should (eq pi-coding-agent--status 'sending))
        (should (null drain-callback))
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("queued behind original prompt")))))))

(ert-deftest pi-coding-agent-test-failed-preflight-compaction-restores-followups-before-prompt-failure ()
  "Failed preflight compaction restores follow-ups while prompt failure is pending."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-preflight-compaction-failure-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-preflight-compaction-failure-input*"))
        (sent-text nil))
    (unwind-protect
        (progn
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (let ((generation (pi-coding-agent--begin-prompt-start-wait)))
              (setq pi-coding-agent--status 'sending
                    pi-coding-agent--input-buffer input-buf
                    pi-coding-agent--pre-compaction-status nil
                    pi-coding-agent--followup-queue '("follow-up after prompt"))
              (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                         (lambda (text &optional on-success &rest _)
                           (setq sent-text text)
                           (when on-success (funcall on-success))))
                        ((symbol-function 'message) #'ignore))
                (pi-coding-agent--handle-display-event
                 '(:type "compaction_start" :reason "threshold"))
                (pi-coding-agent--handle-display-event
                 '(:type "compaction_end"
                   :reason "threshold"
                   :aborted :false
                   :willRetry :false
                   :result :null
                   :errorMessage "quota exceeded")))
              (should (eq pi-coding-agent--status 'idle))
              (should (equal pi-coding-agent--activity-phase "thinking"))
              (should (pi-coding-agent--prompt-start-current-p generation))
              (should (null pi-coding-agent--followup-queue))
              (should (null sent-text))))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "follow-up after prompt"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-aborted-preflight-compaction-clears-followups-before-prompt-failure ()
  "Aborted preflight compaction clears follow-ups while prompt failure is pending."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-text nil))
      (pi-coding-agent--begin-prompt-start-wait)
      (setq pi-coding-agent--status 'sending
            pi-coding-agent--pre-compaction-status nil
            pi-coding-agent--followup-queue '("discarded follow-up"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (setq sent-text text)
                   (when on-success (funcall on-success))))
                ((symbol-function 'message) #'ignore))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_start" :reason "threshold"))
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "threshold"
           :aborted t
           :willRetry :false
           :result nil)))
      (should (eq pi-coding-agent--status 'idle))
      (should (equal pi-coding-agent--activity-phase "thinking"))
      (should (null pi-coding-agent--followup-queue))
      (should (null sent-text)))))

(ert-deftest pi-coding-agent-test-failed-preflight-compaction-prompt-failure-restores-original ()
  "Prompt RPC failure clears preflight wait after compaction failure."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-preflight-prompt-failure-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-preflight-prompt-failure-input*"))
        (rpc-callback nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--activity-phase "idle"
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("queued follow-up")))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "original prompt"))
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () 'mock-proc))
                    ((symbol-function 'process-live-p) (lambda (_) t))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _cmd callback)
                       (setq rpc-callback callback)))
                    ((symbol-function 'message) #'ignore))
            (with-current-buffer input-buf
              (pi-coding-agent-send))
            (with-current-buffer chat-buf
              (pi-coding-agent--handle-display-event
               '(:type "compaction_start" :reason "threshold"))
              (pi-coding-agent--handle-display-event
               '(:type "compaction_end"
                 :reason "threshold"
                 :aborted :false
                 :willRetry :false
                 :result :null
                 :errorMessage "quota exceeded"))
              (should (pi-coding-agent--session-busy-p chat-buf))
              (funcall rpc-callback '(:success :false :error "quota exceeded"))
              (should (eq pi-coding-agent--status 'idle))
              (should (equal pi-coding-agent--activity-phase "idle"))
              (should-not (pi-coding-agent--session-busy-p chat-buf))))
          (with-current-buffer input-buf
            (should (equal (buffer-string)
                           "original prompt\n\nqueued follow-up"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-agent-end-will-retry-preserves-followup-queue ()
  "agent_end with willRetry keeps local follow-ups behind Pi's retry."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-prompts nil)
          drain-callback
          drain-args)
      (setq pi-coding-agent--status 'streaming
            pi-coding-agent--followup-queue '("queued behind transient retry"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (push text sent-prompts)
                   (when on-success (funcall on-success))))
                ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                ((symbol-function 'run-at-time)
                 (lambda (_secs _repeat fn &rest args)
                   (setq drain-callback fn
                         drain-args args)
                   'fake-drain-timer)))
        (pi-coding-agent--handle-display-event
         '(:type "agent_end" :messages [] :willRetry t))
        (should (eq pi-coding-agent--status 'sending))
        (should (null drain-callback))
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("queued behind transient retry")))
        (pi-coding-agent--handle-display-event '(:type "agent_start"))
        (pi-coding-agent--handle-display-event '(:type "agent_end" :messages []))
        (should (functionp drain-callback))
        (apply drain-callback drain-args))
      (should (equal (reverse sent-prompts)
                     '("queued behind transient retry")))
      (should (null pi-coding-agent--followup-queue)))))

(ert-deftest pi-coding-agent-test-compaction-failure-restores-queued-followups ()
  "Failed compaction surfaces queued follow-ups for user recovery."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-compaction-failure-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-compaction-failure-input*"))
        (sent-text nil))
    (unwind-protect
        (progn
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'compacting
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("recover me later"))
            (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (text &optional on-success &rest _)
                         (setq sent-text text)
                         (when on-success (funcall on-success))))
                      ((symbol-function 'message) #'ignore))
              (pi-coding-agent--handle-display-event
               '(:type "compaction_end"
                 :reason "threshold"
                 :aborted :false
                 :willRetry :false
                 :result :null
                 :errorMessage "quota exceeded")))
            (should (eq pi-coding-agent--status 'idle))
            (should (null pi-coding-agent--followup-queue))
            (should (null sent-text)))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "recover me later"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-auto-retry-failure-restores-queued-followups ()
  "Final auto-retry failure surfaces queued follow-ups for user recovery."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-retry-failure-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-retry-failure-input*")))
    (unwind-protect
        (progn
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'sending
                  pi-coding-agent--activity-phase "thinking"
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("queued behind failed retry"))
            (pi-coding-agent--handle-display-event
             '(:type "auto_retry_end"
               :success :false
               :attempt 3
               :finalError "overloaded"))
            (should (eq pi-coding-agent--status 'idle))
            (should (equal pi-coding-agent--activity-phase "idle"))
            (should (null pi-coding-agent--followup-queue))
            (should (string-match-p "Retry failed" (buffer-string))))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "queued behind failed retry"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-compaction-end-aborted-clears-queue ()
  "compaction_end when aborted clears followup queue without sending."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-text nil))
      (setq pi-coding-agent--status 'compacting)
      (setq pi-coding-agent--followup-queue '("queued message"))
      (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                 (lambda (text &optional on-success &rest _)
                   (setq sent-text text)
                   (when on-success (funcall on-success)))))
        ;; Simulate compaction_end event (aborted)
        (pi-coding-agent--handle-display-event
         '(:type "compaction_end"
           :reason "threshold"
           :aborted t)))
      ;; Queue should be cleared (user cancelled)
      (should (null pi-coding-agent--followup-queue))
      ;; No message should have been sent
      (should (null sent-text)))))

;;; Abort Command

(ert-deftest pi-coding-agent-test-abort-sends-command ()
  "pi-coding-agent-abort sends abort command while streaming."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-command nil)
          (pi-coding-agent--status 'streaming))
      (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                ((symbol-function 'pi-coding-agent--get-chat-buffer) (lambda () (current-buffer)))
                ((symbol-function 'pi-coding-agent--rpc-async)
                 (lambda (_proc cmd _cb) (setq sent-command cmd))))
        (pi-coding-agent-abort)
        (should (equal (plist-get sent-command :type) "abort"))
        (should pi-coding-agent--aborted)))))

(ert-deftest pi-coding-agent-test-abort-sends-command-while-compacting ()
  "pi-coding-agent-abort sends abort command while compacting."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-command nil)
          (pi-coding-agent--status 'compacting))
      (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                ((symbol-function 'pi-coding-agent--get-chat-buffer) (lambda () (current-buffer)))
                ((symbol-function 'pi-coding-agent--rpc-async)
                 (lambda (_proc cmd _cb) (setq sent-command cmd))))
        (pi-coding-agent-abort)
        (should (equal (plist-get sent-command :type) "abort"))
        (should-not pi-coding-agent--aborted)))))

(ert-deftest pi-coding-agent-test-abort-noop-when-idle ()
  "pi-coding-agent-abort does nothing when idle."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((sent-command nil)
          (pi-coding-agent--status 'idle))
      (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                ((symbol-function 'pi-coding-agent--get-chat-buffer) (lambda () (current-buffer)))
                ((symbol-function 'pi-coding-agent--rpc-async)
                 (lambda (_proc cmd _cb) (setq sent-command cmd))))
        (pi-coding-agent-abort)
        (should (null sent-command))))))

(ert-deftest pi-coding-agent-test-abort-clears-followup-queue ()
  "Aborting clears the follow-up queue so queued messages are not sent.
When user aborts, they want to stop everything - including queued messages."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((inhibit-read-only t)
          (message-was-sent nil))
      (insert "Some streaming content")
      ;; Set up state as if we're streaming with a queued message
      (setq pi-coding-agent--aborted t
            pi-coding-agent--followup-queue '("queued message that should be discarded"))
      ;; Mock send functions to detect if queue processing sends the message
      (cl-letf (((symbol-function 'pi-coding-agent--prepare-and-send)
                 (lambda (_text) (setq message-was-sent t)))
                ((symbol-function 'pi-coding-agent--refresh-header) #'ignore))
        ;; Simulate agent_end arriving after abort
        (pi-coding-agent--display-agent-end)
        ;; Queue should be empty (either cleared or not processed)
        (should (null pi-coding-agent--followup-queue))
        ;; Key assertion: queued message should NOT have been sent
        (should-not message-was-sent)))))

;;; Kill Buffer Protection

(ert-deftest pi-coding-agent-test-handler-removed-on-kill ()
  "Event handler is removed when chat buffer is killed."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((fake-proc (start-process "test" nil "true")))
      (unwind-protect
          (progn
            (setq pi-coding-agent--process fake-proc)
            (pi-coding-agent--register-display-handler fake-proc)
            (should (process-get fake-proc 'pi-coding-agent-display-handler))
            (pi-coding-agent--cleanup-on-kill)
            (should-not (process-get fake-proc 'pi-coding-agent-display-handler)))
        (when (process-live-p fake-proc)
          (delete-process fake-proc))))))

;;; Message Queuing

(ert-deftest pi-coding-agent-test-queue-steering-when-streaming-sends-steer ()
  "Queue steering sends steer RPC command when agent is streaming."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-steer*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-input*"))
        (sent-command nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Please stop and focus on X")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc cmd _cb) (setq sent-command cmd))))
              (pi-coding-agent-queue-steering))
            ;; Should send steer command
            (should sent-command)
            (should (equal (plist-get sent-command :type) "steer"))
            (should (equal (plist-get sent-command :message) "Please stop and focus on X"))
            ;; Input should be cleared
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-steering-when-sending-sends-steer ()
  "Queue steering sends steer RPC while waiting for agent_start."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-sending*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-sending-input*"))
        (sent-command nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'sending)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Steer the pending retry")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc cmd _cb) (setq sent-command cmd))))
              (pi-coding-agent-queue-steering))
            (should sent-command)
            (should (equal (plist-get sent-command :type) "steer"))
            (should (equal (plist-get sent-command :message) "Steer the pending retry"))
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-steering-refuses-during-session-transition ()
  "Steering must not bypass the session-transition send guard."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-steer-transition*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-steer-transition-input*"))
        (steer-sent nil)
        (shown-message nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue nil)
            (pi-coding-agent--begin-session-transition 'mock-proc))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (pi-coding-agent--set-chat-buffer chat-buf)
            (insert "do not steer during switch")
            (cl-letf (((symbol-function 'pi-coding-agent--send-steer-message)
                       (lambda (_text)
                         (setq steer-sent t)
                         t))
                      ((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (setq shown-message (apply #'format fmt args)))))
              (pi-coding-agent-queue-steering))
            (should-not steer-sent)
            (should (equal (buffer-string) "do not steer during switch")))
          (with-current-buffer chat-buf
            (should (null pi-coding-agent--followup-queue)))
          (should (equal shown-message
                         "Pi: Cannot send steering while session is switching")))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-steering-send-failure-preserves-input ()
  "Steering send failures keep input text for retry and avoid success feedback."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-fail*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-fail-input*"))
        (success-message nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Retry this steer")
            (cl-letf (((symbol-function 'pi-coding-agent--send-steer-message)
                       (lambda (_text) nil))
                      ((symbol-function 'message)
                       (lambda (fmt &rest _)
                         (when (and fmt (string-match-p "steering message sent" (downcase fmt)))
                           (setq success-message t)))))
              (pi-coding-agent-queue-steering))
            ;; Failed send should keep input so user can retry.
            (should (equal (buffer-string) "Retry this steer"))
            ;; Should not claim success.
            (should-not success-message)
            ;; Failed send should not enqueue a normal follow-up.
            (with-current-buffer chat-buf
              (should (null pi-coding-agent--followup-queue)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-steering-while-compacting-queues-locally ()
  "Queue steering during compaction should queue locally instead of sending steer now."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-compacting*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-compacting-input*"))
        (steer-sent nil)
        (shown-message nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'compacting)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Steer during compaction")
            (cl-letf (((symbol-function 'pi-coding-agent--send-steer-message)
                       (lambda (_text)
                         (setq steer-sent t)
                         t))
                      ((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (setq shown-message (apply #'format fmt args)))))
              (pi-coding-agent-queue-steering))
            ;; Should NOT send steer immediately
            (should-not steer-sent)
            ;; Should queue in local follow-up queue
            (with-current-buffer chat-buf
              (should (equal pi-coding-agent--followup-queue '("Steer during compaction"))))
            ;; Should tell user it was queued without over-promising timing.
            (should (equal shown-message "Pi: Steering queued (will send when Pi is ready)"))
            ;; Input should be cleared
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-steering-and-send-during-compaction-preserve-fifo ()
  "Steering and normal sends queued during compaction keep FIFO order."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-compaction-fifo*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-compaction-fifo-input*"))
        (sent-prompts nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'compacting)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (cl-letf (((symbol-function 'message) #'ignore))
              (insert "Steering first")
              (pi-coding-agent-queue-steering)
              (insert "Normal send second")
              (pi-coding-agent-send)))
          (with-current-buffer chat-buf
            (should (equal pi-coding-agent--followup-queue
                           '("Normal send second" "Steering first")))
            (let (drain-callback
                  drain-args)
              (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                         (lambda (text &optional on-success &rest _)
                           (push text sent-prompts)
                           (when on-success (funcall on-success))))
                        ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                        ((symbol-function 'run-at-time)
                         (lambda (_secs _repeat fn &rest args)
                           (setq drain-callback fn
                                 drain-args args)
                           'fake-drain-timer)))
                (pi-coding-agent--handle-display-event
                 '(:type "compaction_end"
                   :reason "threshold"
                   :aborted :false
                   :willRetry :false
                   :result (:tokensBefore 1000 :summary "Summary")))
                (should (functionp drain-callback))
                (apply drain-callback drain-args)
                (setq drain-callback nil
                      drain-args nil)
                (pi-coding-agent--handle-display-event '(:type "agent_end" :messages []))
                (should (functionp drain-callback))
                (apply drain-callback drain-args)))
            (should (equal (reverse sent-prompts)
                           '("Steering first" "Normal send second")))
            (should (null pi-coding-agent--followup-queue))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queued-builtin-command-restores-input-without-running ()
  "Stale queued built-in commands are surfaced instead of run from a timer."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queued-builtin-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queued-builtin-input*"))
        (new-session-called nil)
        (shown-message nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("/new")))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (with-current-buffer chat-buf
            (cl-letf (((symbol-function 'pi-coding-agent-new-session)
                       (lambda () (setq new-session-called t)))
                      ((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (setq shown-message (apply #'format fmt args)))))
              (pi-coding-agent--process-followup-queue))
            (should-not new-session-called)
            (should (null pi-coding-agent--followup-queue)))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "/new")))
          (should (equal shown-message
                         "Pi: Cannot run queued /new command automatically")))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-followup-uses-local-queue ()
  "Queue follow-up adds to local queue, no RPC sent."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-followup*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-followup-input*"))
        (rpc-called nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "After you're done, also do Y")
            (cl-letf (((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq rpc-called t))))
              (pi-coding-agent-queue-followup))
            ;; Should NOT call RPC
            (should-not rpc-called)
            ;; Should add to local queue
            (with-current-buffer chat-buf
              (should (member "After you're done, also do Y" pi-coding-agent--followup-queue)))
            ;; Input should be cleared
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-steering-when-idle-refuses ()
  "Queue steering refuses when agent is idle (nothing to interrupt)."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-idle*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-steer-idle-input*"))
        (sent-anything nil)
        (message-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Do something")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (_) (setq sent-anything t)))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq sent-anything t)))
                      ((symbol-function 'message)
                       (lambda (fmt &rest _)
                         (when (and fmt (string-match-p "nothing\\|idle\\|C-c C-c" (downcase fmt)))
                           (setq message-shown t)))))
              (pi-coding-agent-queue-steering))
            ;; Should NOT send anything
            (should-not sent-anything)
            ;; Should show message about using C-c C-c instead
            (should message-shown)
            ;; Input should be preserved (not accepted)
            (should (equal (buffer-string) "Do something"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-followup-when-idle-sends-prompt ()
  "Queue follow-up sends as normal prompt when agent is idle."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-followup-idle*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-followup-idle-input*"))
        (sent-prompt nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Do something else")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (text &optional on-success &rest _)
                         (setq sent-prompt text)
                         (when on-success (funcall on-success)))))
              (pi-coding-agent-queue-followup))
            ;; Should send as normal prompt
            (should (equal sent-prompt "Do something else"))
            ;; Input should be cleared
            (should (string-empty-p (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-steering-adds-to-history ()
  "Queue steering adds input to history."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-hist*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-hist-input*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (setq pi-coding-agent--input-ring (make-ring 10))
            (insert "History test message")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async) #'ignore))
              (pi-coding-agent-queue-steering))
            ;; Should be in history
            (should (not (ring-empty-p pi-coding-agent--input-ring)))
            (should (equal (ring-ref pi-coding-agent--input-ring 0) "History test message"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-empty-input-does-nothing ()
  "Queue with empty input does nothing."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-empty*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-empty-input*"))
        (command-sent nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            ;; Empty input (just whitespace)
            (insert "   \n  ")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq command-sent t))))
              (pi-coding-agent-queue-steering))
            ;; Should not send anything
            (should-not command-sent)))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-steering-shows-minibuffer-message ()
  "Steering shows feedback in minibuffer but is NOT displayed locally.
Unlike normal sends, steering waits for pi's echo to display at the
correct position in the conversation."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-display*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-display-input*"))
        (message-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "My steering message")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async) #'ignore)
                      ((symbol-function 'message)
                       (lambda (fmt &rest _)
                         (when (and fmt (string-match-p "steering\\|sent" (downcase fmt)))
                           (setq message-shown t)))))
              (pi-coding-agent-queue-steering)))
          ;; Should show minibuffer message
          (should message-shown)
          ;; Steering is NOT displayed locally - will be displayed when pi echoes it back
          (with-current-buffer chat-buf
            (should-not (string-match-p "My steering message" (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-input-mode-has-queue-keybindings ()
  "Input mode has C-c C-s for steering (C-c C-c handles follow-up)."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should (eq (key-binding (kbd "C-c C-s")) 'pi-coding-agent-queue-steering))
    ;; C-c C-c handles follow-up when streaming (no separate C-c C-q)
    (should (eq (key-binding (kbd "C-c C-c")) 'pi-coding-agent-send))))

(ert-deftest pi-coding-agent-test-queue-handles-rpc-error ()
  "Queue handles RPC error response by showing message to user."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-error*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-error-input*"))
        (captured-callback nil)
        (error-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Test message")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd cb) (setq captured-callback cb)))
                      ((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (when (and fmt (string-match-p "error\\|fail" (downcase fmt)))
                           (setq error-shown t)))))
              (pi-coding-agent-queue-steering)
              ;; Simulate error response from RPC
              (when captured-callback
                (funcall captured-callback '(:success :false :error "Queue limit reached")))))
          ;; Should have shown an error message
          (should error-shown))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queue-with-dead-process-shows-error ()
  "Queue with dead process shows error message."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queue-dead*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queue-dead-input*"))
        (error-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Test message")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () nil))
                      ((symbol-function 'message)
                       (lambda (fmt &rest args)
                         (when (and fmt (string-match-p "process\\|unavailable\\|error" (downcase fmt)))
                           (setq error-shown t)))))
              (pi-coding-agent-queue-steering)))
          ;; Should have shown an error about unavailable process
          (should error-shown))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-when-idle-sends-literal-commands ()
  "C-c C-c when idle sends commands literally (pi expands)."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-send-slash*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-send-slash-input*"))
        (sent-prompt nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "/greet world")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (text &optional on-success &rest _)
                         (setq sent-prompt text)
                         (when on-success (funcall on-success)))))
              (pi-coding-agent-send))
            ;; Should send literal command (pi handles expansion)
            (should (equal sent-prompt "/greet world"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

;; Note: pi-coding-agent-test-send-queues-locally-while-streaming covers this case

(ert-deftest pi-coding-agent-test-steering-when-idle-refuses ()
  "C-c C-s when idle shows message and does nothing."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-steer-idle*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-steer-idle-input*"))
        (send-called nil)
        (message-shown nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Steer message")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (_) (setq send-called t)))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _cmd _cb) (setq send-called t)))
                      ((symbol-function 'message)
                       (lambda (fmt &rest _)
                         (when (and fmt (string-match-p "idle\\|nothing\\|use" (downcase fmt)))
                           (setq message-shown t)))))
              (pi-coding-agent-queue-steering))
            ;; Should NOT have sent anything
            (should-not send-called)
            ;; Should have shown a message
            (should message-shown)
            ;; Input should be preserved
            (should (equal (buffer-string) "Steer message"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-message-start-user-echo-ignored-when-displayed-locally ()
  "message_start role=user is ignored when we already displayed the same message locally.
Uses local-user-message to track what we displayed for comparison."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((pi-coding-agent--status 'streaming)
          (pi-coding-agent--state nil)
          ;; Simulate that we displayed this message locally (normal send)
          (pi-coding-agent--local-user-message "Same message")
          (initial-content (buffer-string)))
      ;; Simulate receiving message_start for a user message (pi echoing back same text)
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "user"
                   :content [(:type "text" :text "Same message")]
                   :timestamp 1704067200000)))
      ;; Buffer should be unchanged - pi's echo matches local display, so skip
      (should (equal (buffer-string) initial-content))
      (should-not (string-match-p "Same message" (buffer-string)))
      ;; Variable should be cleared
      (should-not pi-coding-agent--local-user-message))))

(ert-deftest pi-coding-agent-test-message-start-user-displayed-when-different ()
  "message_start role=user IS displayed when pi's text differs from local.
+This handles slash command expansion: user types '/greet', pi sends 'Hello!'."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((pi-coding-agent--status 'streaming)
          (pi-coding-agent--state nil)
          (pi-coding-agent--local-user-message "/greet world")
          (initial-content (buffer-string)))
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "user"
                   :content [(:type "text" :text "Hello world!")]
                   :timestamp 1704067200000)))
      ;; Should be displayed since text differs (expanded template)
      (should (string-match-p "Hello world!" (buffer-string)))
      (should-not pi-coding-agent--local-user-message))))

(ert-deftest pi-coding-agent-test-message-start-user-skipped-when-template-equals-command ()
  "Edge case: if template expands to exactly the command text, we skip display.
This is rare but possible - the local display is already correct."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((pi-coding-agent--status 'streaming)
          (pi-coding-agent--state nil)
          (pi-coding-agent--local-user-message "/echo hello")
          (initial-content (buffer-string)))
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "user"
                   :content [(:type "text" :text "/echo hello")]
                   :timestamp 1704067200000)))
      ;; Should NOT be displayed - text matches what we displayed locally
      (should (equal (buffer-string) initial-content))
      (should-not pi-coding-agent--local-user-message))))

(ert-deftest pi-coding-agent-test-message-start-user-displayed-when-not-local ()
  "message_start role=user IS displayed when local-user-message is nil (steering case).
Steering messages are not displayed locally - they're displayed from the echo."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((pi-coding-agent--status 'streaming)
          (pi-coding-agent--state nil)
          ;; Variable is nil - no locally displayed message pending
          (pi-coding-agent--local-user-message nil))
      ;; Simulate receiving message_start for a steering message
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "user"
                   :content [(:type "text" :text "Steering message here")]
                   :timestamp 1704067200000)))
      ;; Should be displayed since local-user-message was nil
      (should (string-match-p "Steering message here" (buffer-string)))
      ;; Variable should still be nil
      (should-not pi-coding-agent--local-user-message))))

(ert-deftest pi-coding-agent-test-steering-display-not-interleaved ()
  "Steering message during streaming appears cleanly, not interleaved.
When user sends steering while assistant is streaming, the sequence is:
1. Current assistant output ends cleanly
2. User steering message with header appears
3. New assistant turn begins with its own header

This tests for a bug where user message header and assistant text got
mixed together like:
  > ...count from 1 to
  You · 01:32
  ===========
  STOP NOW
  10 slowly...  <- WRONG: '10 slowly' is assistant text after user msg!"
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((pi-coding-agent--status 'streaming)
          (pi-coding-agent--state nil)
          (pi-coding-agent--local-user-message nil)
          (pi-coding-agent--assistant-header-shown nil))
      ;; Simulate initial prompt response - assistant starts streaming
      (pi-coding-agent--handle-display-event '(:type "agent_start"))
      (pi-coding-agent--handle-display-event
       '(:type "message_start" :message (:role "assistant")))
      ;; Stream some content
      (pi-coding-agent--handle-display-event
       '(:type "message_update"
         :assistantMessageEvent (:type "text_delta" :delta "Counting: 1, 2, 3, ")))
      (pi-coding-agent--handle-display-event
       '(:type "message_update"
         :assistantMessageEvent (:type "text_delta" :delta "4, 5, 6, ")))

      ;; Now user sends steering - this comes as message_start with role=user
      ;; (steering messages are displayed from pi's echo, not locally)
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "user"
                   :content [(:type "text" :text "STOP-MARKER")]
                   :timestamp 1704067200000)))

      ;; Assistant continues with new turn after steering
      (setq pi-coding-agent--assistant-header-shown nil)  ; Reset for new turn
      (pi-coding-agent--handle-display-event '(:type "agent_start"))
      (pi-coding-agent--handle-display-event
       '(:type "message_start" :message (:role "assistant")))
      (pi-coding-agent--handle-display-event
       '(:type "message_update"
         :assistantMessageEvent (:type "text_delta" :delta "OK, stopping.")))
      (pi-coding-agent--handle-display-event '(:type "agent_end"))

      ;; Now verify the buffer structure
      (let ((content (buffer-string)))
        ;; All expected content should be present
        (should (string-match-p "Counting: 1, 2, 3, 4, 5, 6," content))
        (should (string-match-p "STOP-MARKER" content))
        (should (string-match-p "OK, stopping" content))

        ;; Find positions to verify order
        (let ((first-assistant-pos (string-match "Counting:" content))
              (steering-pos (string-match "STOP-MARKER" content))
              (second-response-pos (string-match "OK, stopping" content)))
          ;; Order must be: first-assistant < steering < second-response
          (should (< first-assistant-pos steering-pos))
          (should (< steering-pos second-response-pos))

          ;; "You" header must appear before the steering message
          (let ((you-header-pos (string-match "You" content)))
            (should you-header-pos)
            (should (< you-header-pos steering-pos)))

          ;; After STOP-MARKER, we should see "Assistant" header before second response
          (let* ((after-steering (substring content steering-pos))
                 (assistant-after-steering (string-match "Assistant" after-steering)))
            (should assistant-after-steering)))

        ;; Verify NO interleaving: counting text should NOT appear after STOP-MARKER
        (let* ((steering-pos (string-match "STOP-MARKER" content))
               (after-steering (substring content (+ steering-pos (length "STOP-MARKER")))))
          ;; Should NOT see counting continuation after the steering message
          (should-not (string-match-p "^[0-9]" (string-trim-left after-steering)))
          (should-not (string-match-p "^, [0-9]" (string-trim-left after-steering))))))))

(ert-deftest pi-coding-agent-test-local-user-message-tracks-display ()
  "The local-user-message variable tracks locally displayed messages.
- Normal send stores the text
- message_start role=user clears it to nil
- Steering doesn't set it (displayed from echo)
- agent_end clears it to nil"
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-echo-flag*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-echo-flag-input*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf)
            ;; Variable starts as nil
            (should-not pi-coding-agent--local-user-message))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "First message")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (_text &optional on-success &rest _)
                         (when on-success
                           (funcall on-success)))))
              (pi-coding-agent-send)))
          ;; After accepted normal send, variable should store the message text
          (with-current-buffer chat-buf
            (should (equal pi-coding-agent--local-user-message "First message"))
            ;; Simulate pi echo - variable clears to nil
            (pi-coding-agent--handle-display-event
             '(:type "message_start"
               :message (:role "user" :content [(:type "text" :text "First message")])))
            (should-not pi-coding-agent--local-user-message)
            ;; Now simulate steering (doesn't set it)
            (setq pi-coding-agent--status 'streaming))
          (with-current-buffer input-buf
            (erase-buffer)
            (insert "Steer this")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async) #'ignore))
              (pi-coding-agent-queue-steering)))
          ;; Variable still nil (steering doesn't set it)
          (with-current-buffer chat-buf
            (should-not pi-coding-agent--local-user-message)
            ;; agent_end clears to nil (in case of edge cases)
            (setq pi-coding-agent--local-user-message "test")  ; Simulate weird state
            (pi-coding-agent--display-agent-end)
            (should-not pi-coding-agent--local-user-message)))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-normal-send-not-duplicated-by-message-start ()
  "Accepted normal sends should not be duplicated when message_start arrives.
When prompt preflight succeeds, we display the user text locally.  When pi
echoes it back via message_start, we should NOT display it again."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-no-dup*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-no-dup-input*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle)
            (setq pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Hello pi")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (_text &optional on-success &rest _)
                         (when on-success
                           (funcall on-success)))))
              (pi-coding-agent-send)))
          ;; Now simulate pi echoing the message back via message_start
          (with-current-buffer chat-buf
            (pi-coding-agent--handle-display-event
             '(:type "message_start"
               :message (:role "user"
                         :content [(:type "text" :text "Hello pi")]
                         :timestamp 1704067200000)))
            ;; Count occurrences of "Hello pi" - should be exactly 1
            (let ((count 0)
                  (start 0))
              (while (string-match "Hello pi" (buffer-string) start)
                (setq count (1+ count))
                (setq start (match-end 0)))
              (should (= count 1)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-agent-end-sends-queued-followup ()
  "agent_end schedules the queued follow-up after post-run events settle.
When user queues a follow-up (busy state), it goes to the local queue.
After an agent_end with no retry or compaction, the scheduled drain pops
from the queue and sends it as a normal prompt."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-agent-end-queue*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-agent-end-queue-input*"))
        (sent-prompt nil)
        drain-callback
        drain-args)
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil)
            ;; Simulate some prior content
            (let ((inhibit-read-only t))
              (insert "Assistant\n=========\nSome response...\n")))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "My follow-up question")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t)))
              (pi-coding-agent-send)))  ; Adds to local queue when streaming
          ;; Message should be in queue, not in chat yet
          (with-current-buffer chat-buf
            (should (equal pi-coding-agent--followup-queue '("My follow-up question")))
            (should-not (string-match-p "My follow-up question" (buffer-string))))
          ;; Now simulate agent_end.  It should not drain synchronously, so an
          ;; immediately following compaction_start would still be able to
          ;; preserve ordering.
          (with-current-buffer chat-buf
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (text &optional on-success &rest _)
                         (setq sent-prompt text)
                         (when on-success (funcall on-success))))
                      ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                      ((symbol-function 'run-at-time)
                       (lambda (_secs _repeat fn &rest args)
                         (setq drain-callback fn
                               drain-args args)
                         'fake-drain-timer)))
              (pi-coding-agent--handle-display-event '(:type "agent_end"))
              (should (functionp drain-callback))
              (should (equal pi-coding-agent--followup-queue '("My follow-up question")))
              (should (null sent-prompt))
              (apply drain-callback drain-args))
            ;; Queue should be empty now
            (should (null pi-coding-agent--followup-queue))
            ;; Should have sent the queued message
            (should (equal sent-prompt "My follow-up question"))
            ;; Message should now be displayed in chat
            (should (string-match-p "My follow-up question" (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-queues-while-followup-drain-pending ()
  "New input waits behind an older queued follow-up drain."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-drain-pending-send*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-drain-pending-send-input*"))
        (sent-prompt nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("older queued follow-up")
                  pi-coding-agent--followup-drain-timer 'fake-drain-timer))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "new prompt during drain window")
            (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (text &optional on-success &rest _)
                         (setq sent-prompt text)
                         (when on-success (funcall on-success))))
                      ((symbol-function 'message) #'ignore))
              (pi-coding-agent-send))
            (should (string-empty-p (buffer-string))))
          (with-current-buffer chat-buf
            (should (null sent-prompt))
            (should (equal pi-coding-agent--followup-queue
                           '("new prompt during drain window"
                             "older queued follow-up")))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-queues-when-stale-state-arrives-before-agent-start ()
  "A stale idle get_state response must not open a second-send gap."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-stale-state-send-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-stale-state-send-input*"))
        (sent-prompts nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--state '(:session-id "same-session")))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () 'mock-proc))
                    ((symbol-function 'process-live-p) (lambda (_) t))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc cmd _callback)
                       (push (plist-get cmd :message) sent-prompts))))
            (with-current-buffer input-buf
              (insert "first prompt")
              (pi-coding-agent-send))
            (with-current-buffer chat-buf
              (pi-coding-agent--apply-state-response
               chat-buf
               '(:success t :data (:isStreaming :false
                                   :isCompacting :false
                                   :sessionId "same-session"
                                   :sessionFile "/tmp/same.jsonl"))))
            (with-current-buffer input-buf
              (insert "second prompt")
              (pi-coding-agent-send)))
          (with-current-buffer chat-buf
            (should (equal (reverse sent-prompts) '("first prompt")))
            (should (equal pi-coding-agent--followup-queue
                           '("second prompt")))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-process-followup-queue-waits-until-ready ()
  "Direct queue draining keeps its own safe-to-send guard."
  (dolist (case '((sending nil nil)
                  (streaming nil nil)
                  (compacting nil nil)
                  (idle "pending local echo" nil)
                  (idle nil prompt-wait)
                  (idle nil transition)))
    (with-temp-buffer
      (pi-coding-agent-chat-mode)
      (let ((sent-prompts nil))
        (setq pi-coding-agent--status (nth 0 case)
              pi-coding-agent--local-user-message (nth 1 case)
              pi-coding-agent--followup-queue '("queued follow-up"))
        (pcase (nth 2 case)
          ('prompt-wait
           (pi-coding-agent--begin-prompt-start-wait)
           (setq pi-coding-agent--status 'idle))
          ('transition
           (pi-coding-agent--begin-session-transition 'mock-proc)))
        (cl-letf (((symbol-function 'pi-coding-agent--send-prompt)
                   (lambda (text &optional on-success &rest _)
                     (push text sent-prompts)
                     (when on-success (funcall on-success)))))
          (pi-coding-agent--process-followup-queue))
        (should (null sent-prompts))
        (should (equal pi-coding-agent--followup-queue
                       '("queued follow-up")))))))

(ert-deftest pi-coding-agent-test-followup-queue-fifo-order ()
  "Multiple follow-ups are processed in FIFO order."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-fifo*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-fifo-input*"))
        (sent-prompts nil)
        drain-callback
        drain-args)
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf)
            (setq pi-coding-agent--followup-queue nil))
          ;; Queue three messages while busy
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (dolist (msg '("First message" "Second message" "Third message"))
              (erase-buffer)
              (insert msg)
              (pi-coding-agent-send)))
          ;; All three should be in queue
          (with-current-buffer chat-buf
            (should (= 3 (length pi-coding-agent--followup-queue))))
          ;; Simulate each completed queued turn and then run the scheduled drain.
          (with-current-buffer chat-buf
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--send-prompt)
                       (lambda (text &optional on-success &rest _)
                   (push text sent-prompts)
                   (when on-success (funcall on-success))))
                      ((symbol-function 'pi-coding-agent--refresh-header) #'ignore)
                      ((symbol-function 'run-at-time)
                       (lambda (_secs _repeat fn &rest args)
                         (setq drain-callback fn
                               drain-args args)
                         'fake-drain-timer)))
              (dotimes (_ 3)
                (setq drain-callback nil
                      drain-args nil)
                (pi-coding-agent--handle-display-event '(:type "agent_end"))
                (should (functionp drain-callback))
                (apply drain-callback drain-args))))
          ;; Should have sent all three in FIFO order (sent-prompts is reversed)
          (should (equal (reverse sent-prompts)
                         '("First message" "Second message" "Third message")))
          ;; Queue should be empty
          (with-current-buffer chat-buf
            (should (null pi-coding-agent--followup-queue))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-steering-displayed-from-echo ()
  "Steering is NOT displayed locally - it's displayed when pi echoes it back.
This ensures steering appears at the correct position in the conversation
(after the current assistant output completes)."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-steer-echo*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-steer-echo-input*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming)
            (setq pi-coding-agent--input-buffer input-buf)
            (let ((inhibit-read-only t))
              (insert "Assistant\n=========\nWorking on something...\n")))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "Stop and do something else")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                      ((symbol-function 'process-live-p) (lambda (_) t))
                      ((symbol-function 'pi-coding-agent--rpc-async) #'ignore))
              (pi-coding-agent-queue-steering)))
          ;; Steering is NOT displayed when sent (unlike normal sends)
          (with-current-buffer chat-buf
            (should-not (string-match-p "Stop and do something else" (buffer-string)))
            ;; local-user-message should still be nil (steering doesn't set it)
            (should-not pi-coding-agent--local-user-message))
          ;; Simulate pi echoing the steering message back via message_start
          (with-current-buffer chat-buf
            (pi-coding-agent--handle-display-event
             '(:type "message_start"
               :message (:role "user"
                         :content [(:type "text" :text "Stop and do something else")]
                         :timestamp 1704067200000)))
            ;; NOW it should be displayed (from the echo)
            (should (string-match-p "Stop and do something else" (buffer-string)))
            ;; Should be displayed exactly once
            (let ((count 0)
                  (start 0))
              (while (string-match "Stop and do something else" (buffer-string) start)
                (setq count (1+ count))
                (setq start (match-end 0)))
              (should (= count 1)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-steering-echo-followed-by-assistant-shows-header ()
  "After steering message, the next assistant message shows its header.
This tests the full flow: steering echo resets the flag, then the next
message_start role=assistant displays the 'Assistant' header."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((pi-coding-agent--status 'streaming)
          (pi-coding-agent--local-user-message nil)
          ;; Simulate that first assistant header was already shown
          (pi-coding-agent--assistant-header-shown t))
      ;; First, some assistant content is already in the buffer
      (let ((inhibit-read-only t))
        (insert "Assistant\n=========\nPrevious response...\n"))
      ;; Simulate steering message echo from pi
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "user"
                   :content [(:type "text" :text "Stop it")]
                   :timestamp 1704067200000)))
      ;; Steering message should be displayed
      (should (string-match-p "Stop it" (buffer-string)))
      ;; Flag should be reset
      (should-not pi-coding-agent--assistant-header-shown)
      ;; Now simulate the assistant's response to steering
      (pi-coding-agent--handle-display-event
       '(:type "message_start"
         :message (:role "assistant")))
      ;; Now we should see TWO "Assistant" headers in the buffer
      (let ((count 0)
            (start 0)
            (content (buffer-string)))
        (while (string-match "Assistant\n=+" content start)
          (setq count (1+ count))
          (setq start (match-end 0)))
        (should (= count 2))))))


(ert-deftest pi-coding-agent-test-tool-toggle-expands-content ()
  "Toggle button expands collapsed tool output."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    (pi-coding-agent--display-tool-end "bash" nil
                          '((:type "text" :text "L1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL10"))
                          nil nil)
    ;; Initially collapsed - should have "... (N more lines)"
    (should (string-match-p "\\.\\.\\..*more lines" (buffer-string)))
    (should-not (string-match-p "L10" (buffer-string)))
    ;; Find and click the button
    (goto-char (point-min))
    (search-forward "..." nil t)
    (backward-char 1)
    (pi-coding-agent-toggle-tool-section)
    ;; Now should show all lines
    (should (string-match-p "L10" (buffer-string)))
    (should (string-match-p "\\[-\\]" (buffer-string)))))

(ert-deftest pi-coding-agent-test-tool-toggle-collapses-content ()
  "Toggle button collapses expanded tool output."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    (pi-coding-agent--display-tool-end "bash" nil
                          '((:type "text" :text "L1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL10"))
                          nil nil)
    ;; Expand first
    (goto-char (point-min))
    (search-forward "..." nil t)
    (backward-char 1)
    (pi-coding-agent-toggle-tool-section)
    (should (string-match-p "L10" (buffer-string)))
    ;; Now collapse
    (goto-char (point-min))
    (search-forward "[-]" nil t)
    (backward-char 1)
    (pi-coding-agent-toggle-tool-section)
    ;; Should be collapsed again
    (should (string-match-p "\\.\\.\\..*more lines" (buffer-string)))
    (should-not (string-match-p "L10" (buffer-string)))))

(ert-deftest pi-coding-agent-test-tool-toggle-re-expand-after-collapse-from-button ()
  "TAB re-expands after collapsing from the [-] button position.
Regression: collapsing from the [-] button placed cursor at the overlay
boundary where overlays-at returns nil, making the next TAB fall through
to outline-cycle instead of toggling.  Uses enough lines so the [-]
button position in the expanded state exceeds the collapsed overlay end."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    (pi-coding-agent--display-tool-end "bash" nil
                          '((:type "text" :text "L01\nL02\nL03\nL04\nL05\nL06\nL07\nL08\nL09\nL10\nL11\nL12\nL13\nL14\nL15"))
                          nil nil)
    ;; Expand
    (goto-char (point-min))
    (search-forward "..." nil t)
    (backward-char 1)
    (pi-coding-agent-toggle-tool-section)
    (should (string-match-p "L15" (buffer-string)))
    ;; Navigate to the [-] button (near end of expanded block)
    (goto-char (point-min))
    (search-forward "[-]" nil t)
    (beginning-of-line)
    ;; Collapse from the button position
    (pi-coding-agent-toggle-tool-section)
    (should (string-match-p "\\.\\.\\..*more lines" (buffer-string)))
    ;; Verify cursor landed inside the tool block overlay, not at its boundary
    (should (seq-find (lambda (o) (overlay-get o 'pi-coding-agent-tool-block))
                      (overlays-at (point))))
    ;; The critical assertion: TAB must still work to re-expand
    (pi-coding-agent-toggle-tool-section)
    (should (string-match-p "L15" (buffer-string)))))

(ert-deftest pi-coding-agent-test-tool-toggle-expands-with-highlighting ()
  "Expanded tool output has syntax highlighting applied.
With tree-sitter, code blocks get `font-lock-string-face' from
the markdown grammar.  Tool output face also applies."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    ;; Create a read tool with Python content (>10 lines to trigger collapse)
    ;; The 'def' keyword is on line 11, hidden initially
    (pi-coding-agent--display-tool-start "read" '(:path "test.py"))
    (pi-coding-agent--display-tool-end "read" '(:path "test.py")
                          '((:type "text" :text "line1\nline2\nline3\nline4\nline5\nline6\nline7\nline8\nline9\nline10\ndef hello():\n    return 42"))
                          nil nil)
    ;; Initially collapsed - 'def' is hidden
    (should (string-match-p "\\.\\.\\..*more lines" (buffer-string)))
    (should-not (string-match-p "def hello" (buffer-string)))
    ;; Expand
    (goto-char (point-min))
    (search-forward "..." nil t)
    (backward-char 1)
    (pi-coding-agent-toggle-tool-section)
    ;; Now 'def' should be visible
    (should (string-match-p "def hello" (buffer-string)))
    ;; Re-fontify after expansion (in GUI, jit-lock handles this)
    (font-lock-ensure)
    ;; Find 'def' keyword and check for some face being applied
    (goto-char (point-min))
    (search-forward "def" nil t)
    (let ((face (get-text-property (match-beginning 0) 'face)))
      ;; With embedded language support, 'def' gets font-lock-keyword-face
      ;; from the Python grammar.  Without it, font-lock-string-face.
      (should face))))

(ert-deftest pi-coding-agent-test-tab-works-from-anywhere-in-block ()
  "TAB toggles tool output from any position within the block."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    (pi-coding-agent--display-tool-end "bash" nil
                          '((:type "text" :text "L1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL10"))
                          nil nil)
    ;; Go to the header line (not the button)
    (goto-char (point-min))
    (search-forward "$ ls" nil t)
    (beginning-of-line)
    ;; TAB should still expand
    (pi-coding-agent-toggle-tool-section)
    (should (string-match-p "L10" (buffer-string)))))

(ert-deftest pi-coding-agent-test-tab-preserves-cursor-position ()
  "TAB toggle doesn't jump cursor unnecessarily."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    (pi-coding-agent--display-tool-end "bash" nil
                          '((:type "text" :text "L1\nL2\nL3\nL4\nL5\nL6\nL7\nL8\nL9\nL10"))
                          nil nil)
    ;; Go to L3 line
    (goto-char (point-min))
    (search-forward "L3" nil t)
    (beginning-of-line)
    (let ((line-content (buffer-substring-no-properties
                         (line-beginning-position) (line-end-position))))
      ;; Expand
      (pi-coding-agent-toggle-tool-section)
      ;; Should still be on a line starting with L
      (should (string-match-p "^L[0-9]" 
                              (buffer-substring-no-properties
                               (line-beginning-position) (line-end-position)))))))

(ert-deftest pi-coding-agent-test-toggle-preserves-window-scroll ()
  "Toggle collapse/expand should preserve window scroll when viewing content before tool.
When window shows content BEFORE the tool block, toggle should not jump away."
  (let ((buf (generate-new-buffer "*test-toggle-scroll*")))
    (unwind-protect
        (progn
          (with-current-buffer buf
            (pi-coding-agent-chat-mode)
            ;; Add some content before the tool block
            (let ((inhibit-read-only t))
              (insert "Header line 1\nHeader line 2\nHeader line 3\n\n"))
            ;; Create tool output with many lines
            (pi-coding-agent--display-tool-start "read" '(:path "test.el"))
            (pi-coding-agent--display-tool-end
             "read" nil
             `((:type "text"
                :text ,(mapconcat (lambda (n) (format "Line %03d content" n))
                                  (number-sequence 1 50) "\n")))
             nil nil))
          ;; Display buffer in a window so we can test scroll
          (let ((win (display-buffer buf)))
            (when win
              (with-selected-window win
                ;; Position window at the header (before tool block)
                (goto-char (point-min))
                (recenter 0)
                (let ((start-before (window-start win)))
                  ;; Expand the tool content
                  (search-forward "..." nil t)
                  (pi-coding-agent-toggle-tool-section)
                  ;; Window should not have jumped
                  (should (= (window-start win) start-before))
                  ;; Now collapse
                  (search-forward "[-]" nil t)
                  (pi-coding-agent-toggle-tool-section)
                  ;; Window should still be at same position
                  (should (= (window-start win) start-before)))))))
      (kill-buffer buf))))

(ert-deftest pi-coding-agent-test-format-fork-message ()
  "Fork message formatted with index and preview."
  (let ((msg '(:entryId "abc-123" :text "Hello world, this is a test")))
    ;; With index
    (let ((result (pi-coding-agent--format-fork-message msg 2)))
      (should (string-match-p "2:" result))
      (should (string-match-p "Hello world" result)))
    ;; Without index
    (let ((result (pi-coding-agent--format-fork-message msg)))
      (should (string-match-p "Hello world" result))
      (should-not (string-match-p ":" result)))))

(ert-deftest pi-coding-agent-test-fork-detects-empty-messages-vector ()
  "Fork correctly detects empty messages vector from RPC.
JSON arrays are parsed as vectors, and (null []) is nil, not t.
The fork code must use seq-empty-p or length check."
  (let ((rpc-called nil)
        (message-shown nil))
    (with-temp-buffer
      (pi-coding-agent-chat-mode)
      (setq pi-coding-agent--status 'idle)
      (cl-letf (((symbol-function 'pi-coding-agent--get-process) (lambda () 'mock-proc))
                ((symbol-function 'pi-coding-agent--get-chat-buffer)
                 (lambda () (current-buffer)))
                ((symbol-function 'pi-coding-agent--rpc-async)
                 (lambda (_proc cmd cb)
                   (setq rpc-called t)
                   ;; Simulate response with empty vector (no messages to fork from)
                   (funcall cb '(:success t :data (:messages [])))))
                ((symbol-function 'message)
                 (lambda (fmt &rest args)
                   (when (string-match-p "No messages" fmt)
                     (setq message-shown t)))))
        (pi-coding-agent-fork)
        (should rpc-called)
        ;; Should show "No messages to fork from", not call completing-read
        (should message-shown)))))

(ert-deftest pi-coding-agent-test-format-fork-message-handles-nil-text ()
  "Format fork message handles nil text gracefully."
  (let ((msg '(:entryId "abc-123" :text nil)))
    ;; Should not error, should return something displayable
    (let ((result (pi-coding-agent--format-fork-message msg 1)))
      (should (stringp result)))))

(ert-deftest pi-coding-agent-test-load-session-history-uses-provided-buffer ()
  "load-session-history uses provided chat buffer, not current buffer context.
This ensures history loads correctly when callback runs in arbitrary context."
  (let* ((chat-buf (generate-new-buffer "*pi-coding-agent-chat:test-history/*"))
         (rpc-callback nil)
         (proc (start-process "test-history-load-provided-buffer" nil "cat")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--process proc))
          ;; Mock RPC to capture callback
          (cl-letf (((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _cmd cb) (setq rpc-callback cb))))
            ;; Call with explicit buffer
            (pi-coding-agent--load-session-history proc nil chat-buf))
          ;; Simulate callback from different buffer context
          (with-temp-buffer
            (funcall rpc-callback
                     '(:success t :data (:messages [(:role "user" :content "test")]))))
          ;; Chat buffer should have been updated (has startup header)
          (with-current-buffer chat-buf
            (should (string-match-p "C-c C-c" (buffer-string)))))
      (when (and proc (process-live-p proc))
        (delete-process proc))
      (when (buffer-live-p chat-buf)
        (kill-buffer chat-buf)))))

(ert-deftest pi-coding-agent-test-session-metadata-extracts-first-message ()
  "pi-coding-agent--session-metadata extracts first user message text."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n")
            (insert "{\"type\":\"message\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Hello world\"}]}}\n")
            (insert "{\"type\":\"message\",\"message\":{\"role\":\"assistant\",\"content\":[{\"type\":\"text\",\"text\":\"Hi\"}]}}\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            (should (equal (plist-get metadata :first-message) "Hello world"))
            (should (equal (plist-get metadata :message-count) 2))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-session-metadata-extracts-cwd ()
  "pi-coding-agent--session-metadata extracts cwd from the session header."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl"))
        (project-dir (pi-coding-agent-test--make-temp-directory
                      "pi-coding-agent-test-project-")))
    (unwind-protect
        (let ((cwd (directory-file-name project-dir)))
          (with-temp-file temp-file
            (insert (json-encode `(:type "session" :id "test" :cwd ,cwd)) "\n")
            (insert (json-encode '(:type "message"
                                   :message (:role "user"
                                             :content [(:type "text"
                                                       :text "Hello")]))))
            (insert "\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            (should (equal (plist-get metadata :cwd) cwd))
            (should (equal (plist-get metadata :first-message) "Hello"))
            (should (equal (plist-get metadata :message-count) 1))))
      (delete-file temp-file)
      (delete-directory project-dir t))))

(ert-deftest pi-coding-agent-test-session-metadata-accepts-type-after-other-keys ()
  "Session metadata handles small records whose type key is not first."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl"))
        (project-dir (pi-coding-agent-test--make-temp-directory
                      "pi-coding-agent-test-project-")))
    (unwind-protect
        (let ((cwd (directory-file-name project-dir)))
          (with-temp-file temp-file
            (insert (json-encode `(:id "test" :type "session" :cwd ,cwd)) "\n")
            (insert (json-encode '(:id "m1" :type "message"
                                   :message (:role "user"
                                             :content [(:type "text"
                                                       :text "Hello")]))))
            (insert "\n")
            (insert (json-encode '(:id "si1" :type "session_info"
                                   :name "Named session")))
            (insert "\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            (should (equal (plist-get metadata :cwd) cwd))
            (should (equal (plist-get metadata :first-message) "Hello"))
            (should (equal (plist-get metadata :message-count) 1))
            (should (equal (plist-get metadata :session-name)
                           "Named session"))))
      (delete-file temp-file)
      (delete-directory project-dir t))))

(ert-deftest pi-coding-agent-test-session-metadata-returns-nil-for-empty-file ()
  "pi-coding-agent--session-metadata returns nil for empty or invalid files."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          ;; Empty file
          (should (null (pi-coding-agent--session-metadata temp-file))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-session-metadata-handles-missing-first-message ()
  "pi-coding-agent--session-metadata handles session with only header."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            (should (null (plist-get metadata :first-message)))
            (should (equal (plist-get metadata :message-count) 0))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-session-metadata-extracts-session-name ()
  "pi-coding-agent--session-metadata extracts session name from session_info entry."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n")
            (insert "{\"type\":\"message\",\"id\":\"m1\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Hello\"}]}}\n")
            (insert "{\"type\":\"session_info\",\"id\":\"si1\",\"name\":\"Refactor auth module\"}\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            (should (equal (plist-get metadata :session-name) "Refactor auth module"))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-session-metadata-uses-latest-session-name ()
  "pi-coding-agent--session-metadata uses the most recent session_info name."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n")
            (insert "{\"type\":\"session_info\",\"id\":\"si1\",\"name\":\"Old name\"}\n")
            (insert "{\"type\":\"message\",\"id\":\"m1\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Hello\"}]}}\n")
            (insert "{\"type\":\"session_info\",\"id\":\"si2\",\"name\":\"New name\"}\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            (should (equal (plist-get metadata :session-name) "New name"))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-session-metadata-ignores-null-name ()
  "pi-coding-agent--session-metadata treats null name as cleared (no name)."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n")
            (insert "{\"type\":\"session_info\",\"id\":\"si1\",\"name\":\"My Session\"}\n")
            (insert "{\"type\":\"message\",\"id\":\"m1\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Hello\"}]}}\n")
            ;; User cleared the session name - null means no name
            (insert "{\"type\":\"session_info\",\"id\":\"si2\",\"name\":null}\n"))
          (let ((metadata (pi-coding-agent--session-metadata temp-file)))
            (should metadata)
            ;; Should be nil, not :null
            (should (null (plist-get metadata :session-name)))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-format-session-choice-fallback-on-cleared-name ()
  "pi-coding-agent--format-session-choice falls back to message when name cleared."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n")
            (insert "{\"type\":\"message\",\"id\":\"m1\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Hello world\"}]}}\n")
            (insert "{\"type\":\"session_info\",\"id\":\"si1\",\"name\":\"My Project\"}\n")
            ;; Name was cleared
            (insert "{\"type\":\"session_info\",\"id\":\"si2\",\"name\":null}\n"))
          (let ((choice (pi-coding-agent--format-session-choice temp-file)))
            ;; Should fall back to first message, not crash
            (should (string-match-p "Hello world" (car choice)))
            (should-not (string-match-p "My Project" (car choice)))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-format-session-choice-prefers-name ()
  "pi-coding-agent--format-session-choice uses session name when available."
  (let ((temp-file (make-temp-file "pi-coding-agent-test-session" nil ".jsonl")))
    (unwind-protect
        (progn
          (with-temp-file temp-file
            (insert "{\"type\":\"session\",\"id\":\"test\"}\n")
            (insert "{\"type\":\"message\",\"id\":\"m1\",\"message\":{\"role\":\"user\",\"content\":[{\"type\":\"text\",\"text\":\"Hello world\"}]}}\n")
            (insert "{\"type\":\"session_info\",\"id\":\"si1\",\"name\":\"My Project\"}\n"))
          (let ((choice (pi-coding-agent--format-session-choice temp-file)))
            ;; Should show session name, not first message
            (should (string-match-p "My Project" (car choice)))
            (should-not (string-match-p "Hello world" (car choice)))))
      (delete-file temp-file))))

(ert-deftest pi-coding-agent-test-format-session-choice-reuses-metadata ()
  "pi-coding-agent--format-session-choice need not rescan a listed session."
  (cl-letf (((symbol-function 'pi-coding-agent--session-metadata)
             (lambda (_path)
               (ert-fail "session metadata was rescanned"))))
    (let* ((path "/tmp/session.jsonl")
           (metadata (list :modified-time (current-time)
                           :session-name "Cached name"
                           :message-count 12))
           (choice (pi-coding-agent--format-session-choice path metadata)))
      (should (equal (cdr choice) path))
      (should (string-match-p "Cached name" (car choice)))
      (should (string-match-p "12 msgs" (car choice))))))

(ert-deftest pi-coding-agent-test-header-line-includes-session-name ()
  "pi-coding-agent--header-line-string includes session name when set."
  (let ((chat-buf (get-buffer-create "*pi-test-header-session-name*")))
    (unwind-protect
        (with-current-buffer chat-buf
          (pi-coding-agent-chat-mode)
          (setq pi-coding-agent--state '(:model (:name "test-model") :thinking-level "high"))
          ;; Without session name
          (setq pi-coding-agent--session-name nil)
          (let ((header (pi-coding-agent--header-line-string)))
            (should-not (string-match-p "My Session" header)))
          ;; With session name
          (setq pi-coding-agent--session-name "My Session")
          (let ((header (pi-coding-agent--header-line-string)))
            (should (string-match-p "My Session" header))
            ;; Should have separator before session name
            (should (string-match-p "│" header))))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-header-line-truncates-long-session-name ()
  "pi-coding-agent--header-line-string truncates long session names."
  (let ((chat-buf (get-buffer-create "*pi-test-header-truncate*")))
    (unwind-protect
        (with-current-buffer chat-buf
          (pi-coding-agent-chat-mode)
          (setq pi-coding-agent--state '(:model (:name "test-model")))
          ;; Set a very long session name (longer than 30 chars)
          (setq pi-coding-agent--session-name "This is a very long session name that should be truncated")
          (let ((header (pi-coding-agent--header-line-string)))
            ;; Should contain truncated version with ellipsis
            (should (string-match-p "This is a very long session" header))
            (should (string-match-p "…" header))
            ;; Should NOT contain the full name
            (should-not (string-match-p "truncated$" header))))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-empty-shows-current ()
  "pi-coding-agent-set-session-name with empty string shows current name."
  (let ((chat-buf (get-buffer-create "*pi-test-show-name*"))
        (messages nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--session-name "My Session"))
          ;; Capture message output
          (cl-letf (((symbol-function 'message)
                     (lambda (fmt &rest args)
                       (push (apply #'format fmt args) messages))))
            (with-current-buffer chat-buf
              (pi-coding-agent-set-session-name "")))
          ;; Should show current name, not change it
          (should (equal (buffer-local-value 'pi-coding-agent--session-name chat-buf)
                         "My Session"))
          (should (member "Pi: Session name: My Session" messages)))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-empty-no-name-shows-message ()
  "pi-coding-agent-set-session-name with empty string and no name shows message."
  (let ((chat-buf (get-buffer-create "*pi-test-no-name*"))
        (messages nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--session-name nil))
          ;; Capture message output
          (cl-letf (((symbol-function 'message)
                     (lambda (fmt &rest args)
                       (push (apply #'format fmt args) messages))))
            (with-current-buffer chat-buf
              (pi-coding-agent-set-session-name "")))
          (should (member "Pi: No session name set" messages)))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-no-process-errors ()
  "pi-coding-agent-set-session-name errors when no process is running."
  (let ((chat-buf (get-buffer-create "*pi-test-no-proc*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode))
          ;; Mock pi-coding-agent--get-process to return nil
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () nil)))
            (should-error
             (with-current-buffer chat-buf
               (pi-coding-agent-set-session-name "New Name"))
             :type 'user-error)))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-sends-rpc ()
  "pi-coding-agent-set-session-name sends correct RPC command."
  (let ((chat-buf (get-buffer-create "*pi-test-rpc*"))
        (pi-coding-agent--request-id-counter 0)
        (output-buffer (generate-new-buffer " *test-output*")))
    (unwind-protect
        (let ((fake-proc (start-process "cat" output-buffer "cat")))
          (unwind-protect
              (progn
                (with-current-buffer chat-buf
                  (pi-coding-agent-chat-mode))
                ;; Mock get-process and get-chat-buffer
                (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                           (lambda () fake-proc))
                          ((symbol-function 'pi-coding-agent--get-chat-buffer)
                           (lambda () chat-buf)))
                  (pi-coding-agent-set-session-name "Test Session"))
                ;; Wait for output
                (pi-coding-agent-test-wait-until
                 (lambda ()
                   (with-current-buffer output-buffer
                     (> (buffer-size) 0)))
                 1.0 0.05 fake-proc)
                ;; Verify JSON sent
                (with-current-buffer output-buffer
                  (let* ((sent (buffer-string))
                         (json (json-parse-string (string-trim sent) :object-type 'plist)))
                    (should (equal (plist-get json :type) "set_session_name"))
                    (should (equal (plist-get json :name) "Test Session")))))
            (delete-process fake-proc)))
      (kill-buffer output-buffer)
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-trims-whitespace ()
  "pi-coding-agent-set-session-name trims whitespace from name."
  (let ((chat-buf (get-buffer-create "*pi-test-trim*"))
        (pi-coding-agent--request-id-counter 0)
        (output-buffer (generate-new-buffer " *test-output*")))
    (unwind-protect
        (let ((fake-proc (start-process "cat" output-buffer "cat")))
          (unwind-protect
              (progn
                (with-current-buffer chat-buf
                  (pi-coding-agent-chat-mode))
                ;; Mock get-process and get-chat-buffer
                (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                           (lambda () fake-proc))
                          ((symbol-function 'pi-coding-agent--get-chat-buffer)
                           (lambda () chat-buf)))
                  (pi-coding-agent-set-session-name "  Trimmed Name  "))
                ;; Wait for output
                (pi-coding-agent-test-wait-until
                 (lambda ()
                   (with-current-buffer output-buffer
                     (> (buffer-size) 0)))
                 1.0 0.05 fake-proc)
                ;; Verify JSON sent has trimmed name
                (with-current-buffer output-buffer
                  (let* ((sent (buffer-string))
                         (json (json-parse-string (string-trim sent) :object-type 'plist)))
                    (should (equal (plist-get json :name) "Trimmed Name")))))
            (delete-process fake-proc)))
      (kill-buffer output-buffer)
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-whitespace-only-shows-current ()
  "pi-coding-agent-set-session-name with whitespace-only shows current name."
  (let ((chat-buf (get-buffer-create "*pi-test-ws*"))
        (messages nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--session-name "Existing Name"))
          ;; Capture message output
          (cl-letf (((symbol-function 'message)
                     (lambda (fmt &rest args)
                       (push (apply #'format fmt args) messages))))
            (with-current-buffer chat-buf
              (pi-coding-agent-set-session-name "   ")))  ; whitespace only
          ;; Should show current name, not try to set
          (should (equal (buffer-local-value 'pi-coding-agent--session-name chat-buf)
                         "Existing Name"))
          (should (member "Pi: Session name: Existing Name" messages)))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-set-session-name-rpc-failure-shows-error ()
  "pi-coding-agent-set-session-name shows error on RPC failure."
  (let ((chat-buf (get-buffer-create "*pi-test-fail*"))
        (messages nil))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--session-name "Old Name"))
          ;; Mock RPC to call callback with failure
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () 'fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () chat-buf))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _cmd callback)
                       (funcall callback '(:success nil :error "test error"))))
                    ((symbol-function 'message)
                     (lambda (fmt &rest args)
                       (push (apply #'format fmt args) messages))))
            (with-current-buffer chat-buf
              (pi-coding-agent-set-session-name "New Name")))
          ;; Name should NOT be updated
          (should (equal (buffer-local-value 'pi-coding-agent--session-name chat-buf)
                         "Old Name"))
          ;; Error message should be shown
          (should (member "Pi: Failed to set session name: test error" messages)))
      (kill-buffer chat-buf))))

;;; Input History

(ert-deftest pi-coding-agent-test-history-add-to-ring ()
  "pi-coding-agent--history-add adds input to ring."
  (let ((pi-coding-agent--input-ring nil))
    (pi-coding-agent--history-add "first")
    (pi-coding-agent--history-add "second")
    (should (equal (ring-ref (pi-coding-agent--input-ring) 0) "second"))
    (should (equal (ring-ref (pi-coding-agent--input-ring) 1) "first"))))

(ert-deftest pi-coding-agent-test-history-no-duplicate ()
  "pi-coding-agent--history-add skips duplicates of last entry."
  (let ((pi-coding-agent--input-ring nil))
    (pi-coding-agent--history-add "first")
    (pi-coding-agent--history-add "first")
    (should (= (ring-length (pi-coding-agent--input-ring)) 1))))

(ert-deftest pi-coding-agent-test-history-skip-empty ()
  "pi-coding-agent--history-add skips empty input."
  (let ((pi-coding-agent--input-ring nil))
    (pi-coding-agent--history-add "")
    (pi-coding-agent--history-add "   ")
    (should (ring-empty-p (pi-coding-agent--input-ring)))))

(ert-deftest pi-coding-agent-test-history-previous-input ()
  "pi-coding-agent-previous-input navigates backward through history."
  (let ((pi-coding-agent--input-ring nil))
    (pi-coding-agent--history-add "first")
    (pi-coding-agent--history-add "second")
    (with-temp-buffer
      (pi-coding-agent-input-mode)
      (insert "current")
      (pi-coding-agent-previous-input)
      (should (equal (buffer-string) "second"))
      (should (equal pi-coding-agent--input-saved "current"))
      (pi-coding-agent-previous-input)
      (should (equal (buffer-string) "first")))))

(ert-deftest pi-coding-agent-test-history-next-input ()
  "pi-coding-agent-next-input navigates forward and restores saved input."
  (let ((pi-coding-agent--input-ring nil))
    (pi-coding-agent--history-add "first")
    (pi-coding-agent--history-add "second")
    (with-temp-buffer
      (pi-coding-agent-input-mode)
      (insert "current")
      (pi-coding-agent-previous-input)
      (pi-coding-agent-previous-input)
      (should (equal (buffer-string) "first"))
      (pi-coding-agent-next-input)
      (should (equal (buffer-string) "second"))
      (pi-coding-agent-next-input)
      (should (equal (buffer-string) "current")))))

(ert-deftest pi-coding-agent-test-history-keys-bound ()
  "History keys are bound in pi-coding-agent-input-mode."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should (eq (key-binding (kbd "M-p")) 'pi-coding-agent-previous-input))
    (should (eq (key-binding (kbd "M-n")) 'pi-coding-agent-next-input))
    (should (eq (key-binding (kbd "C-r")) 'pi-coding-agent-history-isearch-backward))))

(ert-deftest pi-coding-agent-test-history-isolated-per-buffer ()
  "Input history is isolated per buffer, not shared globally.
Regression test for #27: history was shared across all sessions."
  (let ((buf1 (generate-new-buffer "*pi-coding-agent-input:project-a*"))
        (buf2 (generate-new-buffer "*pi-coding-agent-input:project-b*")))
    (unwind-protect
        (progn
          ;; Add history in buffer 1
          (with-current-buffer buf1
            (pi-coding-agent-input-mode)
            (pi-coding-agent--history-add "project-a-query"))
          ;; Add different history in buffer 2
          (with-current-buffer buf2
            (pi-coding-agent-input-mode)
            (pi-coding-agent--history-add "project-b-query"))
          ;; Buffer 1 should only see its own history
          (with-current-buffer buf1
            (should (= (ring-length (pi-coding-agent--input-ring)) 1))
            (should (equal (ring-ref (pi-coding-agent--input-ring) 0) "project-a-query")))
          ;; Buffer 2 should only see its own history
          (with-current-buffer buf2
            (should (= (ring-length (pi-coding-agent--input-ring)) 1))
            (should (equal (ring-ref (pi-coding-agent--input-ring) 0) "project-b-query"))))
      ;; Cleanup
      (kill-buffer buf1)
      (kill-buffer buf2))))

;;; History Isearch (C-r incremental search)

(ert-deftest pi-coding-agent-test-history-isearch-empty-history-errors ()
  "pi-coding-agent-history-isearch-backward errors with empty history."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should-error (pi-coding-agent-history-isearch-backward) :type 'user-error)))

(ert-deftest pi-coding-agent-test-history-isearch-saves-current-input ()
  "pi-coding-agent-history-isearch-backward saves current buffer content."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (pi-coding-agent--history-add "old command")
    (insert "my current input")
    ;; Mock isearch-backward to avoid actually starting isearch
    (cl-letf (((symbol-function 'isearch-backward) #'ignore))
      (pi-coding-agent-history-isearch-backward))
    (should (equal pi-coding-agent--history-isearch-saved-input "my current input"))))

(ert-deftest pi-coding-agent-test-history-isearch-sets-active-flag ()
  "pi-coding-agent-history-isearch-backward sets the active flag."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (pi-coding-agent--history-add "old command")
    (cl-letf (((symbol-function 'isearch-backward) #'ignore))
      (pi-coding-agent-history-isearch-backward))
    (should pi-coding-agent--history-isearch-active)))

(ert-deftest pi-coding-agent-test-history-isearch-end-restores-on-quit ()
  "pi-coding-agent--history-isearch-end restores input when isearch is quit."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--history-isearch-active t)
    (setq pi-coding-agent--history-isearch-saved-input "original input")
    (erase-buffer)
    (insert "some history item")
    ;; Simulate isearch quit
    (let ((isearch-mode-end-hook-quit t))
      (pi-coding-agent--history-isearch-end))
    (should (equal (buffer-string) "original input"))
    (should-not pi-coding-agent--history-isearch-active)))

(ert-deftest pi-coding-agent-test-history-isearch-end-keeps-on-accept ()
  "pi-coding-agent--history-isearch-end keeps history item when accepted."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--history-isearch-active t)
    (setq pi-coding-agent--history-isearch-saved-input "original input")
    (erase-buffer)
    (insert "chosen history item")
    ;; Simulate isearch accept (quit is nil)
    (let ((isearch-mode-end-hook-quit nil))
      (pi-coding-agent--history-isearch-end))
    (should (equal (buffer-string) "chosen history item"))
    (should-not pi-coding-agent--history-isearch-active)))

(ert-deftest pi-coding-agent-test-history-isearch-goto-index ()
  "pi-coding-agent--history-isearch-goto loads history item into buffer."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (pi-coding-agent--history-add "first")
    (pi-coding-agent--history-add "second")
    (pi-coding-agent--history-add "third")
    (insert "current")
    (pi-coding-agent--history-isearch-goto 1)  ; "second" (0=third, 1=second)
    (should (equal (buffer-string) "second"))
    (should (= pi-coding-agent--history-isearch-index 1))))

(ert-deftest pi-coding-agent-test-history-isearch-hook-added ()
  "isearch-mode-hook is set up in pi-coding-agent-input-mode."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should (memq 'pi-coding-agent--history-isearch-setup isearch-mode-hook))))

(ert-deftest pi-coding-agent-test-history-isearch-goto-nil-restores-saved ()
  "pi-coding-agent--history-isearch-goto with nil index restores saved input."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (pi-coding-agent--history-add "history item")
    (setq pi-coding-agent--history-isearch-saved-input "my original input")
    (insert "something else")
    (pi-coding-agent--history-isearch-goto nil)
    (should (equal (buffer-string) "my original input"))
    (should (null pi-coding-agent--history-isearch-index))))

(ert-deftest pi-coding-agent-test-history-isearch-goto-empty-saved-input ()
  "pi-coding-agent--history-isearch-goto with nil index and empty saved input."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (pi-coding-agent--history-add "history item")
    (setq pi-coding-agent--history-isearch-saved-input "")
    (insert "something else")
    (pi-coding-agent--history-isearch-goto nil)
    (should (equal (buffer-string) ""))
    (should (null pi-coding-agent--history-isearch-index))))

;;; Input Buffer Completion

(ert-deftest pi-coding-agent-test-input-mode-has-only-own-capfs ()
  "Input mode should only include our own completion functions.
`text-mode' adds `ispell-completion-at-point' by default, which pollutes
the completion candidates with dictionary words.  Our input buffer should
only offer our own capfs (slash commands, file references, paths)."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should (equal completion-at-point-functions
                   '(pi-coding-agent--path-capf
                     pi-coding-agent--file-reference-capf
                     pi-coding-agent--command-capf)))))

(ert-deftest pi-coding-agent-test-input-mode-has-only-own-capfs-with-markdown ()
  "Only our capfs present even with markdown highlighting enabled."
  (let ((pi-coding-agent-input-markdown-highlighting t))
    (with-temp-buffer
      (pi-coding-agent-input-mode)
      (should (equal completion-at-point-functions
                     '(pi-coding-agent--path-capf
                       pi-coding-agent--file-reference-capf
                       pi-coding-agent--command-capf))))))

;;; Input Buffer Slash Completion

(ert-deftest pi-coding-agent-test-command-capf-returns-nil-without-slash ()
  "Completion returns nil when not after slash."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "hello")
    (should-not (pi-coding-agent--command-capf))))

(ert-deftest pi-coding-agent-test-command-capf-returns-nil-at-line-start ()
  "Completion returns nil when point is at beginning of line."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "/test")
    (goto-char (line-beginning-position))
    (should-not (pi-coding-agent--command-capf))))

(ert-deftest pi-coding-agent-test-command-capf-returns-completion-data ()
  "Completion returns data when after slash at start of buffer."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--commands '((:name "test-cmd" :description "Test")))
    (insert "/te")
    (let ((result (pi-coding-agent--command-capf)))
      (should result)
      (should (= (nth 0 result) 2))  ; Start after /
      (should (= (nth 1 result) 4))  ; End at point
      (should (member "test-cmd" (nth 2 result))))))

(ert-deftest pi-coding-agent-test-command-capf-ignores-slash-on-later-lines ()
  "Completion ignores / on lines after the first (pi only expands at buffer start)."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--commands '((:name "test-cmd" :description "Test")))
    (insert "Some context:\n/te")
    (should-not (pi-coding-agent--command-capf))))

(ert-deftest pi-coding-agent-test-command-capf-includes-builtins ()
  "Completion includes built-in commands even when RPC returns nothing."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--commands nil)
    (insert "/co")
    (let ((result (pi-coding-agent--command-capf)))
      (should result)
      (should (member "compact" (nth 2 result)))
      (should (member "new" (nth 2 result)))
      (should (member "model" (nth 2 result))))))

(ert-deftest pi-coding-agent-test-command-capf-merges-builtins-and-rpc ()
  "Completion merges built-in and RPC commands without duplicates."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--commands '((:name "my-ext" :description "Extension")))
    (insert "/")
    (let* ((result (pi-coding-agent--command-capf))
           (names (nth 2 result)))
      ;; Has built-in
      (should (member "compact" names))
      ;; Has RPC command
      (should (member "my-ext" names))
      ;; No duplicates
      (should (= (length (seq-filter (lambda (n) (equal n "compact")) names)) 1)))))

(ert-deftest pi-coding-agent-test-send-prompt-sends-literal ()
  "pi-coding-agent--send-prompt sends text literally (no expansion).
Pi handles command expansion on the server side."
  (let* ((rpc-message nil)
         (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                   (lambda () fake-proc))
                  ((symbol-function 'pi-coding-agent--rpc-async)
                   (lambda (_proc msg _cb) (setq rpc-message msg))))
          (pi-coding-agent--send-prompt "/greet world")
          ;; Should send literal /greet world, NOT expanded
          (should (equal (plist-get rpc-message :message) "/greet world")))
      (delete-process fake-proc))))

(ert-deftest pi-coding-agent-test-send-prompt-marks-sending-until-preflight-fails ()
  "pi-coding-agent--send-prompt closes the local pre-agent_start idle gap."
  (let* ((rpc-callback nil)
         (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (with-temp-buffer
          (pi-coding-agent-chat-mode)
          (setq pi-coding-agent--status 'idle
                pi-coding-agent--activity-phase "idle")
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () (current-buffer)))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _msg cb) (setq rpc-callback cb)))
                    ((symbol-function 'message) #'ignore))
            (pi-coding-agent--send-prompt "hello")
            (should (eq pi-coding-agent--status 'sending))
            (should (equal pi-coding-agent--activity-phase "thinking"))
            (should (functionp rpc-callback))
            (funcall rpc-callback '(:success :false :error "preflight failed"))
            (should (eq pi-coding-agent--status 'idle))
            (should (equal pi-coding-agent--activity-phase "idle"))))
      (delete-process fake-proc))))

(ert-deftest pi-coding-agent-test-normal-send-preflight-failure-restores-input ()
  "Rejected normal sends do not leave ghost chat text or lose input."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-send-fail-echo*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-send-fail-echo-input*"))
        (rpc-callback nil)
        (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--activity-phase "idle"
                  pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "this send will fail")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                       (lambda () fake-proc))
                      ((symbol-function 'pi-coding-agent--get-chat-buffer)
                       (lambda () chat-buf))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _msg cb) (setq rpc-callback cb)))
                      ((symbol-function 'message) #'ignore))
              (pi-coding-agent-send)))
          (with-current-buffer chat-buf
            (should (null pi-coding-agent--local-user-message))
            (should-not (string-match-p "this send will fail" (buffer-string)))
            (funcall rpc-callback '(:success :false :error "preflight failed"))
            (should (eq pi-coding-agent--status 'idle))
            (should (equal pi-coding-agent--activity-phase "idle"))
            (should (null pi-coding-agent--local-user-message))
            (should-not (string-match-p "this send will fail" (buffer-string))))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "this send will fail"))))
      (delete-process fake-proc)
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-slash-prompt-preflight-failure-restores-input ()
  "Rejected slash prompts are restored instead of being lost silently."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-slash-fail-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-slash-fail-input*"))
        (rpc-callback nil)
        (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--activity-phase "idle"
                  pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "/unknown command")
            (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                       (lambda () fake-proc))
                      ((symbol-function 'pi-coding-agent--get-chat-buffer)
                       (lambda () chat-buf))
                      ((symbol-function 'pi-coding-agent--rpc-async)
                       (lambda (_proc _msg cb) (setq rpc-callback cb)))
                      ((symbol-function 'message) #'ignore))
              (pi-coding-agent-send)))
          (with-current-buffer chat-buf
            (should-not (string-match-p "/unknown command" (buffer-string)))
            (funcall rpc-callback '(:success :false :error "preflight failed"))
            (should (eq pi-coding-agent--status 'idle)))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "/unknown command"))))
      (delete-process fake-proc)
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-normal-send-without-process-restores-input ()
  "Direct sends without a process do not create ghost chat text."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-send-no-process-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-send-no-process-input*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--activity-phase "idle"
                  pi-coding-agent--process nil
                  pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "no process prompt")
            (cl-letf (((symbol-function 'message) #'ignore))
              (pi-coding-agent-send))
            (should (equal (buffer-string) "no process prompt")))
          (with-current-buffer chat-buf
            (should (eq pi-coding-agent--status 'idle))
            (should (null pi-coding-agent--local-user-message))
            (should-not (string-match-p "no process prompt" (buffer-string)))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-restore-followups-prepends-existing-draft ()
  "Recovered queued text stays before any newer input draft."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-restore-before-draft-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-restore-before-draft-input*")))
    (unwind-protect
        (progn
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "newer draft"))
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("second" "first"))
            (pi-coding-agent--restore-followup-queue-to-input)
            (should (null pi-coding-agent--followup-queue)))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "first\n\nsecond\n\nnewer draft"))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-queued-followup-send-failure-restores-queue-to-input ()
  "Rejected queued follow-ups become visible input instead of hidden work."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-queued-fail-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-queued-fail-input*"))
        (rpc-callback nil)
        (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--activity-phase "idle"
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--followup-queue '("newer queued item" "queued send will fail")))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () chat-buf))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _msg cb) (setq rpc-callback cb)))
                    ((symbol-function 'message) #'ignore))
            (with-current-buffer chat-buf
              (pi-coding-agent--process-followup-queue)
              (should (eq pi-coding-agent--status 'sending))
              (should (equal pi-coding-agent--followup-queue
                             '("newer queued item" "queued send will fail")))
              (should-not (string-match-p "queued send will fail" (buffer-string)))
              (funcall rpc-callback '(:success :false :error "preflight failed"))
              (should (eq pi-coding-agent--status 'idle))
              (should (null pi-coding-agent--followup-queue))
              (should-not (string-match-p "queued send will fail" (buffer-string)))))
          (with-current-buffer input-buf
            (should (equal (buffer-string)
                           "queued send will fail\n\nnewer queued item"))))
      (delete-process fake-proc)
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-send-prompt-success-without-agent-start-returns-idle ()
  "Successful no-turn slash commands do not leave the frontend sending."
  (let* ((rpc-callback nil)
         (fallback-callback nil)
         (fallback-args nil)
         (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (with-temp-buffer
          (pi-coding-agent-chat-mode)
          (setq pi-coding-agent--status 'idle
                pi-coding-agent--activity-phase "idle")
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () (current-buffer)))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _msg cb) (setq rpc-callback cb)))
                    ((symbol-function 'run-at-time)
                     (lambda (_secs _repeat fn &rest args)
                       (setq fallback-callback fn
                             fallback-args args)
                       'fake-prompt-start-timer)))
            (pi-coding-agent--send-prompt "/test-noop")
            (should (eq pi-coding-agent--status 'sending))
            (funcall rpc-callback '(:success t))
            (should (functionp fallback-callback))
            (apply fallback-callback fallback-args)
            (should (eq pi-coding-agent--status 'idle))
            (should (equal pi-coding-agent--activity-phase "idle"))))
      (delete-process fake-proc))))

(ert-deftest pi-coding-agent-test-no-turn-prompt-fallback-drains-queued-followup ()
  "Successful no-turn commands release follow-ups queued while sending."
  (let* ((rpc-callbacks nil)
         (prompt-fallback-callback nil)
         (prompt-fallback-args nil)
         (drain-callback nil)
         (drain-args nil)
         (sent-messages nil)
         (chat-buf (get-buffer-create "*pi-coding-agent-test-no-turn-drain*"))
         (input-buf (get-buffer-create "*pi-coding-agent-test-no-turn-drain-input*"))
         (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--activity-phase "idle"
                  pi-coding-agent--input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () chat-buf))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc cmd cb)
                       (push (plist-get cmd :message) sent-messages)
                       (push cb rpc-callbacks)))
                    ((symbol-function 'run-at-time)
                     (lambda (_secs _repeat fn &rest args)
                       (cond
                        ((eq fn 'pi-coding-agent--clear-sending-if-no-agent-start)
                         (setq prompt-fallback-callback fn
                               prompt-fallback-args args)
                         'fake-prompt-start-timer)
                        ((eq fn 'pi-coding-agent--drain-followup-queue-if-idle)
                         (setq drain-callback fn
                               drain-args args)
                         'fake-drain-timer)
                        (t 'fake-timer))))
                    ((symbol-function 'message) #'ignore))
            (with-current-buffer chat-buf
              (pi-coding-agent--prepare-and-send "/test-noop"))
            (with-current-buffer input-buf
              (insert "follow-up after noop")
              (pi-coding-agent-send))
            (with-current-buffer chat-buf
              (should (eq pi-coding-agent--status 'sending))
              (should (equal pi-coding-agent--followup-queue
                             '("follow-up after noop"))))
            (funcall (car rpc-callbacks) '(:success t))
            (should (functionp prompt-fallback-callback))
            (apply prompt-fallback-callback prompt-fallback-args)
            (should (functionp drain-callback))
            (apply drain-callback drain-args)
            (should (equal (reverse sent-messages)
                           '("/test-noop" "follow-up after noop")))))
      (delete-process fake-proc)
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-stale-prompt-start-fallback-does-not-clear-newer-send ()
  "A stale no-turn fallback timer cannot clear a newer sending prompt."
  (let* ((rpc-callbacks nil)
         (fallbacks nil)
         (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (with-temp-buffer
          (pi-coding-agent-chat-mode)
          (setq pi-coding-agent--status 'idle
                pi-coding-agent--activity-phase "idle")
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () (current-buffer)))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _msg cb) (push cb rpc-callbacks)))
                    ((symbol-function 'run-at-time)
                     (lambda (_secs _repeat fn &rest args)
                       (push (cons fn args) fallbacks)
                       'fake-prompt-start-timer)))
            (pi-coding-agent--send-prompt "/first-noop")
            (funcall (car rpc-callbacks) '(:success t))
            (let ((first-fallback (car fallbacks)))
              (pi-coding-agent--send-prompt "/second-command")
              (should (eq pi-coding-agent--status 'sending))
              (apply (car first-fallback) (cdr first-fallback))
              (should (eq pi-coding-agent--status 'sending))
              (should (equal pi-coding-agent--activity-phase "thinking")))))
      (delete-process fake-proc))))

(ert-deftest pi-coding-agent-test-agent-start-invalidates-prompt-success-fallback ()
  "A prompt response arriving after agent_start cannot schedule stale idle reset."
  (let ((rpc-callback nil)
        (fallback-scheduled nil)
        (fake-proc (start-process "test" nil "cat")))
    (unwind-protect
        (with-temp-buffer
          (pi-coding-agent-chat-mode)
          (setq pi-coding-agent--status 'idle
                pi-coding-agent--activity-phase "idle")
          (cl-letf (((symbol-function 'pi-coding-agent--get-process)
                     (lambda () fake-proc))
                    ((symbol-function 'pi-coding-agent--get-chat-buffer)
                     (lambda () (current-buffer)))
                    ((symbol-function 'pi-coding-agent--rpc-async)
                     (lambda (_proc _msg cb) (setq rpc-callback cb)))
                    ((symbol-function 'run-at-time)
                     (lambda (&rest _)
                       (setq fallback-scheduled t)
                       'fake-prompt-start-timer)))
            (pi-coding-agent--send-prompt "/starts-fast")
            (pi-coding-agent--handle-display-event '(:type "agent_start"))
            (funcall rpc-callback '(:success t))
            (should-not fallback-scheduled)
            (should (eq pi-coding-agent--status 'streaming))))
      (delete-process fake-proc))))

(ert-deftest pi-coding-agent-test-agent-start-cancels-prompt-start-fallback ()
  "A real agent_start cancels the no-turn prompt fallback timer."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((cancelled nil))
      (setq pi-coding-agent--status 'sending
            pi-coding-agent--prompt-start-timer 'fake-timer)
      (cl-letf (((symbol-function 'timerp) (lambda (timer) (eq timer 'fake-timer)))
                ((symbol-function 'cancel-timer) (lambda (_timer) (setq cancelled t))))
        (pi-coding-agent--handle-display-event '(:type "agent_start")))
      (should cancelled)
      (should (null pi-coding-agent--prompt-start-timer))
      (should (eq pi-coding-agent--status 'streaming)))))

(ert-deftest pi-coding-agent-test-format-session-stats ()
  "Format session stats returns readable string with cache details."
  (let ((stats '(:tokens (:input 50000 :output 10000 :total 60000
                         :cacheRead 123000 :cacheWrite 4567)
                 :cost 0.45
                 :userMessages 5
                 :toolCalls 12)))
    (let ((result (pi-coding-agent--format-session-stats stats)))
      (should (string-match-p "50,000" result))
      (should (string-match-p "10,000" result))
      (should (string-match-p "60,000" result))
      (should (string-match-p "123,000" result))
      (should (string-match-p "4,567" result))
      (should (string-match-p "\\$0.45" result))
      (should (string-match-p "Messages: 5" result))
      (should (string-match-p "Tools: 12" result)))))

(ert-deftest pi-coding-agent-test-header-line-shows-model ()
  "Header line displays current model."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4"))
    (let ((header (pi-coding-agent--header-line-string)))
      (should (string-match-p "sonnet-4" header)))))

(ert-deftest pi-coding-agent-test-header-line-shows-thinking ()
  "Header line displays thinking level."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4" :thinking-level "high"))
    (let ((header (pi-coding-agent--header-line-string)))
      (should (string-match-p "high" header)))))

(ert-deftest pi-coding-agent-test-header-line-shows-activity-phase ()
  "Header line shows the current activity phase label."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4" :thinking-level "high")
          pi-coding-agent--activity-phase "thinking")
    (let ((header (pi-coding-agent--header-line-string)))
      (should (string-match-p "thinking" header)))))

(ert-deftest pi-coding-agent-test-header-line-shows-idle ()
  "Header line shows idle activity phase with fixed-width padding."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4" :thinking-level "high")
          pi-coding-agent--activity-phase "idle")
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string))))
      (should (string-match-p "idle    " header)))))

(ert-deftest pi-coding-agent-test-header-line-phase-is-padded ()
  "Header line activity phase slot is always 8 characters wide."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4" :thinking-level "high")
          pi-coding-agent--activity-phase "running")
    (let* ((header (substring-no-properties (pi-coding-agent--header-line-string)))
           (pos (string-match "running" header)))
      (should pos)
      (should (equal (substring header pos (+ pos 8)) "running ")))))

(ert-deftest pi-coding-agent-test-header-line-shows-thinking-activity-phase ()
  "Header line shows semantic activity label during streaming."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4")
          pi-coding-agent--activity-phase "thinking")
    (let ((header (pi-coding-agent--header-line-string)))
      (should (string-match-p "thinking" header)))))

(ert-deftest pi-coding-agent-test-quit-prompts-even-when-process-noquery ()
  "Explicit quit still asks before killing a live noquery process."
  (let ((chat-buf (generate-new-buffer "*pi-coding-agent-test-quit-chat*"))
        (input-buf (generate-new-buffer "*pi-coding-agent-test-quit-input*"))
        (proc (start-process "test-quit-noquery" nil "cat"))
        (asked nil))
    (unwind-protect
        (progn
          (set-process-query-on-exit-flag proc nil)
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--process proc)
            (pi-coding-agent--set-input-buffer input-buf))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (pi-coding-agent--set-chat-buffer chat-buf))
          (cl-letf (((symbol-function 'yes-or-no-p)
                     (lambda (_prompt)
                       (setq asked t)
                       nil)))
            (with-current-buffer chat-buf
              (should-error (pi-coding-agent-quit) :type 'user-error)))
          (should asked)
          (should (buffer-live-p chat-buf))
          (should (buffer-live-p input-buf))
          (should (process-live-p proc)))
      (when (process-live-p proc)
        (delete-process proc))
      (pi-coding-agent-test--kill-live-buffers input-buf chat-buf))))

(ert-deftest pi-coding-agent-test-process-exit-resets-busy-chat-and-restores-queue ()
  "Process exit leaves the frontend idle and surfaces queued local work."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-process-exit-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-process-exit-input*"))
        (proc (start-process "test-process-exit" nil "cat")))
    (unwind-protect
        (progn
          (set-process-sentinel proc nil)
          (set-process-query-on-exit-flag proc nil)
          (process-put proc 'pi-coding-agent-chat-buffer chat-buf)
          (pi-coding-agent--register-display-handler proc)
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf))
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'streaming
                  pi-coding-agent--activity-phase "replying"
                  pi-coding-agent--process proc
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--local-user-message "pending echo"
                  pi-coding-agent--followup-queue '("queued after crash")
                  pi-coding-agent--prompt-start-generation 7)
            (pi-coding-agent--handle-process-exit proc "exited abnormally with code 1\n")
            (should (eq pi-coding-agent--status 'idle))
            (should (equal pi-coding-agent--activity-phase "idle"))
            (should (null pi-coding-agent--process))
            (should (null pi-coding-agent--local-user-message))
            (should (null pi-coding-agent--followup-queue))
            (should (> pi-coding-agent--prompt-start-generation 7))
            (should (string-match-p "Process exited"
                                    (plist-get pi-coding-agent--state :last-error))))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "queued after crash"))))
      (when (process-live-p proc)
        (delete-process proc))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-process-exit-restores-direct-pending-prompt ()
  "Process exit restores a direct prompt whose RPC preflight never completed."
  (let ((chat-buf (get-buffer-create "*pi-coding-agent-test-process-exit-direct-chat*"))
        (input-buf (get-buffer-create "*pi-coding-agent-test-process-exit-direct-input*"))
        (proc (start-process "test-process-exit-direct" nil "cat")))
    (unwind-protect
        (progn
          (set-process-sentinel proc nil)
          (set-process-query-on-exit-flag proc nil)
          (process-put proc 'pi-coding-agent-chat-buffer chat-buf)
          (pi-coding-agent--register-display-handler proc)
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--status 'idle
                  pi-coding-agent--process proc
                  pi-coding-agent--input-buffer input-buf
                  pi-coding-agent--prompt-start-generation 3))
          (with-current-buffer input-buf
            (pi-coding-agent-input-mode)
            (setq pi-coding-agent--chat-buffer chat-buf)
            (insert "please survive the crash")
            (pi-coding-agent-send)
            (should (string-empty-p (buffer-string))))
          (with-current-buffer chat-buf
            (should (eq pi-coding-agent--status 'sending))
            (should-not (string-match-p "please survive the crash" (buffer-string)))
            (pi-coding-agent--handle-process-exit proc "exited abnormally with code 1\n")
            (should (eq pi-coding-agent--status 'idle))
            (should (null pi-coding-agent--process))
            (should (string-match-p "Process exited"
                                    (plist-get pi-coding-agent--state :last-error))))
          (with-current-buffer input-buf
            (should (equal (buffer-string) "please survive the crash"))))
      (when (process-live-p proc)
        (delete-process proc))
      (kill-buffer chat-buf)
      (kill-buffer input-buf))))

(ert-deftest pi-coding-agent-test-abort-send-resets-activity-phase ()
  "Abort send resets activity phase and status to idle in CHAT-BUF."
  (let ((chat-buf (generate-new-buffer "*pi-coding-agent-chat:test-abort-send/*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--activity-phase "running"
                  pi-coding-agent--status 'streaming))
          ;; Simulate callback/sentinel context by calling from other buffer
          (with-temp-buffer
            (pi-coding-agent--abort-send chat-buf))
          (with-current-buffer chat-buf
            (should (equal pi-coding-agent--activity-phase "idle"))
            (should (eq pi-coding-agent--status 'idle))))
      (when (buffer-live-p chat-buf)
        (kill-buffer chat-buf)))))

(ert-deftest pi-coding-agent-test-working-message-in-header ()
  "Header line includes transient working message when set."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4")
          pi-coding-agent--working-message "📖 Skimming…")
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string))))
      (should (string-match-p "Skimming" header)))))

(ert-deftest pi-coding-agent-test-header-no-pipes-when-minimal ()
  "Header has no pipe separators when only identity group is present."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4")
          pi-coding-agent--cached-stats nil
          pi-coding-agent--session-name nil
          pi-coding-agent--extension-status nil
          pi-coding-agent--working-message nil)
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string))))
      (should-not (string-match-p "│" header)))))

(ert-deftest pi-coding-agent-test-header-pipes-collapse-correctly ()
  "Header renders only needed pipes when stats and context groups are set."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "claude-sonnet-4" :contextWindow 200000))
          pi-coding-agent--cached-stats '(:cost 0.05
                                   :contextUsage (:tokens 150 :contextWindow 200000 :percent 0.075))
          pi-coding-agent--session-name "My Session"
          pi-coding-agent--extension-status nil
          pi-coding-agent--working-message nil)
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string)))
          (count 0)
          (start 0))
      (while (string-match "│" header start)
        (setq count (1+ count)
              start (match-end 0)))
      (should (= count 2)))))

(ert-deftest pi-coding-agent-test-header-all-groups-present ()
  "Header shows three group separators when all groups have content."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "claude-sonnet-4" :contextWindow 200000))
          pi-coding-agent--cached-stats '(:cost 0.05
                                   :contextUsage (:tokens 150 :contextWindow 200000 :percent 0.075))
          pi-coding-agent--session-name "My Session"
          pi-coding-agent--extension-status '(("ext" . "Git: synced"))
          pi-coding-agent--working-message "📖 Skimming…")
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string)))
          (count 0)
          (start 0))
      (while (string-match "│" header start)
        (setq count (1+ count)
              start (match-end 0)))
      (should (= count 3))
      (should (string-match-p "My Session" header))
      (should (string-match-p "Git: synced · 📖 Skimming…" header)))))

(ert-deftest pi-coding-agent-test-header-extension-group-escapes-percent-signs ()
  "Extension header text escapes percent signs for header-line display."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "gpt-5.4" :contextWindow 200000))
          pi-coding-agent--extension-status '(("sub-status:usage" . "5h 4% · Week 3% · degraded"))
          pi-coding-agent--working-message "refresh 50%")
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string))))
      (should (string-match-p "5h 4%% · Week 3%% · degraded" header))
      (should (string-match-p "refresh 50%%" header)))))

(ert-deftest pi-coding-agent-test-header-session-name-in-context-group ()
  "Context group shows session name when set, collapses when nil."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model "claude-sonnet-4")
          pi-coding-agent--session-name "Refactor auth")
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string))))
      (should (string-match-p "Refactor auth" header))
      (should (string-match-p "│" header)))
    (setq pi-coding-agent--session-name nil)
    (let ((header (substring-no-properties (pi-coding-agent--header-line-string))))
      (should-not (string-match-p "│" header)))))

(ert-deftest pi-coding-agent-test-format-tokens-compact ()
  "Tokens formatted compactly."
  (should (equal "500" (pi-coding-agent--format-tokens-compact 500)))
  (should (equal "5k" (pi-coding-agent--format-tokens-compact 5000)))
  (should (equal "50k" (pi-coding-agent--format-tokens-compact 50000)))
  (should (equal "1.2M" (pi-coding-agent--format-tokens-compact 1200000))))

(ert-deftest pi-coding-agent-test-input-mode-has-header-line ()
  "Input mode sets up header-line-format."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should header-line-format)))

(ert-deftest pi-coding-agent-test-header-line-handles-model-plist ()
  "Header line handles model as plist with :name."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "claude-sonnet-4" :id "model-123")))
    (let ((header (pi-coding-agent--header-line-string)))
      (should (string-match-p "sonnet-4" header)))))

(ert-deftest pi-coding-agent-test-menu-model-description-buffer-local ()
  "Menu model description uses buffer-local model."
  (let ((buf-a (generate-new-buffer "*pi-coding-agent-chat:model-a*"))
        (buf-b (generate-new-buffer "*pi-coding-agent-chat:model-b*")))
    (unwind-protect
        (let (desc-a desc-b)
          (with-current-buffer buf-a
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--state '(:model (:name "Alpha")))
            (setq desc-a (pi-coding-agent--menu-model-description)))
          (with-current-buffer buf-b
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--state '(:model (:name "Beta")))
            (setq desc-b (pi-coding-agent--menu-model-description)))
          (should (equal (list desc-a desc-b)
                         '("Model: Alpha" "Model: Beta"))))
      (mapc #'kill-buffer (list buf-a buf-b)))))

(ert-deftest pi-coding-agent-test-select-model-updates-current-session-only ()
  "Selecting a model updates only the current session."
  (let* ((buf-a (generate-new-buffer "*pi-coding-agent-chat:model-select-a*"))
         (buf-b (generate-new-buffer "*pi-coding-agent-chat:model-select-b*"))
         (available-models (list (list :id "model-a" :name "Model A" :provider "test")
                                 (list :id "model-b" :name "Model B" :provider "test")))
         (selected-model (list :id "model-b" :name "Model B" :provider "test")))
    (unwind-protect
        (cl-letf (((symbol-function 'pi-coding-agent--rpc-sync)
                   (lambda (&rest _) (list :success t :data (list :models available-models))))
                  ((symbol-function 'pi-coding-agent--rpc-async)
                   (lambda (_proc _cmd callback)
                     (funcall callback (list :success t :command "set_model" :data selected-model))))
                  ((symbol-function 'completing-read)
                   (lambda (&rest _) "Model B")))
          (with-current-buffer buf-a
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--process :proc-a)
            (setq pi-coding-agent--state '(:model (:name "Model A" :id "model-a"))))
          (with-current-buffer buf-b
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--process :proc-b)
            (setq pi-coding-agent--state '(:model (:name "Model B-old" :id "model-b-old"))))
          (with-current-buffer buf-a
            (pi-coding-agent-select-model))
          (let ((model-a (with-current-buffer buf-a
                           (plist-get (plist-get pi-coding-agent--state :model) :name)))
                (model-b (with-current-buffer buf-b
                           (plist-get (plist-get pi-coding-agent--state :model) :name))))
            (should (equal (list model-a model-b)
                           '("Model B" "Model B-old")))))
      (mapc (lambda (buf)
              (with-current-buffer buf
                (setq pi-coding-agent--process nil))
              (kill-buffer buf))
            (list buf-a buf-b)))))

(ert-deftest pi-coding-agent-test-update-state-refreshes-header ()
  "Updating state should trigger header-line refresh."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "old-model") :thinking-level "low"))
    (let ((header-before (pi-coding-agent--header-line-string)))
      ;; Simulate state update
      (setq pi-coding-agent--state '(:model (:name "new-model") :thinking-level "high"))
      (let ((header-after (pi-coding-agent--header-line-string)))
        ;; Header string should reflect new state
        (should (string-match-p "new-model" header-after))
        (should (string-match-p "high" header-after))))))

(ert-deftest pi-coding-agent-test-apply-state-response-updates-buffer ()
  "Apply state response updates buffer-local variables in correct buffer."
  (let ((chat-buf (generate-new-buffer "*test-apply-state*")))
    (unwind-protect
        (progn
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (setq pi-coding-agent--state nil
                  pi-coding-agent--status nil))
          ;; Call from a different buffer to verify buffer context handling
          (with-temp-buffer
            (pi-coding-agent--apply-state-response
             chat-buf
             '(:success t :data (:isStreaming :false
                                 :sessionFile "/tmp/test.jsonl"
                                 :model "test-model"))))
          ;; Verify state was updated in chat-buf, not temp buffer
          (with-current-buffer chat-buf
            (should (eq pi-coding-agent--status 'idle))
            (should (equal (plist-get pi-coding-agent--state :session-file)
                           "/tmp/test.jsonl"))))
      (kill-buffer chat-buf))))

(ert-deftest pi-coding-agent-test-apply-state-response-handles-dead-buffer ()
  "Apply state response handles dead buffer gracefully."
  (let ((chat-buf (generate-new-buffer "*test-dead-buf*")))
    (kill-buffer chat-buf)
    ;; Should not error when buffer is dead
    (pi-coding-agent--apply-state-response
     chat-buf
     '(:success t :data (:sessionFile "/tmp/test.jsonl")))))

(ert-deftest pi-coding-agent-test-header-line-model-is-clickable ()
  "Model name in header-line has click properties."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "claude-sonnet-4")))
    (let ((header (pi-coding-agent--header-line-string)))
      ;; Should have local-map property
      (should (get-text-property 0 'local-map header))
      ;; Should have mouse-face for highlight
      (should (get-text-property 0 'mouse-face header)))))

(ert-deftest pi-coding-agent-test-header-line-thinking-is-clickable ()
  "Thinking level in header-line cycles on mouse click."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (setq pi-coding-agent--state '(:model (:name "test") :thinking-level "high"))
    (let* ((header (pi-coding-agent--header-line-string))
           ;; Find position of "high" in header
           (pos (string-match "high" header))
           (map (and pos (get-text-property pos 'local-map header))))
      (should pos)
      ;; Should have local-map at that position
      (should map)
      ;; Should have mouse-face for highlight
      (should (get-text-property pos 'mouse-face header))
      (should (eq (lookup-key map [header-line mouse-1])
                  #'pi-coding-agent-cycle-thinking))
      (should (eq (lookup-key map [header-line mouse-2])
                  #'pi-coding-agent-cycle-thinking)))))

(ert-deftest pi-coding-agent-test-header-format-context-returns-nil-when-no-window ()
  "Context format returns nil when context window is 0."
  (should (null (pi-coding-agent--header-format-context 25.0 0))))

(ert-deftest pi-coding-agent-test-header-format-context-shows-percentage ()
  "Context format shows percentage and window size."
  (let ((result (pi-coding-agent--header-format-context 25.0 200000)))
    (should (string-match-p "25.0%%" result))
    (should (string-match-p "200k" result))))

(ert-deftest pi-coding-agent-test-header-format-context-shows-unknown-when-percent-nil ()
  "Context format shows unknown usage when percentage is unavailable."
  (let ((result (pi-coding-agent--header-format-context nil 200000)))
    (should (string-match-p "\\?/200k" result))))

(ert-deftest pi-coding-agent-test-header-format-context-warning-over-70 ()
  "Context format uses warning face over 70%."
  (let ((result (pi-coding-agent--header-format-context 75.0 200000)))
    (should (eq (get-text-property 0 'face result) 'warning))))

(ert-deftest pi-coding-agent-test-header-format-context-error-over-90 ()
  "Context format uses error face over 90%."
  (let ((result (pi-coding-agent--header-format-context 95.0 200000)))
    (should (eq (get-text-property 0 'face result) 'error))))

(ert-deftest pi-coding-agent-test-message-end-refreshes-header-for-assistant ()
  "Assistant message_end refreshes header stats for fresher cost updates."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((refresh-count 0))
      (cl-letf (((symbol-function 'pi-coding-agent--refresh-header)
                 (lambda () (setq refresh-count (1+ refresh-count)))))
        (pi-coding-agent--handle-display-event
         '(:type "message_end"
           :message (:role "assistant"
                     :stopReason "stop"
                     :usage (:input 100 :output 50 :cacheRead 10 :cacheWrite 5)))))
      (should (= refresh-count 1)))))

(ert-deftest pi-coding-agent-test-message-end-does-not-refresh-header-for-user ()
  "User message_end does not trigger header stats refresh."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (let ((refresh-count 0))
      (cl-letf (((symbol-function 'pi-coding-agent--refresh-header)
                 (lambda () (setq refresh-count (1+ refresh-count)))))
        (pi-coding-agent--handle-display-event
         '(:type "message_end"
           :message (:role "user" :content "hello"))))
      (should (= refresh-count 0)))))

(ert-deftest pi-coding-agent-test-header-format-stats-returns-nil-when-no-stats ()
  "Stats format returns nil when stats is nil."
  (should (null (pi-coding-agent--header-format-stats nil))))

(ert-deftest pi-coding-agent-test-header-format-stats-shows-cost-and-context ()
  "Header stats shows cost and context percentage from contextUsage."
  (let* ((stats '(:cost 0.05
                  :contextUsage (:tokens 3500 :contextWindow 200000 :percent 1.75)))
         (result (pi-coding-agent--header-format-stats stats)))
    (should (string-match-p "\\$0.05" result))
    (should (string-match-p "1.8%%/200k" result))))

(ert-deftest pi-coding-agent-test-header-format-stats-no-context-without-context-usage ()
  "Header stats omit context display when contextUsage is absent.
Without contextUsage there is no context window to display against."
  (let* ((stats '(:cost 0.05))
         (result (pi-coding-agent--header-format-stats stats)))
    (should (string-match-p "\\$0.05" result))
    (should-not (string-match-p "\\?" result))))

(ert-deftest pi-coding-agent-test-header-format-stats-shows-unknown-when-tokens-null ()
  "Header stats show ? for context when contextUsage.tokens is :null.
This occurs after compaction before the next assistant message."
  (let* ((stats '(:cost 0.12
                  :contextUsage (:tokens :null :contextWindow 200000 :percent 0)))
         (result (pi-coding-agent--header-format-stats stats)))
    (should (string-match-p "\\$0.12" result))
    (should (string-match-p "\\?/200k" result))))

;;; File Reference Completion (@)

(ert-deftest pi-coding-agent-test-at-trigger-context ()
  "@ completion should only trigger at word boundaries, not in emails."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    ;; @ at start of buffer - should trigger
    (erase-buffer)
    (insert "@")
    (should (pi-coding-agent--at-trigger-p))
    ;; @ after space - should trigger
    (erase-buffer)
    (insert "hello @")
    (should (pi-coding-agent--at-trigger-p))
    ;; @ after newline - should trigger
    (erase-buffer)
    (insert "hello\n@")
    (should (pi-coding-agent--at-trigger-p))
    ;; @ after punctuation - should trigger
    (erase-buffer)
    (insert "see:@")
    (should (pi-coding-agent--at-trigger-p))
    ;; @ after alphanumeric (email) - should NOT trigger
    (erase-buffer)
    (insert "user@")
    (should-not (pi-coding-agent--at-trigger-p))
    ;; @ in middle of email - should NOT trigger
    (erase-buffer)
    (insert "test123@")
    (should-not (pi-coding-agent--at-trigger-p))))

(ert-deftest pi-coding-agent-test-file-reference-capf-returns-nil-without-at ()
  "File reference completion returns nil when not after @."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "hello world")
    (should-not (pi-coding-agent--file-reference-capf))))

(ert-deftest pi-coding-agent-test-file-reference-capf-returns-data-after-at ()
  "File reference completion returns data when point is after @."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    ;; Mock project files
    (setq pi-coding-agent--project-files-cache '("file1.el" "file2.py" "dir/file3.ts"))
    (setq pi-coding-agent--project-files-cache-time (float-time))
    (insert "Check @fi")
    (let ((result (pi-coding-agent--file-reference-capf)))
      (should result)
      ;; Start should be after @
      (should (= (nth 0 result) (- (point) 2)))  ; Position after @
      ;; End should be at point
      (should (= (nth 1 result) (point)))
      ;; Candidates should include matching files
      (should (member "file1.el" (nth 2 result)))
      (should (member "file2.py" (nth 2 result))))))

(ert-deftest pi-coding-agent-test-file-reference-capf-empty-prefix ()
  "File reference completion returns all files when no prefix after @."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--project-files-cache '("a.el" "b.py" "c.ts"))
    (setq pi-coding-agent--project-files-cache-time (float-time))
    (insert "See @")
    (let ((result (pi-coding-agent--file-reference-capf)))
      (should result)
      ;; Should return all files when prefix is empty
      (should (= (length (nth 2 result)) 3)))))

(ert-deftest pi-coding-agent-test-file-reference-capf-mid-line ()
  "File reference completion works in the middle of a line."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (setq pi-coding-agent--project-files-cache '("test.el"))
    (setq pi-coding-agent--project-files-cache-time (float-time))
    (insert "Look at @te and also")
    (goto-char 11)  ; Position right after "@te"
    (let ((result (pi-coding-agent--file-reference-capf)))
      (should result)
      (should (member "test.el" (nth 2 result))))))

;;; Path Completion (Tab)

(ert-deftest pi-coding-agent-test-path-capf-returns-nil-for-non-path ()
  "Path completion returns nil for text that doesn't look like a path."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "hello world")
    (should-not (pi-coding-agent--path-capf))))

(ert-deftest pi-coding-agent-test-path-capf-returns-nil-for-non-prefixed-path ()
  "Path completion returns nil for paths without ./ ../ ~/ or / prefix."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "src/file.el")
    (should-not (pi-coding-agent--path-capf))))

(ert-deftest pi-coding-agent-test-path-capf-triggers-for-dot-slash ()
  "Path completion triggers for paths starting with ./"
  (let* ((temp-dir (make-temp-file "pi-coding-agent-path-test-" t))
         (test-file (expand-file-name "test.txt" temp-dir)))
    (unwind-protect
        (progn
          (with-temp-file test-file (insert "test"))
          (let ((default-directory temp-dir))
            (with-temp-buffer
              (pi-coding-agent-input-mode)
              (setq pi-coding-agent--chat-buffer (current-buffer))
              ;; Mock session directory
              (cl-letf (((symbol-function 'pi-coding-agent--session-directory)
                         (lambda () temp-dir)))
                (insert "./te")
                (let ((result (pi-coding-agent--path-capf)))
                  (should result)
                  ;; Should have candidates
                  (should (> (length (nth 2 result)) 0)))))))
      (delete-directory temp-dir t))))

(ert-deftest pi-coding-agent-test-path-capf-triggers-for-tilde ()
  "Path completion triggers for paths starting with ~/"
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "~/")
    ;; Just verify it doesn't error and returns something
    ;; (actual completions depend on user's home directory)
    (let ((result (pi-coding-agent--path-capf)))
      ;; May return nil if ~ directory doesn't exist or has no completions
      ;; but should not error
      (should (or (null result) (listp result))))))

(ert-deftest pi-coding-agent-test-path-capf-triggers-for-absolute ()
  "Path completion triggers for absolute paths not at buffer start."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "see /tmp/")
    (let ((result (pi-coding-agent--path-capf)))
      (when result
        (should (listp (nth 2 result)))))))

(ert-deftest pi-coding-agent-test-path-capf-remote-absolute-uses-remote-root ()
  "Remote absolute path completion checks remote / but inserts /-style paths."
  (let ((default-directory "/ssh:pi-host:/home/pi/project/")
        (completion-base nil)
        (completion-dir nil)
        (directory-checks nil))
    (with-temp-buffer
      (pi-coding-agent-input-mode)
      (setq default-directory "/ssh:pi-host:/home/pi/project/")
      (cl-letf (((symbol-function 'file-directory-p)
                 (lambda (path)
                   (push path directory-checks)
                   (string-prefix-p "/ssh:pi-host:" path)))
                ((symbol-function 'file-name-all-completions)
                 (lambda (base dir)
                   (setq completion-base base
                         completion-dir dir)
                   '("log/" "local"))))
        (insert "see /var/lo")
        (let* ((result (pi-coding-agent--path-capf))
               (candidates (nth 2 result))
               (annotation (plist-get (nthcdr 3 result) :annotation-function)))
          (should result)
          (should (equal completion-base "lo"))
          (should (equal completion-dir "/ssh:pi-host:/var/"))
          (should (equal candidates '("/var/log/" "/var/local")))
          (should-not (cl-some #'file-remote-p candidates))
          (should (equal (funcall annotation "/var/log/") " (dir)"))
          (should (equal (funcall annotation "/var/local") " (file)"))
          (should (member "/ssh:pi-host:/var/" directory-checks))
          (should-not (member "/ssh:pi-host:/var/log/" directory-checks))
          (should-not (member "/var/" directory-checks)))))))

(ert-deftest pi-coding-agent-test-path-capf-multi-hop-absolute-keeps-full-route ()
  "Remote absolute path completion checks the full multi-hop TRAMP route."
  (let ((completion-base nil)
        (completion-dir nil)
        (directory-checks nil)
        (session-dir "/ssh:bastion|sudo:root@pi-host:/home/pi/project/"))
    (with-temp-buffer
      (pi-coding-agent-input-mode)
      (cl-letf (((symbol-function 'pi-coding-agent--session-directory)
                 (lambda () session-dir))
                ((symbol-function 'file-directory-p)
                 (lambda (path)
                   (push path directory-checks)
                   (equal path "/ssh:bastion|sudo:root@pi-host:/var/")))
                ((symbol-function 'file-name-all-completions)
                 (lambda (base dir)
                   (setq completion-base base
                         completion-dir dir)
                   '("log/" "local"))))
        (insert "see /var/lo")
        (let* ((result (pi-coding-agent--path-capf))
               (candidates (nth 2 result)))
          (should result)
          (should (equal completion-base "lo"))
          (should (equal completion-dir
                         "/ssh:bastion|sudo:root@pi-host:/var/"))
          (should (equal candidates '("/var/log/" "/var/local")))
          (should (member "/ssh:bastion|sudo:root@pi-host:/var/"
                          directory-checks)))))))

(ert-deftest pi-coding-agent-test-path-completions-returns-nil-for-unsafe-input ()
  "Path completion treats malformed path text as no completions."
  (let ((bad-path (concat "/tmp/bad" (string ?\0) "name")))
    (should-not (pi-coding-agent--path-completions bad-path))))

(ert-deftest pi-coding-agent-test-path-completions-excludes-dot-entries ()
  "Path completions should not include ./ or ../ entries."
  (let* ((temp-dir (make-temp-file "pi-coding-agent-path-test-" t))
         (subdir (expand-file-name "subdir" temp-dir)))
    (unwind-protect
        (progn
          (make-directory subdir)
          (cl-letf (((symbol-function 'pi-coding-agent--session-directory)
                     (lambda () temp-dir)))
            (let ((completions (pi-coding-agent--path-completions "./")))
              ;; Should have the subdir
              (should (member "./subdir/" completions))
              ;; Should NOT have ./ or ../
              (should-not (member "./" completions))
              (should-not (member "./../" completions))
              (should-not (member "././" completions)))))
      (delete-directory temp-dir t))))

(ert-deftest pi-coding-agent-test-complete-command-exists ()
  "pi-coding-agent-complete should be an interactive command."
  (should (commandp 'pi-coding-agent-complete)))

(ert-deftest pi-coding-agent-test-path-capf-skips-slash-at-buffer-start ()
  "Path completion skips / at buffer start to allow slash commands."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "/tmp")
    (should-not (pi-coding-agent--path-capf))))

(ert-deftest pi-coding-agent-test-path-capf-allows-slash-on-later-lines ()
  "Path completion works for / on lines after the first."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "Check this file:\n/tmp/")
    (let ((result (pi-coding-agent--path-capf)))
      (when result
        (should (listp (nth 2 result)))))))

(ert-deftest pi-coding-agent-test-tool-start-creates-overlay ()
  "tool_execution_start creates an overlay with pending face."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    ;; Should have an overlay with pi-coding-agent-tool-block property
    (goto-char (point-min))
    (let* ((overlays (overlays-at (point)))
           (tool-ov (seq-find (lambda (o) (overlay-get o 'pi-coding-agent-tool-block)) overlays)))
      (should tool-ov)
      (should (eq (overlay-get tool-ov 'face) 'pi-coding-agent-tool-block))
      (should (equal (overlay-get tool-ov 'pi-coding-agent-tool-name) "bash")))))

(ert-deftest pi-coding-agent-test-tool-start-header-format ()
  "tool_execution_start uses simple header format, not drawer syntax."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls -la"))
    ;; Should have "$ ls -la" header
    (should (string-match-p "\\$ ls -la" (buffer-string)))
    ;; Should NOT have drawer syntax
    (should-not (string-match-p ":BASH:" (buffer-string)))))

(ert-deftest pi-coding-agent-test-tool-end-keeps-overlay-face ()
  "tool_execution_end keeps base face on success."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    ;; Initially base face
    (let ((ov (car (overlays-at (point-min)))))
      (should (eq (overlay-get ov 'face) 'pi-coding-agent-tool-block)))
    ;; After success — face stays the same
    (pi-coding-agent--display-tool-end "bash" '(:command "ls")
                          '((:type "text" :text "file.txt"))
                          nil nil)
    (let ((ov (car (overlays-at (point-min)))))
      (should (eq (overlay-get ov 'face) 'pi-coding-agent-tool-block)))))

(ert-deftest pi-coding-agent-test-tool-end-error-face ()
  "tool_execution_end sets error face on failure."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "bad"))
    (pi-coding-agent--display-tool-end "bash" '(:command "bad")
                          '((:type "text" :text "error"))
                          nil t)  ; is-error = t
    (let ((ov (car (overlays-at (point-min)))))
      (should (eq (overlay-get ov 'face) 'pi-coding-agent-tool-block-error)))))

(ert-deftest pi-coding-agent-test-tool-end-no-drawer-syntax ()
  "tool_execution_end does not insert :END: marker."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-tool-start "bash" '(:command "ls"))
    (pi-coding-agent--display-tool-end "bash" '(:command "ls")
                          '((:type "text" :text "output"))
                          nil nil)
    (should-not (string-match-p ":END:" (buffer-string)))))

(ert-deftest pi-coding-agent-test-tool-overlay-does-not-extend-to-subsequent-content ()
  "Tool overlay should not extend when content is inserted after tool block.
Regression test: overlay with rear-advance was extending to subsequent content."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    ;; Create a complete tool block
    (pi-coding-agent--display-tool-start "write" '(:path "/tmp/test.txt" :content "hello"))
    (pi-coding-agent--display-tool-end "write" '(:path "/tmp/test.txt" :content "hello")
                          '((:type "text" :text "Written to /tmp/test.txt"))
                          nil nil)
    ;; Simulate inserting more content after the tool (like next message)
    (let ((inhibit-read-only t))
      (goto-char (point-max))
      (insert "AFTER_TOOL_CONTENT\n"))
    ;; The new content should NOT be inside any tool overlay
    (let* ((new-content-pos (- (point-max) 10))  ; somewhere in AFTER_TOOL_CONTENT
           (overlays (overlays-at new-content-pos))
           (tool-overlay (seq-find
                          (lambda (ov) (overlay-get ov 'pi-coding-agent-tool-block))
                          overlays)))
      (should-not tool-overlay))))

(ert-deftest pi-coding-agent-test-abort-mid-tool-cleans-up-overlay ()
  "Aborting mid-tool should clean up the pending overlay.
When abort happens during tool execution, tool_execution_end never arrives.
display-agent-end must finalize the pending overlay with error face."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    ;; Start a tool (creates pending overlay)
    (pi-coding-agent--display-tool-start "bash" '(:command "sleep 100"))
    ;; Verify overlay is pending
    (should pi-coding-agent--pending-tool-overlay)
    (should (eq (overlay-get pi-coding-agent--pending-tool-overlay 'face)
                'pi-coding-agent-tool-block))
    ;; Simulate abort - display-agent-end is called WITHOUT tool-end
    (setq pi-coding-agent--aborted t)
    (pi-coding-agent--display-agent-end)
    ;; Pending overlay variable should be nil
    (should-not pi-coding-agent--pending-tool-overlay)
    ;; But there should still be a finalized overlay with error face
    (goto-char (point-min))
    (let* ((overlays (overlays-at (point)))
           (tool-ov (seq-find (lambda (o) (overlay-get o 'pi-coding-agent-tool-block)) overlays)))
      (should tool-ov)
      (should (eq (overlay-get tool-ov 'face) 'pi-coding-agent-tool-block-error)))
    ;; Content inserted after should NOT be inside the overlay
    (let ((inhibit-read-only t))
      (goto-char (point-max))
      (insert "AFTER_ABORT_CONTENT\n"))
    (let* ((new-content-pos (- (point-max) 10))
           (overlays (overlays-at new-content-pos))
           (tool-overlay (seq-find
                          (lambda (ov) (overlay-get ov 'pi-coding-agent-tool-block))
                          overlays)))
      (should-not tool-overlay))))

(ert-deftest pi-coding-agent-test-delta-no-transform-inside-code-block ()
  "Hash inside fenced code block should NOT be transformed."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-agent-start)
    (pi-coding-agent--display-message-delta "```python\n# This is a comment\n```")
    ;; The # inside code block should stay as single #
    (should (string-match-p "^# This is a comment$" (buffer-string)))))

(ert-deftest pi-coding-agent-test-delta-transform-resumes-after-code-block ()
  "Headings after code block closes should be transformed."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-agent-start)
    (pi-coding-agent--display-message-delta "```\n# comment\n```\n# Real Heading")
    ;; Inside block: stays #
    (should (string-match-p "^# comment$" (buffer-string)))
    ;; After block: becomes ##
    (should (string-match-p "^## Real Heading" (buffer-string)))))

(ert-deftest pi-coding-agent-test-delta-code-fence-split-across-deltas ()
  "Code fence split across deltas still detected."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-agent-start)
    (pi-coding-agent--display-message-delta "``")
    (pi-coding-agent--display-message-delta "`python\n# comment\n```")
    ;; Should recognize the split ``` and not transform inside
    (should (string-match-p "^# comment$" (buffer-string)))))

(ert-deftest pi-coding-agent-test-delta-backticks-mid-line-not-fence ()
  "Backticks mid-line don't trigger code block state."
  (with-temp-buffer
    (pi-coding-agent-chat-mode)
    (pi-coding-agent--display-agent-start)
    (pi-coding-agent--display-message-delta "Use ```code``` inline\n# Heading")
    ;; Inline backticks shouldn't affect heading transform
    (should (string-match-p "^## Heading" (buffer-string)))))

;;; Input Mode — Markdown Highlighting

(ert-deftest pi-coding-agent-test-input-mode-md-ts-by-default ()
  "By default, input mode has tree-sitter markdown font-lock."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should (derived-mode-p 'pi-coding-agent-input-mode))
    (insert "some **bold** text")
    (font-lock-ensure)
    (goto-char (point-min))
    (search-forward "bold")
    (should (memq 'bold
                  (let ((f (get-text-property (1- (point)) 'face)))
                    (if (listp f) f (list f)))))))

(ert-deftest pi-coding-agent-test-input-mode-no-metadata-face ()
  "With markdown highlighting, lines ending with colon have no metadata face.
Tree-sitter markdown doesn't have metadata face, so this verifies
no spurious faces are applied to plain colon-ending lines."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (insert "Fix the bug:\n- item\n")
    (font-lock-ensure)
    (goto-char (point-min))
    (let ((f (get-text-property (point) 'face)))
      ;; No heading, bold, or other markdown face on plain text
      (should-not (and f (not (eq f 'default)))))))

(ert-deftest pi-coding-agent-test-input-mode-no-hidden-markup ()
  "Input mode does NOT hide markup, even when user customizes it globally."
  (with-temp-buffer
    (let ((old-default (default-value 'md-ts-hide-markup)))
      (unwind-protect
          (progn
            (setq-default md-ts-hide-markup t)
            (pi-coding-agent-input-mode)
            (should-not md-ts-hide-markup)
            (insert "some **bold** text")
            (font-lock-ensure)
            (goto-char (point-min))
            (search-forward "**")
            (should-not (get-text-property (1- (point)) 'invisible)))
        (setq-default md-ts-hide-markup old-default)))))

(ert-deftest pi-coding-agent-test-input-mode-no-fontification-without-markdown ()
  "Without markdown highlighting, bold text gets no bold face."
  (with-temp-buffer
    (let ((pi-coding-agent-input-markdown-highlighting nil))
      (pi-coding-agent-input-mode)
      (insert "some **bold** text")
      (font-lock-ensure)
      (goto-char (point-min))
      (search-forward "bold")
      (should-not (memq 'bold
                        (let ((f (get-text-property (1- (point)) 'face)))
                          (if (listp f) f (list f))))))))

(ert-deftest pi-coding-agent-test-input-mode-keybindings ()
  "Pi input keybindings are active in input mode."
  (with-temp-buffer
    (pi-coding-agent-input-mode)
    (should (eq (key-binding (kbd "C-c C-c")) 'pi-coding-agent-send))
    (should (eq (key-binding (kbd "C-c C-k")) 'pi-coding-agent-abort))
    (should (eq (key-binding (kbd "C-c C-p")) 'pi-coding-agent-menu))
    (should (eq (key-binding (kbd "C-c C-n")) 'pi-coding-agent-new-session))
    (should (eq (key-binding (kbd "C-c C-r")) 'pi-coding-agent-resume-session))
    (should (eq (key-binding (kbd "C-c C-e")) 'pi-coding-agent-export-html))
    (should (eq (key-binding (kbd "C-c C-m")) 'pi-coding-agent-select-model))
    (should (eq (key-binding (kbd "C-c C-t")) 'pi-coding-agent-cycle-thinking))
    (should (eq (key-binding (kbd "C-c C-y")) 'pi-coding-agent-copy-last-message))
    (should (eq (key-binding (kbd "M-p")) 'pi-coding-agent-previous-input))
    (should (eq (key-binding (kbd "M-n")) 'pi-coding-agent-next-input))
    (should (eq (key-binding (kbd "TAB")) 'pi-coding-agent-complete))
    (should (eq (key-binding (kbd "C-c C-s")) 'pi-coding-agent-queue-steering))))

(ert-deftest pi-coding-agent-test-input-chat-c-c-key-parity ()
  "Input mode mirrors chat mode's C-c session-management chords.
Every C-c chord in `pi-coding-agent-chat-mode-map' is bound to the
same command in `pi-coding-agent-input-mode-map', except C-c C-c,
which means `pi-coding-agent-send' in the input buffer."
  (let ((chat-c-c (lookup-key pi-coding-agent-chat-mode-map (kbd "C-c")))
        (input-c-c (lookup-key pi-coding-agent-input-mode-map (kbd "C-c"))))
    (should (keymapp chat-c-c))
    (map-keymap
     (lambda (event def)
       (when (symbolp def)
         (if (eq event ?\C-c)
             (should (eq (lookup-key input-c-c (vector event))
                         'pi-coding-agent-send))
           (should (eq (lookup-key input-c-c (vector event)) def)))))
     chat-c-c)))

;;; Input-Buffer Chat Navigation

(ert-deftest pi-coding-agent-test-input-next-message-moves-chat ()
  "Input-side next-message moves the linked chat and keeps focus."
  (let ((chat-buf (generate-new-buffer "*test-chat*"))
        (input-buf (generate-new-buffer "*test-input*")))
    (unwind-protect
        (progn
          (delete-other-windows)
          (switch-to-buffer chat-buf)
          (with-current-buffer chat-buf
            (pi-coding-agent-chat-mode)
            (let ((inhibit-read-only t))
              (pi-coding-agent-test--insert-chat-turns))
            (pi-coding-agent--set-input-buffer input-buf)
            (goto-char (point-min)))
          (let ((input-win (split-window nil -10 'below)))
            (set-window-buffer input-win input-buf)
            (with-current-buffer input-buf
              (pi-coding-agent-input-mode)
              (pi-coding-agent--set-chat-buffer chat-buf))
            (select-window input-win)
            (pi-coding-agent-input-next-message)
            (with-current-buffer chat-buf
              (should (looking-at "You · 10:00")))
            (should (eq (window-buffer (selected-window)) input-buf))))
      (kill-buffer chat-buf)
      (kill-buffer input-buf)
      (delete-other-windows))))

(ert-deftest pi-coding-agent-test-input-previous-message-moves-linked-chat ()
  "Input-side previous-message uses the linked chat, not scroll state."
  (let ((chat-a (generate-new-buffer "*test-chat-a*"))
        (chat-b (generate-new-buffer "*test-chat-b*"))
        (input-buf (generate-new-buffer "*test-input*")))
    (unwind-protect
        (progn
          (delete-other-windows)
          (switch-to-buffer chat-a)
          (let* ((chat-win-a (selected-window))
                 (input-win (split-window chat-win-a -10 'below))
                 (chat-win-b (split-window chat-win-a nil 'right)))
            (set-window-buffer input-win input-buf)
            (set-window-buffer chat-win-b chat-b)
            (with-current-buffer chat-a
              (pi-coding-agent-chat-mode)
              (let ((inhibit-read-only t))
                (pi-coding-agent-test--insert-chat-turns))
              (goto-char (point-max))
              (re-search-backward "^You · 10:10$" nil t))
            (with-current-buffer chat-b
              (pi-coding-agent-chat-mode)
              (let ((inhibit-read-only t))
                (pi-coding-agent-test--insert-chat-turns))
              (goto-char (point-max))
              (re-search-backward "^You · 10:10$" nil t))
            (with-current-buffer input-buf
              (pi-coding-agent-input-mode)
              (pi-coding-agent--set-chat-buffer chat-a)
              (setq-local other-window-scroll-buffer chat-b))
            (select-window input-win)
            (pi-coding-agent-input-previous-message)
            (with-current-buffer chat-a
              (should (looking-at "You · 10:05")))
            (with-current-buffer chat-b
              (should (looking-at "You · 10:10")))
            (should (eq (window-buffer (selected-window)) input-buf))))
      (kill-buffer chat-a)
      (kill-buffer chat-b)
      (kill-buffer input-buf)
      (delete-other-windows))))

(ert-deftest pi-coding-agent-test-input-previous-message-no-chat-window-errors ()
  "Navigating from input without a visible linked chat signals error."
  (let ((chat-buf (generate-new-buffer "*test-chat-hidden*")))
    (unwind-protect
        (with-temp-buffer
          (pi-coding-agent-input-mode)
          (pi-coding-agent--set-chat-buffer chat-buf)
          (should-error (pi-coding-agent-input-previous-message)
                        :type 'user-error))
      (kill-buffer chat-buf))))

(provide 'pi-coding-agent-input-test)
;;; pi-coding-agent-input-test.el ends here