diff --git a/org/channel-tui-view.org b/org/channel-tui-view.org
index 263a3f6..1b0cd36 100644
--- a/org/channel-tui-view.org
+++ b/org/channel-tui-view.org
@@ -51,19 +51,6 @@ and current sidebar mode (:auto/:visible/:hidden)."
     (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.
@@ -76,7 +63,7 @@ Returns a list of strings, one per line."
          (inner-w (- chat-w (* 2 hpad)))
          (prompt-w (- inner-w 2))
          (text (input-string))
-         (lines (word-wrap text prompt-w))
+         (lines (cl-tty.box:word-wrap text prompt-w))
          (n-lines (max 1 (length lines)))
          (panel-rows (max 4 (+ n-lines 2))))
     (- h 4 panel-rows -1)))
@@ -219,7 +206,7 @@ Returns a list of strings, one per line."
          (prompt-w (- inner-w 2))
          (text (input-string))
          (pos (or (st :cursor-pos) 0))
-         (lines (word-wrap text prompt-w))
+         (lines (cl-tty.box: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))
@@ -380,168 +367,6 @@ Returns a list of strings, one per line."
     (finish-output (cl-tty.backend::backend-output-stream fb))))
 #+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)
@@ -586,75 +411,6 @@ dead code.
 (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