#+TITLE: Passepartout TUI — View
#+PROPERTY: header-args:lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp

* View

|Pure render functions. Each takes the cl-tty backend and current state.
|State is read via ~(st :key)~ — no mutation here.

** Contract

1. (view-status fb w h): no-op. Status bar is a clean black line.
2. (view-chat fb w h): renders scrolled chat messages. User messages
   get amber left border (│), agent messages no border, streaming
   agent gets grey left border. Gate traces/tool calls use ╎ prefix.
3. (view-input fb w h): renders expanding light grey input box,
   multi-line word-wrapped prompt, software blinking cursor (█),
   right-aligned lowercase hint at h-2.
4. (redraw fb w h): wraps view-status/chat/input in begin-sync/end-sync,
   dispatches per dirty flags, fills global :bg first.
5. (char-width ch): returns terminal column width of character CH.
   ASCII < 128 = 1. CJK, fullwidth, emoji = 2. Combining marks = 0.
   Tab = 8. Used by word-wrap for accurate line counting (v0.7.0).
6. (sidebar-visible-p w): returns T if sidebar should show given width W
   and current :sidebar-mode (:auto >120, :visible always, :hidden never).

** Status Bar

The status bar, as of v0.4.0, renders Passepartout's three differentiator
visualizations — data only available because of the deterministic gate
architecture:

- *Rule counter* (~Rules:N~): the number of pending HITL actions from the
  Dispatcher's ~*hitl-pending*~ hash table. The user watches this tick up
  as they teach the agent their preferences through approve/deny decisions.
- *Focus map* (~[Focus: <id>]~): the foveal focus from the daemon's signal
  context. Shows the user what the agent is currently looking at.
- *Gate trace* (not rendered in status bar — attached to individual
  messages via ~:gate-trace~ field for future collapsible rendering per
  message).

All three enrichments cost 0 LLM tokens — they are daemon-state queries
that the TUI actuator attaches to the response plist before transmission.

#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(in-package :passepartout.channel-tui)

(defun sidebar-visible-p (w)
  "Compute whether sidebar should be shown given terminal width W
and current sidebar mode (:auto/:visible/:hidden)."
  (let ((mode (st :sidebar-mode)))
    (or (eq mode :visible)
        (and (eq mode :auto) (> w 120)))))

