ui: center chat content + wrap to chamber width

Two parts working together:

## Wrap chat messages to chamber width

Markdown rendering for assistant messages and the live token
stream used `renderer.line_width()` (the full content band), so
long replies spilled across the entire terminal even when the
tool chambers below them were capped at 120 cols. Result: chat
text was visually a different width from chambers — the eye saw
two parallel layouts.

Both render paths now wrap to `renderer.content_width()` minus the
8-col chat handle prefix (`<dirge> ` + space), so wrapped lines
sit beneath the handle and the right edge matches chamber width.

## Center the chat band

The whole chat content area (chamber tops/bottoms, chat lines,
banner, prompt input row, status row, cursor) now indents by
`content_indent()` columns to center within the visible chat band.

On a 160-col terminal with the panel visible:
- band width = 160 - 33 (panel) - 1 (divider gutter) = 126 cols
- target content width = min(126, 120) = 120 cols
- indent = (126 - 120) / 2 = 3 cols

So the chat sits in a 120-col column with ~3 cols of margin each
side, regardless of how wide the terminal is. On a 100-col
terminal the indent is 0 — the chat uses the full band.

Two new helpers on `Renderer`:
- `content_width() -> usize` — cap at 120 cols.
- `content_indent() -> usize` — left padding to center within the
  band.

`render_viewport` applies the indent at paint time so the buffer
itself stays raw (no rewrites needed when terminal width changes).
The bottom rows (input + status + cursor) match.

## Test plan

- [x] `cargo test --features plugin` -> 599 pass, 0 fail.
- [x] Both build profiles -> 0 warnings.
- [ ] Eyeball: on a wide terminal, verify chat + chambers share
      the same 120-col column and both visibly center under the
      chat band; verify cursor lands where text is being typed;
      verify status line + prompt align with chat above.

Author: Yogthos

src/ui/events.rs

@@ -81,7 +81,13 @@ pub fn render_session(
         let cont_indent = " ".repeat(handle.chars().count());
 
         if msg.role == MessageRole::Assistant {
-            let max_width = renderer.line_width();
+            // Wrap chat to the same width tool chambers use so chat
+            // and chamber blocks line up visually. The 8-col handle
+            // prefix is subtracted so wrapped continuation text fits
+            // beneath the handle position.
+            let max_width = renderer
+                .content_width()
+                .saturating_sub(handle.chars().count() + 1);
             let mut styled = markdown::markdown_to_styled(&msg.content, max_width);
             for (i, entry) in styled.iter_mut().enumerate() {
                 if i == 0 {

src/ui/mod.rs

@@ -1412,7 +1412,7 @@ pub async fn run_interactive(
                             continue;
                         }
 
-                        let max_width = renderer.line_width();
+                        let max_width = renderer.content_width().saturating_sub(9); // 8-col handle + space
                         let mut styled =
                             crate::ui::markdown::markdown_to_styled(&response_buf, max_width);
 
@@ -1603,7 +1603,7 @@ pub async fn run_interactive(
                         }
 
                         if !response_buf.is_empty() {
-                            let max_width = renderer.line_width();
+                            let max_width = renderer.content_width().saturating_sub(9); // 8-col handle + space
                             let mut styled = crate::ui::markdown::markdown_to_styled(
                                 &response_buf,
                                 max_width,
@@ -1812,7 +1812,7 @@ pub async fn run_interactive(
                         // the conversation history reflects what the user saw,
                         // not a phantom turn that "never happened".
                         if !response_buf.is_empty() {
-                            let max_width = renderer.line_width();
+                            let max_width = renderer.content_width().saturating_sub(9); // 8-col handle + space
                             let mut styled = crate::ui::markdown::markdown_to_styled(
                                 &response_buf,
                                 max_width,

src/ui/renderer.rs

@@ -157,6 +157,22 @@ impl Renderer {
         self.max_line_width()
     }
 
+    /// Target width for chat content. Caps at 120 cols so wide
+    /// terminals don't stretch chambers + chat lines into sprawling
+    /// rivers of text. Matches the cap used by tool chambers.
+    pub fn content_width(&self) -> usize {
+        self.line_width().min(120)
+    }
+
+    /// Left padding in columns to horizontally center the chat
+    /// content area (`content_width`) within the visible chat band
+    /// (`line_width`). Zero when content already fills the band.
+    pub fn content_indent(&self) -> usize {
+        let band = self.line_width();
+        let target = self.content_width();
+        band.saturating_sub(target) / 2
+    }
+
     pub fn buffer_len(&self) -> usize {
         self.buffer.len()
     }
@@ -373,12 +389,23 @@ impl Renderer {
         // `content_cols`). All chat text is clipped here; the remaining
         // columns belong to the divider + panel.
         let content_band = content_cols.saturating_sub(1) as usize;
+        // Left indent in columns to horizontally center chat content
+        // inside the band. We then clip the per-line text to
+        // `content_band - indent` so wide content can't spill into
+        // the divider/panel.
+        let indent = self.content_indent();
+        let line_cap = content_band.saturating_sub(indent);
         for i in 0..visible {
             stdout.execute(MoveTo(0, i as u16))?;
+            // Paint indent spaces (no color) so any stale text on the
+            // left edge from a wider previous line gets wiped.
+            if indent > 0 {
+                write!(stdout, "{}", " ".repeat(indent))?;
+            }
             let text_chars: usize = if start + i < end {
                 let entry = &self.buffer[start + i];
                 let line_idx = start + i;
-                let text: String = entry.text.chars().take(content_band).collect();
+                let text: String = entry.text.chars().take(line_cap).collect();
                 let actual_chars = text.chars().count();
 
                 let is_selected = self.selection_active
@@ -420,9 +447,12 @@ impl Renderer {
                 0
             };
             if self.panel_visible() {
-                // Manually pad to the content band; ClearType::UntilNewLine
-                // would wipe the panel area to our right.
-                let pad = content_band.saturating_sub(text_chars);
+                // Pad to fill the content band so stale chars from
+                // wider previous lines get wiped. With centering,
+                // the written length per row is `indent + text_chars`;
+                // the trailing pad fills `content_band - (indent + text)`.
+                let written = indent + text_chars;
+                let pad = content_band.saturating_sub(written);
                 if pad > 0 {
                     write!(stdout, "{}", " ".repeat(pad))?;
                 }
@@ -728,12 +758,16 @@ impl Renderer {
         let display_chars: Vec<Vec<char>> =
             display_lines.iter().map(|s| s.chars().collect()).collect();
 
+        // Input rows + status row also center under the chat band so
+        // the prompt + status visually align with the chat content
+        // above.
+        let bottom_indent = self.content_indent();
         for row_offset in 0..visible_input_rows {
             let row = input_top + row_offset as u16;
             let vr_idx = first_visible_visual + row_offset;
             stdout.execute(MoveTo(0, row))?;
             write!(stdout, "{}", " ".repeat(cols as usize))?;
-            stdout.execute(MoveTo(0, row))?;
+            stdout.execute(MoveTo(bottom_indent as u16, row))?;
             write!(
                 stdout,
                 "{}",
@@ -763,10 +797,10 @@ impl Renderer {
             write!(stdout, "{}", ResetColor)?;
         }
 
-        // Status row.
+        // Status row — also centered under the chat band.
         stdout.execute(MoveTo(0, status_row))?;
         write!(stdout, "{}", " ".repeat(cols as usize))?;
-        stdout.execute(MoveTo(0, status_row))?;
+        stdout.execute(MoveTo(bottom_indent as u16, status_row))?;
         write!(
             stdout,
             "{}",
@@ -803,7 +837,10 @@ impl Renderer {
         let cursor_row =
             input_top + (cursor_visual_row.saturating_sub(first_visible_visual)) as u16;
         // Match the 3-column prompt prefix used in the loop above.
-        let cursor_x = (3 + cursor_visual_col).min(cols.saturating_sub(1) as usize) as u16;
+        // Match the indented prompt (`bottom_indent + 3-col prompt
+        // prefix` + cursor offset within content).
+        let cursor_x =
+            (bottom_indent + 3 + cursor_visual_col).min(cols.saturating_sub(1) as usize) as u16;
         stdout.execute(MoveTo(cursor_x, cursor_row))?;
 
         if self.panel_visible() {