(defun word-wrap (text width)
  "Wrap TEXT to at most WIDTH columns. Splits on word boundaries.
Returns a list of strings, one per line."
  (let ((lines nil))
    (loop while (> (length text) width)
          do (let ((break (or (position #\Space text :end width :from-end t)
                              width)))
               (push (subseq text 0 break) lines)
               (setf text (string-left-trim '(#\Space)
                            (subseq text break)))))
    (push text lines)
    (nreverse lines)))

(defun view-status (fb w h)
  (declare (ignore fb w h))
  ;; Status bar is now a clean black line — blends with global :bg.
  ;; No clock, no dot, no text. Everything clean.
  )

(defun cursor-visible-p ()
  "Returns T if the blinking cursor should be visible this frame (2Hz)."
  (evenp (floor (get-internal-real-time)
                (floor internal-time-units-per-second 2))))

(defun input-panel-top (chat-w h)
  "Compute the top row of the input panel based on current input buffer."
  (let* ((hpad 2)
         (inner-w (- chat-w (* 2 hpad)))
         (prompt-w (- inner-w 2))
         (text (input-string))
         (lines (word-wrap text prompt-w))
         (n-lines (max 1 (length lines)))
         (panel-rows (max 4 (+ n-lines 2))))
    (- h 4 panel-rows -1)))


;; v0.7.2: search-highlight — wrap matching text in **bold** for markdown
(defun search-highlight (content query)
  "Wrap occurrences of QUERY in CONTENT with **bold** markers."
  (let ((lower-content (string-downcase content))
        (lower-query (string-downcase query))
        (result "") (pos 0))
    (when (and query (> (length query) 0))
      (loop
        (let ((found (search lower-query lower-content :start2 pos)))
          (unless found (return))
          (setf result (concatenate 'string result
                                   (subseq content pos found)
                                   "**" (subseq content found (+ found (length query))) "**"))
          (setf pos (+ found (length query)))))
      (setf result (concatenate 'string result (subseq content pos)))
      (if (string= result "") content result))))

(defun view-chat (fb w h)
  (let* ((w (or (and (numberp w) (> w 0) w) 80))
         (h (or (and (numberp h) (> h 0) h) 24))
          (hpad 2)
          (sidebar-w (if (sidebar-visible-p w) (or (st :sidebar-width) 42) 0))
          (chat-w (- w sidebar-w))
          (msgs (st :messages)) (total (length msgs))
          (panel-top (input-panel-top chat-w h))
          (max-lines (max 0 panel-top)) (is-search (st :search-mode))
          (bordered-w (- chat-w (* 2 hpad) 2))
          (unbordered-w (- chat-w (* 2 hpad)))
          (y 0))
    (when is-search
      (let* ((matches (st :search-matches)) (idx (st :search-match-idx))
             (query (st :search-query))
             (hdr (format nil "Search: ~d matches for '~a' (~d/~d) — Esc to exit"
                          (length matches) query (1+ idx) (length matches))))
        (cl-tty.backend:draw-text fb hpad y hdr (theme-color :accent) nil)
        (incf y) (decf max-lines)))
    (let ((msg-lines (make-array total)) (msg-heights (make-array total)))
      (dotimes (i total)
        (let* ((msg (aref msgs i)) (role (getf msg :role))
               (content (getf msg :content))
               (cs (if is-search (search-highlight content (st :search-query)) content))
               (pairs nil)
               (think-bg (theme-color :thinking-bg))
               (sym-bdr (theme-color :symbolic-border))
               (agent-bdr (theme-color :agent-border))
               (user-bdr (theme-color :user-border))
               (user-fg (theme-color :user-fg))
               (agent-fg (theme-color :agent-fg))
               (system-fg (theme-color :system)))
          (case role
            (:user
             (dolist (l (cl-tty.box:word-wrap cs bordered-w))
               (push (list "│" user-bdr l user-fg) pairs)))
            (             :agent
             (let* ((streaming (getf msg :streaming))
                    (think-rect (if streaming think-bg nil))
                    (bdr (if streaming nil agent-bdr))
                    (bstr (if streaming nil "│"))
                    (wrap-w (if streaming unbordered-w bordered-w))
                    (nodes (cl-tty.markdown:parse-blocks cs))
                    (raw-body (or (and nodes (cl-tty.markdown:render-md nodes)) (list "")))
                    (body (mapcan (lambda (l) (cl-tty.box:word-wrap l wrap-w)) raw-body)))
               (dolist (l body)
                 (push (list bstr bdr l agent-fg think-rect) pairs))))
            (t (dolist (l (cl-tty.box:word-wrap cs unbordered-w))
                 (push (list nil nil l system-fg) pairs))))
          ;; Gate trace
          (let ((gt (getf msg :gate-trace)))
            (when (and gt (eq role :agent))
              (if (member i (st :collapsed-gates))
                  (push (list "│" sym-bdr (format nil "Gate trace: ~a gates" (length gt)) sym-bdr) pairs)
                  (dolist (entry (passepartout::gate-trace-lines gt))
                    (let ((ec (theme-color (getf (cdr entry) :fgcolor))))
                      (dolist (l (cl-tty.box:word-wrap (car entry) bordered-w))
                        (push (list "│" sym-bdr l ec) pairs)))))))
          ;; Tool calls
          (let ((tc (getf msg :tool-calls)))
            (when tc
              (if (member i (st :collapsed-tools))
                  (let* ((n (or (getf (first tc) :name) "tool"))
                         (d (or (getf (first tc) :duration) 0.0)))
                    (push (list "│" (theme-color :tool-done) (format nil "~a … ~,1fs" n d) (theme-color :tool-done)) pairs))
                  (dolist (call tc)
                    (let* ((name (or (getf call :name) "tool"))
                           (dur (or (getf call :duration) 0.0))
                           (st (getf call :status))
                           (out (getf call :output))
                           (bc (theme-color
                                (cond ((eq st :running) :tool-running)
                                      ((eq st :error) :tool-error)
                                      (t :tool-done))))
                           (pfx (cond ((eq st :error) "✗") ((eq st :running) "●") (t "✓")))
                           (ol (when out (cl-tty.box:word-wrap out bordered-w))))
                      (push (list "│" bc (format nil "~a ~a  ~,1fs" pfx name dur) bc) pairs)
                      (dolist (l ol)
                        (push (list "│" bc l bc) pairs)))))))
          (setf (aref msg-lines i) (nreverse pairs))
          (setf (aref msg-heights i) (length pairs))))
      (let ((msg-count 0) (lines-remaining max-lines))
        (loop for i from (1- total) downto 0
              while (> lines-remaining 0)
               do (let ((mh (aref msg-heights i))
                          (spacer (if (< i (1- total)) 1 0)))
                   (if (<= (+ mh spacer) lines-remaining)
                       (progn (decf lines-remaining (+ mh spacer)) (incf msg-count))
                       (setf lines-remaining 0))))
        (let* ((scroll-skip (st :scroll-offset))
               (start (max 0 (- total msg-count scroll-skip))))
            (loop for i from start below total while (< y panel-top)
                  do (let ((pairs (aref msg-lines i)))
                     (dolist (pair pairs)
                        (when (>= y panel-top) (return))
                         (destructuring-bind (bstr bcolor tstr tcolor &optional rect-bg) pair
                           (when rect-bg
                             (cl-tty.backend:draw-rect fb 0 y 1 1 :bg rect-bg))
                           (let ((has-border (and bstr (> (length bstr) 0))))
                             (when has-border
                               (cl-tty.backend:draw-text fb hpad y bstr bcolor nil))
                             (cl-tty.backend:draw-text fb (+ hpad (if has-border 2 0)) y tstr tcolor nil)))
                        (incf y))
                       ;; spacer between message blocks
                        (when (< i (1- total))
                          (incf y)))))))))
#+END_SRC

** Input Line
#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(defun view-input (fb w h)
  (let* ((w (or (and (numberp w) (> w 0) w) 80))
         (h (or (and (numberp h) (> h 0) h) 24))
         (hpad 2)
         (sidebar-w (if (sidebar-visible-p w) (or (st :sidebar-width) 42) 0))
         (chat-w (- w sidebar-w))
         (inner-w (- chat-w (* 2 hpad)))
         (prompt-w (- inner-w 2))
         (text (input-string))
         (pos (or (st :cursor-pos) 0))
         (lines (word-wrap text prompt-w))
         (n-lines (max 1 (length lines)))
          (panel-rows (max 4 (+ n-lines 2)))
          (panel-top (input-panel-top chat-w h))
         (bg-i (theme-color :bg-input))
         (input-fg (theme-color :input-fg))
         (hint-fg (theme-color :hint)))
    ;; Fill input panel: panel-top to h-4, indented by hpad
    (cl-tty.backend:draw-rect fb hpad panel-top inner-w panel-rows :bg bg-i)
    ;; Speaker lines for all input rows
    (dotimes (r panel-rows)
      (cl-tty.backend:draw-text fb hpad (+ panel-top r) "│" (theme-color :input-prompt) nil))
    ;; Draw each wrapped input line
    (let ((accum 0) (cursor-line 0) (cursor-col 0))
      (dotimes (i n-lines)
        (let* ((line (nth i lines))
               (row (+ panel-top 1 i))
               (len (length line)))
          (when (>= row (- h 4)) (return))
          (cl-tty.backend:draw-text fb (+ hpad 2) row line input-fg nil)
          (when (and (>= pos accum) (<= pos (+ accum len)))
            (setf cursor-line i
                  cursor-col (- pos accum)))
          (incf accum (1+ len))))
      ;; Draw software blinking cursor at insertion point
      (when (cursor-visible-p)
        (let ((cursor-row (+ panel-top 1 cursor-line)))
          (cl-tty.backend:draw-text fb (+ hpad 2 cursor-col) cursor-row "█" input-fg nil))))
    ;; Hint — lowercase, right-aligned at h-2
    (let ((hint "ctrl+p | /help"))
      (cl-tty.backend:draw-text fb (- chat-w (length hint) 2) (- h 2) hint hint-fg (theme-color :bg)))))
#+end_src

** Sidebar
#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(defun view-sidebar (fb w h)
  "Render the right-side sidebar panel."
  (let* ((w (or (and (numberp w) (> w 0) w) 80))
         (h (or (and (numberp h) (> h 0) h) 24))
         (x (- w (or (st :sidebar-width) 42)))
         (bg-panel (theme-color :bg-panel))
         (y 0))
    ;; Fill sidebar background (h-1 done separately to avoid scroll)
    (cl-tty.backend:draw-rect fb x 0 (- w x) (1- h) :bg bg-panel)
    (cl-tty.backend:draw-text fb x (1- h) (make-string (- w x) :initial-element #\Space) nil bg-panel)
    ;; Focus panel
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) "FOCUS" (theme-color :accent) bg-panel)
    (incf y)
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) (format nil "  ~a" (or (st :foveal-id) "none"))
                              (theme-color :agent-fg) bg-panel)
    (incf y 2)
    ;; Rules panel
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) "RULES" (theme-color :accent) bg-panel)
    (incf y)
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) (format nil "  ~d active" (or (st :rule-count) 0))
                              (theme-color :agent-fg) bg-panel)
    (incf y 2)
    ;; Context panel — token gauge
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) "CONTEXT" (theme-color :accent) bg-panel)
    (let* ((msg-count (max 1 (length (st :messages))))
           (est (* msg-count 60))
           (limit 8192)
           (pct (min 100 (floor (* 100 est) limit)))
           (bar-len (floor pct 10))
           (bar (make-string bar-len :initial-element #\#)))
      (cl-tty.backend:draw-text fb (+ x 2) (incf y)
                               (format nil "  [~a~a]" bar
                                       (make-string (- 10 bar-len) :initial-element #\Space))
                               (theme-color :dim) bg-panel)
      (incf y)
      (cl-tty.backend:draw-text fb (+ x 2) (incf y) (format nil "  ~d%" pct)
                               (theme-color :status-fg) bg-panel)
      (incf y 2))
    ;; MCP panel
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) "MCP" (theme-color :accent) bg-panel)
    (incf y)
    (cl-tty.backend:draw-text fb (+ x 2) (incf y) (format nil "  ~d server~:p" (or (st :mcp-count) 0))
                              (theme-color :agent-fg) bg-panel)
    ;; Version footer at bottom with connection dot
    (let* ((ver (or (st :daemon-version) ""))
           (ver-label (if (> (length ver) 0) (format nil "passepartout ~a" ver) "passepartout"))
           (dot (if (st :connected) "●" "○"))
           (dot-color (if (st :connected) (theme-color :dot-connected) (theme-color :dot-disconnected))))
      (cl-tty.backend:draw-text fb (+ x 2) (- h 2) dot dot-color bg-panel)
      (cl-tty.backend:draw-text fb (+ x 4) (- h 2) ver-label (theme-color :text-muted) bg-panel))))
#+END_SRC

** Redraw (dirty-flag dispatch)
#+begin_src lisp
(defun redraw (fb w h)
  (setq w (or (and (numberp w) (> w 0) w) 80)
        h (or (and (numberp h) (> h 0) h) 24))
  (when (or (first (st :dirty)) (second (st :dirty)) (third (st :dirty)))
    (cl-tty.backend:begin-sync fb)
    (cl-tty.backend:draw-rect fb 0 0 w h :bg (theme-color :bg))
    (view-status fb w h)
    (view-chat fb w h)
    (view-input fb w h)
    (when (sidebar-visible-p w)
      (view-sidebar fb w h))
    (cl-tty.backend:end-sync fb)
    (setf (st :dirty) (list nil nil nil))))

(defun cursor-visible-p ()
  "Returns T if the software-cursor should be visible this frame (2Hz)."
  (evenp (floor (get-internal-real-time)
                (floor internal-time-units-per-second 2))))

(defun position-cursor (fb w h)
  "Position terminal cursor at input insertion point and draw █ software cursor."
  (let* ((sw (if (sidebar-visible-p w) (or (st :sidebar-width) 42) 0))
         (cw (- w sw))
         (hpad 2)
         (text (input-string))
         (pos (or (st :cursor-pos) 0))
         (prompt-w (- cw (* 2 hpad) 2))
         (display-start (max 0 (- pos (1- prompt-w))))
         (cx (+ hpad 2 (- pos display-start)))
         (cy (- h 6)))
    (cl-tty.backend:cursor-move fb cx cy)
    (cl-tty.backend:cursor-style fb :block :blink t)
    ;; Software █ cursor — erase old position with space, draw new position
    (cl-tty.backend:draw-text fb cx cy (if (cursor-visible-p) "█" " ") (theme-color :input-fg) nil)))
#+END_SRC

* Implementation — v0.7.0 additions
#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(in-package :passepartout)

(defun char-width (ch)
  "Returns the terminal column width of character CH.
ASCII < 128 = 1. CJK, fullwidth, emoji = 2. Combining marks = 0. Tab = 8."
  (let ((code (char-code ch)))
    (cond
      ((= code 9) 8)
      ((< code 32) 0)
      ((<= code 127) 1)
      ((<= #x4E00 code #x9FFF) 2)
      ((<= #x3400 code #x4DBF) 2)
      ((<= #x3040 code #x309F) 2)
      ((<= #x30A0 code #x30FF) 2)
      ((<= #xAC00 code #xD7AF) 2)
      ((<= #xFF01 code #xFF60) 2)
      ((<= #xFFE0 code #xFFE6) 2)
      ((<= #x1F300 code #x1F9FF) 2)
      ((<= #x2600 code #x27BF) 2)
      ((<= #x0300 code #x036F) 0)
      ((<= #x20D0 code #x20FF) 0)
      ((<= #xFE00 code #xFE0F) 0)
      (t 1))))
#+END_SRC

* v0.7.1 — Markdown Rendering

~render-styled~ accepts a ~(text . plist)~ segment list from the span
parser and emits ~draw-text~ calls. The ~w~ parameter is ignored (layout
is line-at-a-time, not fixed-width); ~theme-color~ is fully qualified
as ~passepartout.channel-tui:theme-color~ since this function lives in
the ~passepartout~ package but the theme API is in ~passepartout.channel-tui~.

The inline span parser (~parse-markdown-spans~) delegates punctuation
delimiters (**bold**, `code`, *italic*) to a local ~pick~ helper.
URLs are handled directly via ~url-end~ rather than through ~pick~,
so the ~:url~ clause was removed from ~pick~'s ~case~ form to avoid
dead code.

#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(in-package :passepartout)

(defun parse-markdown-spans (text)
  "Parse inline markdown. Returns list of (text . (:bold/:underline/:code/:url ...))."
  (let ((results nil) (pos 0) (len (length text)))
    (labels ((earliest (a b) (cond ((and a (or (null b) (< a b))) a) (b b))))
      (loop
        (when (>= pos len) (return))
        (let* ((bold (search "**" text :start2 pos))
               (code (search "`" text :start2 pos))
               (italic (search "*" text :start2 pos))
               (http (search "http://" text :start2 pos))
               (https (search "https://" text :start2 pos))
               (url-s (or https http)))
          (flet ((pick (tag delim)
                   (let ((end (search delim text :start2 (+ pos (length delim)))))
              (when end
                        (push (cons (subseq text (+ pos (length delim)) end)
                                    (case tag (:bold '(:bold t))
                                         (:code '(:code t :bgcolor :dim))
                                         (:underline '(:underline t))))
                              results)
                       (setf pos (+ end (length delim)))
                       t)))
                 (url-end (start)
                   (or (position-if (lambda (c) (find c '(#\Space #\Newline #\Tab #\))))
                                    text :start start)
                       len)))
            (let ((next (earliest (earliest (earliest bold code) italic) url-s)))
              (cond ((and bold (eql bold next)) (unless (pick :bold "**") (incf pos 2)))
                    ((and code (eql code next)) (unless (pick :code "`") (incf pos)))
                    ((and italic (eql italic next)) (unless (pick :underline "*") (incf pos)))
                    ((and url-s (eql url-s next))
                     (let ((ue (url-end url-s)))
                       (push (cons (subseq text url-s ue) '(:url t)) results)
                       (setf pos ue)))
                    (t (push (cons (subseq text pos) nil) results) (return))))))))
    (nreverse results)))

(defun render-styled (fb segments y x w)
  "Render markdown segments to cl-tty backend. Returns next y."
  (declare (ignore w))
  (dolist (seg segments)
    (let* ((text (or (car seg) ""))
           (attrs (cdr seg))
           (bold (getf attrs :bold))
           (code (getf attrs :code))
           (url (getf attrs :url)))
      (declare (ignore code))
      (cl-tty.backend:draw-text fb x y text
                                (cond (url (passepartout.channel-tui:theme-color :accent))
                                      (t (passepartout.channel-tui:theme-color (or (getf attrs :role) :agent-fg))))
                               (passepartout.channel-tui:theme-color :bg)
                               :bold bold)
      (incf x (length text))))
  y)

(defun parse-markdown-blocks (text)
  "Split text at ``` code block boundaries."
  (let ((r nil) (p 0) (l (length text)))
    (loop
     (when (>= p l) (return))
     (let ((bs (search "```" text :start2 p)))
       (unless bs
         (push (cons (subseq text p) nil) r)
         (return))
       (when (> bs p)
         (push (cons (subseq text p bs) nil) r))
       (let* ((ao (+ bs 3))
              (le (or (position #\Newline text :start ao) l))
              (lang (string-trim " \r\n\t" (if (< le l) (subseq text ao le) "")))
              (cs (if (< le l) (1+ le) l))
              (cp (search "```" text :start2 cs))
              (ce (or cp l))
              (content (string-trim "\r\n" (subseq text cs ce))))
         (push (list :code-block t :lang lang :content content) r)
         (setf p (if cp (+ cp 3) l)))))
    (nreverse r)))

(defun syntax-highlight (code lang)
  "Highlight Lisp code: strings, comments, keywords, function calls."
  (declare (ignore lang))
  (let* ((r nil) (p 0) (l (length code))
         (kw '("defun" "defvar" "defparameter" "let" "let*" "lambda" "if" "when" "unless"
               "cond" "loop" "dolist" "dotimes" "progn" "prog1" "return"
               "setf" "setq" "format" "and" "or" "not" "list" "cons"
               "quote" "function" "declare" "ignore" "t" "nil")))
    (flet ((wordp (c) (or (alphanumericp c) (find c "-*+/?!_=<>"))))
      (loop
       (when (>= p l) (return))
       (let* ((ss (position #\" code :start p))
              (sc (position #\; code :start p))
              (sp (position #\( code :start p))
              (next (min (or ss l) (or sc l) (or sp l))))
         (when (> next p)
           (push (cons (subseq code p next) nil) r)
           (setf p next))
         (when (>= p l) (return))
         (cond
          ((eql p ss)
           (let ((e (or (position #\" code :start (1+ p)) l)))
             (push (cons (subseq code p (min (1+ e) l)) '(:fgcolor :string)) r)
             (setf p (min (1+ e) l))))
          ((eql p sc)
           (let ((e (or (position #\Newline code :start p) l)))
             (push (cons (subseq code p e) '(:fgcolor :comment)) r)
             (setf p e)))
          ((eql p sp)
           (push (cons "(" nil) r)
           (incf p)
           (let ((fe (loop for i from p below l for c = (char code i)
                           while (wordp c) finally (return i))))
             (when (> fe p)
               (let ((fs (subseq code p fe)))
                 (push (cons fs (list :fgcolor (if (member fs kw :test #'string=)
                                                   :keyword :function))) r)
                 (setf p fe)))))))))
    (nreverse r)))
#+END_SRC

* v0.7.2 — Gate Trace
#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(in-package :passepartout)

(defun gate-trace-lines (trace)
  "Convert gate-trace plist to display lines."
  (let ((lines nil))
    (dolist (entry trace)
      (let* ((gate (getf entry :gate))
             (result (getf entry :result))
             (reason (getf entry :reason))
             (name (or gate "unknown"))
             (color (case result
                       (:passed :tool-done)
                       (:blocked :error)
                       (:approval :accent)
                       (t :dim)))
             (prefix (case result
                       (:passed "  \u2713 ")
                       (:blocked "  \u2717 ")
                       (:approval "  \u2192 ")
                       (t "  ? ")))
             (text (format nil "~a~a~@[~a~]~@[~a~]"
                           prefix name
                           (when reason (format nil ": ~a" reason))
                           (if (eq result :approval) " (HITL required)" ""))))
        (push (cons text (list :fgcolor color)) lines)))
    (nreverse lines)))
#+END_SRC

* Test Suite
#+BEGIN_SRC lisp :tangle /home/user/.local/share/passepartout/lisp/channel-tui-view.lisp
(eval-when (:compile-toplevel :load-toplevel :execute)
  (ql:quickload :fiveam :silent t))

(defpackage :passepartout-tui-view-tests
  (:use :cl :fiveam :passepartout)
  (:export #:tui-view-suite))

(in-package :passepartout-tui-view-tests)

(def-suite tui-view-suite :description "TUI view rendering helpers")
(in-suite tui-view-suite)

(test test-char-width-ascii
  "Contract 5: ASCII characters (< 128) have width 1."
  (is (= 1 (passepartout::char-width #\a)))
  (is (= 1 (passepartout::char-width #\Space)))
  (is (= 1 (passepartout::char-width #\@))))

(test test-char-width-tab
  "Contract 5: tab character has width 8."
  (is (= 8 (passepartout::char-width #\Tab))))

(test test-char-width-cjk
  "Contract 5: CJK characters have width 2."
  (is (= 2 (passepartout::char-width #\日))))

(test test-char-width-null
  "Contract 5: null has width 0."
  (is (= 0 (passepartout::char-width #\Nul))))

(test test-markdown-bold
  "Contract 7: parse-markdown-spans detects **bold**."
  (let ((segments (passepartout::parse-markdown-spans "hello **world**!")))
    (is (= 3 (length segments)))))

(test test-markdown-plain
  "Contract 7: plain text returns single segment."
  (let ((segments (passepartout::parse-markdown-spans "plain")))
    (is (= 1 (length segments)))
    (is (string= "plain" (caar segments)))))

(test test-markdown-url
  "Contract 7: parse-markdown-spans detects URLs."
  (let ((segments (passepartout::parse-markdown-spans "see https://example.com for more")))
    (is (>= (length segments) 2))
    (is (find t segments :key (lambda (s) (getf (cdr s) :url))))))

(test test-markdown-blocks
  "Contract 8: parse-markdown-blocks detects code blocks."
  (let* ((text (format nil "before~%```lisp~%(+ 1 2)~%```~%after"))
         (segs (passepartout::parse-markdown-blocks text)))
    (is (= 3 (length segs)))
    (let ((code (second segs)))
      (is (eq t (getf code :code-block)))
      (is (string= "lisp" (getf code :lang)))
      (is (string= "(+ 1 2)" (string-trim '(#\Space #\Newline) (getf code :content)))))))

(test test-markdown-blocks-no-close
  "Contract 8: unclosed code block returns content."
  (let* ((text (format nil "```~%unclosed code"))
         (segs (passepartout::parse-markdown-blocks text)))
    (is (= 1 (length segs)))
    (is (eq t (getf (first segs) :code-block)))))

(test test-syntax-highlight
  "Contract 9: syntax-highlight colors Lisp code."
  (let ((segs (passepartout::syntax-highlight "(defun foo (x) (+ x 1))" "lisp")))
    (is (>= (length segs) 3))))

(test test-syntax-highlight-keyword
  "Contract 9: syntax-highlight colors keywords."
  (let ((segs (passepartout::syntax-highlight "(let ((x 1)) (+ x 2))" "lisp")))
    (is (>= (length segs) 2))
    (is (find :keyword segs :key (lambda (s) (getf (cdr s) :fgcolor))))))

(test test-syntax-highlight-function
  "Contract 9: syntax-highlight colors function calls."
  (let ((segs (passepartout::syntax-highlight "(+ 1 2)" "lisp")))
    (is (>= (length segs) 2))
    (is (find :function segs :key (lambda (s) (getf (cdr s) :fgcolor))))))

(test test-gate-trace-lines-passed
  "Contract 9: gate-trace-lines for passed gate."
  (let ((lines (passepartout::gate-trace-lines
                '((:gate "path" :result :passed)))))
    (is (= 1 (length lines)))
    (is (eq :tool-done (getf (cdar lines) :fgcolor)))))

(test test-gate-trace-lines-blocked
  "Contract 9: gate-trace-lines for blocked gate."
  (let ((lines (passepartout::gate-trace-lines
                '((:gate "shell" :result :blocked :reason "rm")))))
    (is (= 1 (length lines)))
    (is (search "rm" (caar lines)))))

(test test-gate-trace-lines-approval
  "Contract 9: gate-trace-lines for approval gate."
  (let ((lines (passepartout::gate-trace-lines
                '((:gate "network" :result :approval)))))
    (is (= 1 (length lines)))
    (is (search "HITL" (caar lines)))))

(test test-init-state-has-collapsed-gates
  "Contract v0.7.2: init-state includes :collapsed-gates field."
  (passepartout.channel-tui::init-state)
  (let ((cg (passepartout.channel-tui::st :collapsed-gates)))
    (is (null cg))))

(test test-sidebar-state
  "Contract v0.8.0: init-state includes :sidebar-mode (:auto) and :sidebar-width (42)."
  (passepartout.channel-tui::init-state)
  (is (eq :auto (passepartout.channel-tui::st :sidebar-mode)))
  (is (= 42 (passepartout.channel-tui::st :sidebar-width))))

(defun sidebar-visible-p (w)
  "Compute whether sidebar should be shown given terminal width W
and current sidebar mode."
  (let ((mode (passepartout.channel-tui::st :sidebar-mode)))
    (or (eq mode :visible)
        (and (eq mode :auto) (> w 120)))))

(test test-sidebar-auto-wide
  "Contract v0.8.0: sidebar auto-shows when terminal > 120 cols."
  (passepartout.channel-tui::init-state)
  (setf (passepartout.channel-tui::st :sidebar-mode) :auto)
  (is (sidebar-visible-p 140))
  (is (not (sidebar-visible-p 100))))

(test test-sidebar-visible-mode
  "Contract v0.8.0: :visible mode shows sidebar regardless of width."
  (passepartout.channel-tui::init-state)
  (setf (passepartout.channel-tui::st :sidebar-mode) :visible)
  (is (sidebar-visible-p 40))
  (is (sidebar-visible-p 140)))

(test test-sidebar-hidden-mode
  "Contract v0.8.0: :hidden mode hides sidebar regardless of width."
  (passepartout.channel-tui::init-state)
  (setf (passepartout.channel-tui::st :sidebar-mode) :hidden)
  (is (not (sidebar-visible-p 140)))
  (is (not (sidebar-visible-p 40))))

(test test-status-bar-tokens
  "v0.9.0: status bar uses :status-fg and :status-bg theme tokens."
  (is (getf passepartout.channel-tui::*tui-theme* :status-fg))
  (is (getf passepartout.channel-tui::*tui-theme* :status-bg)))

(test test-new-theme-keys
  "v0.10.0: theme has all zone keys."
  (is (getf passepartout.channel-tui::*tui-theme* :bg))
  (is (getf passepartout.channel-tui::*tui-theme* :bg-panel))
  (is (getf passepartout.channel-tui::*tui-theme* :bg-element))
  (is (getf passepartout.channel-tui::*tui-theme* :bg-input))
  (is (getf passepartout.channel-tui::*tui-theme* :agent-border))
  (is (getf passepartout.channel-tui::*tui-theme* :thinking-bg))
  (is (getf passepartout.channel-tui::*tui-theme* :symbolic-border))
  (is (getf passepartout.channel-tui::*tui-theme* :text-muted)))
#+END_SRC