From fae7ed3fd0a6ec7c2e55f2bcf419c282df468e8a Mon Sep 17 00:00:00 2001
From: Levi Neuwirth <ln@levineuwirth.org>
Date: Mon, 6 Jul 2026 13:38:38 -0400
Subject: [PATCH 1/4] feat(tui): line-number gutter (UX arc sub-arc 1, TUI
 half)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Introduce a reserved left gutter column with absolute line numbers in the
TUI/grid frontend — the foundational piece of the UX arc (docs/ux-arc-
framing.md). Default OFF (Emacs tradition), so zero layout/coordinate
change until a window opts in.

- window.rs: LineNumberMode { Off, Absolute } + per-window `line_numbers`
  field + `gutter_width()` (digits(line_count) + PAD) + `decimal_digits`.
- editor.rs: the gutter is one viewport shift at the paint site
  (cell_origin.col += gutter_w, cell_size.cols -= gutter_w) — every
  viewport-relative painter (text, syntax, diag underline, search) stays
  gutter-agnostic. The sites that read rect.origin.col directly get a
  manual +gutter_w: cursor placement, local selection, mouse hit-test
  (a gutter click maps to line start, Q#UX6). paint_line_number_gutter
  writes right-aligned dim digits alloc-free.
- overlay_paint.rs: remote-presence cursor/selection shift by gutter_w.
- Lua: pmacs.window.set_line_numbers/line_numbers +
  window.toggle-line-numbers command.

No protocol/daemon change (frontend-local, Q#UX1). Tests: gutter render
(right-aligned digits + past-EOF blanks) + decimal_digits.

Validated: fmt clean; clippy --lib clean both flavors; 1439 lib tests pass
both flavors. Needs a human eyeball (coordinate-math change) before the PR.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014TXbAwk27agwhrNNrhLi2U
---
 builtin/commands/default.lua |   6 ++
 src/editor.rs                | 148 +++++++++++++++++++++++++++++++++--
 src/lua_bindings/mod.rs      |  38 +++++++++
 src/overlay_paint.rs         |  23 ++++--
 src/window.rs                |  61 +++++++++++++++
 5 files changed, 263 insertions(+), 13 deletions(-)

diff --git a/builtin/commands/default.lua b/builtin/commands/default.lua
index b220a74..eb0fb3a 100644
--- a/builtin/commands/default.lua
+++ b/builtin/commands/default.lua
@@ -219,6 +219,12 @@ cmd { name = "window.split-horizontal",
 cmd { name = "window.split-vertical",
       description = "Split the active window vertically (children sit side-by-side).",
       fn = function() pmacs.window.split_vertical() end }
+cmd { name = "window.toggle-line-numbers",
+      description = "Toggle the active window's line-number gutter (off / absolute).",
+      fn = function()
+        local cur = pmacs.window.line_numbers()
+        pmacs.window.set_line_numbers(cur == "off" and "absolute" or "off")
+      end }
 cmd { name = "window.focus-next",
       description = "Move focus to the next window in iteration order.",
       fn = function() pmacs.window.focus_next() end }
diff --git a/src/editor.rs b/src/editor.rs
index 95bd64d..41108c9 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -882,7 +882,20 @@ impl EditorState {
         };
         let inner_rows = rect.size.rows.saturating_sub(1);
         let local_row = cell_row.saturating_sub(rect.origin.row);
-        let local_col = cell_col.saturating_sub(rect.origin.col);
+        // UX gutter (Q#UX6): subtract the reserved gutter width so the
+        // hit-test lands on the right text byte. A click inside the gutter
+        // strip (raw < gutter_w) saturates to column 0 → the start of that
+        // line, a mild, useful affordance for the MVP.
+        let gutter_w = {
+            let core = self.core.borrow();
+            core.windows.get(&win_id).map_or(0, |w| {
+                let g = w.gutter_width();
+                if g >= rect.size.cols { 0 } else { g }
+            })
+        };
+        let local_col = cell_col
+            .saturating_sub(rect.origin.col)
+            .saturating_sub(gutter_w);
 
         match ev.kind {
             MouseEventKind::Down(MouseButton::Left) => {
@@ -1608,11 +1621,20 @@ pub fn paint_frame(
             continue;
         };
         let viewport_buffer_start = window.text_view.line_offset(window.view_top).unwrap_or(0);
+        // UX gutter (Q#UX2): reserve a left strip for line numbers and
+        // shrink+shift the text area into the remainder, so every
+        // viewport-relative painter (text, syntax, diagnostics, search)
+        // stays gutter-agnostic. A window too narrow for the gutter falls
+        // back to no gutter this frame rather than starving the text.
+        let gutter_w = {
+            let w = window.gutter_width();
+            if w >= rect.size.cols { 0 } else { w }
+        };
         let viewport = Viewport {
             buffer_start: viewport_buffer_start,
             buffer_end: buf.len(),
-            cell_origin: rect.origin,
-            cell_size: crate::cell::CellSize::new(inner_rows, rect.size.cols),
+            cell_origin: CellCoord::new(rect.origin.row, rect.origin.col + gutter_w),
+            cell_size: crate::cell::CellSize::new(inner_rows, rect.size.cols - gutter_w),
         };
         // Composition (T M2.9): base text_view paints first, then
         // each overlay in attach order. See [`crate::view::View`].
@@ -1620,7 +1642,10 @@ pub fn paint_frame(
         for overlay in &mut window.overlays {
             overlay.render(buf, viewport, grid);
         }
-        paint_local_selection(grid, buf, window, &rect, inner_rows);
+        if gutter_w > 0 {
+            paint_line_number_gutter(grid, window, &rect, inner_rows, gutter_w);
+        }
+        paint_local_selection(grid, buf, window, &rect, inner_rows, gutter_w);
         // Mode line for this window. Painted last so the line
         // itself is always visible regardless of overlay activity.
         let coord = window
@@ -1685,9 +1710,15 @@ pub fn paint_frame(
     {
         return None;
     }
+    // UX gutter: the terminal caret sits in the text area, past the
+    // reserved gutter strip (mirrors the viewport shift above).
+    let gutter_w = {
+        let w = aw.gutter_width();
+        if w >= active_rect.size.cols { 0 } else { w }
+    };
     let grid_row = active_rect.origin.row + (disp.row - aw.view_top as u32);
     let max_col = active_rect.origin.col + active_rect.size.cols.saturating_sub(1);
-    let grid_col = (active_rect.origin.col + disp.col).min(max_col);
+    let grid_col = (active_rect.origin.col + gutter_w + disp.col).min(max_col);
     Some(CellCoord::new(grid_row, grid_col))
 }
 
@@ -1745,12 +1776,69 @@ fn inner_rows(rect: &crate::window::Rect) -> u32 {
     rect.size.rows.saturating_sub(1)
 }
 
+/// Paint the left line-number gutter for `window` into the reserved strip
+/// `[rect.origin.col, rect.origin.col + gutter_w)` over the window's text
+/// rows (UX gutter arc). Numbers are 1-based, right-aligned with a single
+/// trailing pad cell; rows past end-of-buffer stay blank. Dimly styled so
+/// the gutter recedes behind the code. The caller guarantees `gutter_w >
+/// 0` and that it fits within `rect.size.cols`.
+fn paint_line_number_gutter(
+    grid: &mut crate::cell::CellGrid<'_>,
+    window: &crate::window::Window,
+    rect: &crate::window::Rect,
+    inner_rows: u32,
+    gutter_w: u32,
+) {
+    let line_count = window.text_view.line_count();
+    let style = crate::cell::Style {
+        fg: crate::cell::Color::Indexed(8),
+        ..crate::cell::Style::default()
+    };
+    // The number's rightmost digit sits at `field - 1`; the last gutter
+    // cell (`gutter_w - 1`) is a trailing pad separating it from the code.
+    let field = gutter_w.saturating_sub(1);
+    for r in 0..inner_rows {
+        let grid_row = rect.origin.row + r;
+        // Blank + style the whole strip first, so a number that shrank a
+        // digit (e.g. after a large delete) leaves no stale trailing glyph.
+        for c in 0..gutter_w {
+            let cell = grid.at(CellCoord::new(grid_row, rect.origin.col + c));
+            cell.glyph = crate::cell::Glyph::Char(' ');
+            cell.style = style;
+            cell.attachment = None;
+        }
+        let buffer_line = window.view_top + r as usize;
+        if buffer_line >= line_count {
+            continue; // past end-of-buffer: blank gutter
+        }
+        // Write the 1-based number right-aligned, rightmost digit first,
+        // alloc-free. `field >= digits(line_count)` by construction, so
+        // the leftmost digit always leaves at least a leading pad cell.
+        let mut val = buffer_line + 1;
+        let mut col = field;
+        loop {
+            col -= 1;
+            let digit = (val % 10) as u8;
+            grid.at(CellCoord::new(grid_row, rect.origin.col + col))
+                .glyph = crate::cell::Glyph::Char((b'0' + digit) as char);
+            val /= 10;
+            if val == 0 || col == 0 {
+                break;
+            }
+        }
+    }
+}
+
 fn paint_local_selection(
     grid: &mut crate::cell::CellGrid<'_>,
     buf: &crate::buffer::Buffer,
     window: &crate::window::Window,
     rect: &crate::window::Rect,
     inner_rows: u32,
+    // UX gutter: the reserved left-strip width; selection cells are the
+    // text-relative display column shifted right by this (Q#UX2). 0 when
+    // the gutter is off, so this is a no-op then.
+    gutter_w: u32,
 ) {
     let Some((sel_start, sel_end)) = window.region() else {
         return;
@@ -1758,6 +1846,7 @@ fn paint_local_selection(
     if inner_rows == 0 || rect.size.cols == 0 || sel_start >= sel_end {
         return;
     }
+    let text_cols = rect.size.cols.saturating_sub(gutter_w);
 
     let first_row = window.view_top;
     let last_row = first_row.saturating_add(inner_rows as usize);
@@ -1786,15 +1875,15 @@ fn paint_local_selection(
         }
 
         let row_offset = display_row.saturating_sub(first_row) as u32;
-        let start_col = start_coord.col.min(rect.size.cols);
-        let end_col = end_coord.col.min(rect.size.cols);
+        let start_col = start_coord.col.min(text_cols);
+        let end_col = end_coord.col.min(text_cols);
         if start_col >= end_col {
             continue;
         }
         for col in start_col..end_col {
             let cell = grid.at(CellCoord::new(
                 rect.origin.row + row_offset,
-                rect.origin.col + col,
+                rect.origin.col + gutter_w + col,
             ));
             cell.style.reverse = true;
         }
@@ -2196,6 +2285,49 @@ mod tests {
     use super::*;
     use crate::frontend::KeyEventKind;
 
+    #[test]
+    fn line_number_gutter_renders_right_aligned_digits() {
+        use crate::buffer::{Buffer, BufferId};
+        use crate::cell::{Cell, CellGrid, CellSize, Glyph};
+        use crate::text_view::TextView;
+        use crate::window::{LineNumberMode, Window, WindowId};
+
+        // 12 lines → decimal_digits(12) = 2, gutter_w = 2 + PAD(2) = 4.
+        let content = b"a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl\n";
+        let bid = BufferId::next();
+        let buf = Buffer::from_bytes(bid, "test", content);
+        let view = TextView::new(&buf);
+        let mut window = Window::new(WindowId::next(), bid, view);
+        window.line_numbers = LineNumberMode::Absolute;
+        assert_eq!(window.gutter_width(), 4, "2-digit line count + 2 pad");
+
+        let (rows, cols) = (12u32, 20u32);
+        let mut storage = vec![Cell::default(); (rows * cols) as usize];
+        let mut grid = CellGrid {
+            cells: &mut storage,
+            stride: cols,
+            size: CellSize::new(rows, cols),
+        };
+        let rect = Rect::new(0, 0, rows, cols);
+        paint_line_number_gutter(&mut grid, &window, &rect, rows, 4);
+
+        let glyph = |r: u32, c: u32| storage[(r * cols + c) as usize].glyph.clone();
+        // Row 0 = line 1: "  1 " (digit right-aligned at col 2, col 3 = pad).
+        assert_eq!(glyph(0, 0), Glyph::Char(' '));
+        assert_eq!(glyph(0, 1), Glyph::Char(' '));
+        assert_eq!(glyph(0, 2), Glyph::Char('1'));
+        assert_eq!(glyph(0, 3), Glyph::Char(' '));
+        // Row 4 = line 5.
+        assert_eq!(glyph(4, 2), Glyph::Char('5'));
+        // Row 9 = line 10: two digits → col1='1', col2='0', col3 pad.
+        assert_eq!(glyph(9, 1), Glyph::Char('1'));
+        assert_eq!(glyph(9, 2), Glyph::Char('0'));
+        assert_eq!(glyph(9, 3), Glyph::Char(' '));
+        // Row 11 = line 12.
+        assert_eq!(glyph(11, 1), Glyph::Char('1'));
+        assert_eq!(glyph(11, 2), Glyph::Char('2'));
+    }
+
     fn fresh_with(content: &[u8]) -> EditorState {
         let s = EditorState::new();
         let new_id = s
diff --git a/src/lua_bindings/mod.rs b/src/lua_bindings/mod.rs
index 5a171d6..434f632 100644
--- a/src/lua_bindings/mod.rs
+++ b/src/lua_bindings/mod.rs
@@ -10093,6 +10093,44 @@ fn install_window_module(lua: &Lua, core: &SharedCore) -> mlua::Result<Table> {
         )?;
     }
 
+    {
+        // UX gutter: set the active window's line-number mode
+        // ("off" | "absolute"). Per-window (Q#UX5); a friendly toggle
+        // command wraps this in `builtin/`.
+        let cc = core.clone();
+        win.set(
+            "set_line_numbers",
+            lua.create_function(move |_, mode: String| {
+                let m = match mode.as_str() {
+                    "off" | "none" => crate::window::LineNumberMode::Off,
+                    "absolute" | "abs" | "on" => crate::window::LineNumberMode::Absolute,
+                    other => {
+                        return Err(mlua::Error::external(format!(
+                            "unknown line-number mode {other:?} (expected off|absolute)"
+                        )));
+                    }
+                };
+                cc.borrow_mut().active_window_mut().line_numbers = m;
+                Ok(())
+            })?,
+        )?;
+    }
+
+    {
+        // Read the active window's line-number mode as a string.
+        let cc = core.clone();
+        win.set(
+            "line_numbers",
+            lua.create_function(move |_, ()| {
+                let mode = match cc.borrow().active_window().line_numbers {
+                    crate::window::LineNumberMode::Off => "off",
+                    crate::window::LineNumberMode::Absolute => "absolute",
+                };
+                Ok(mode)
+            })?,
+        )?;
+    }
+
     {
         let cc = core.clone();
         win.set(
diff --git a/src/overlay_paint.rs b/src/overlay_paint.rs
index 72ed9b4..af0ee7f 100644
--- a/src/overlay_paint.rs
+++ b/src/overlay_paint.rs
@@ -135,6 +135,15 @@ pub fn paint_other_frontend_overlays(
             let Ok(buf) = reg.get(window.buffer_id) else {
                 continue;
             };
+            // UX gutter: this window may reserve a left strip for line
+            // numbers; a remote cursor/selection is a text-relative column
+            // shifted right by that width (0 when the gutter is off). This
+            // pass runs after `paint_frame`, so it learns the width here.
+            let gutter_w = {
+                let g = window.gutter_width();
+                if g >= rect.size.cols { 0 } else { g }
+            };
+            let text_cols = rect.size.cols.saturating_sub(gutter_w);
             // Source's byte position → display coords via THIS
             // recipient window's text_view (the recipient's view
             // of the buffer).
@@ -154,11 +163,11 @@ pub fn paint_other_frontend_overlays(
             // Column bounds: disp.col is the buffer column; window
             // doesn't horizontally scroll in v1.0, so cells past
             // rect.size.cols are simply off-grid for this window.
-            if disp.col >= rect.size.cols {
+            if disp.col >= text_cols {
                 continue;
             }
             let cursor_grid_row = rect.origin.row + row_in_window as u32;
-            let cursor_grid_col = rect.origin.col + disp.col;
+            let cursor_grid_col = rect.origin.col + gutter_w + disp.col;
             paint_cursor_cell(grid, cursor_grid_row, cursor_grid_col, color);
             if let Some(label_ch) = label {
                 paint_label_cell(grid, cursor_grid_row, cursor_grid_col, label_ch, color);
@@ -171,7 +180,9 @@ pub fn paint_other_frontend_overlays(
                 } else {
                     (sel.active, sel.anchor)
                 };
-                paint_selection_in_window(grid, buf, window, rect, inner_rows, lo, hi, color);
+                paint_selection_in_window(
+                    grid, buf, window, rect, inner_rows, gutter_w, lo, hi, color,
+                );
             }
         }
     }
@@ -223,6 +234,7 @@ fn paint_selection_in_window(
     window: &crate::window::Window,
     rect: Rect,
     inner_rows: u32,
+    gutter_w: u32,
     lo: crate::rope::Position,
     hi: crate::rope::Position,
     color: Color,
@@ -230,6 +242,7 @@ fn paint_selection_in_window(
     if lo >= hi {
         return;
     }
+    let text_cols = rect.size.cols.saturating_sub(gutter_w);
     // Walk byte positions from lo to hi, mapping each to a
     // display coord. Step in single-byte increments; pos_to_display
     // tolerates byte-boundary positions and returns None for
@@ -249,9 +262,9 @@ fn paint_selection_in_window(
             break;
         };
         match (disp.row as usize).checked_sub(window.view_top) {
-            Some(r) if r < inner_rows as usize && disp.col < rect.size.cols => {
+            Some(r) if r < inner_rows as usize && disp.col < text_cols => {
                 let grid_row = rect.origin.row + r as u32;
-                let grid_col = rect.origin.col + disp.col;
+                let grid_col = rect.origin.col + gutter_w + disp.col;
                 if grid_row < grid.size.rows && grid_col < grid.size.cols {
                     let cell = grid.at(CellCoord::new(grid_row, grid_col));
                     cell.style.underline = UnderlineStyle::Single;
diff --git a/src/window.rs b/src/window.rs
index a5ed06a..9988622 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -129,6 +129,36 @@ pub struct Selection {
     pub anchor: Position,
 }
 
+/// Line-number display mode for a window's left gutter (UX gutter arc).
+/// `Off` reserves no gutter at all — text starts at column 0, and every
+/// coordinate is unchanged (the default, matching the Emacs tradition).
+/// Additional modes (relative, hybrid) arrive in a later sub-arc.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+pub enum LineNumberMode {
+    /// No gutter; zero layout change.
+    #[default]
+    Off,
+    /// Absolute 1-based line numbers, right-aligned in the gutter.
+    Absolute,
+}
+
+/// Cells of horizontal padding the line-number gutter adds around the
+/// digit field: a leading and a trailing blank, so `gutter_w = digits +
+/// PAD` (Q#UX3). Kept as a named constant so both frontends can share the
+/// convention (Q#UX7). `u32` to match the cell-grid column type.
+pub const LINE_NUMBER_GUTTER_PAD: u32 = 2;
+
+/// Number of decimal digits in `n` (for `n >= 1`). Allocation-free.
+#[must_use]
+pub fn decimal_digits(mut n: usize) -> u32 {
+    let mut d = 1u32;
+    while n >= 10 {
+        n /= 10;
+        d += 1;
+    }
+    d
+}
+
 /// One leaf of the window tree: a buffer plus per-window state.
 pub struct Window {
     /// Unique identifier.
@@ -158,6 +188,9 @@ pub struct Window {
     /// render. Updated by the renderer; consumed by `cursor.page-down`
     /// / `cursor.page-up`. `0` until the first render lands.
     pub last_visible_rows: u32,
+    /// Line-number gutter mode for this window (UX gutter arc). `Off` by
+    /// default → no gutter, no coordinate change.
+    pub line_numbers: LineNumberMode,
 }
 
 impl Window {
@@ -175,6 +208,22 @@ impl Window {
             view_top: 0,
             goal_col: None,
             last_visible_rows: 0,
+            line_numbers: LineNumberMode::Off,
+        }
+    }
+
+    /// Width in cells this window's line-number gutter occupies, or `0`
+    /// when disabled (UX gutter arc, Q#UX3). `digits(line_count) + PAD`;
+    /// the renderer caps this against the window width and applies it as a
+    /// left offset to the text area. Every gutter coordinate-math site
+    /// reads this one function so the width stays consistent.
+    #[must_use]
+    pub fn gutter_width(&self) -> u32 {
+        match self.line_numbers {
+            LineNumberMode::Off => 0,
+            LineNumberMode::Absolute => {
+                decimal_digits(self.text_view.line_count().max(1)) + LINE_NUMBER_GUTTER_PAD
+            }
         }
     }
 
@@ -465,6 +514,18 @@ fn collapse_single_child_splits(node: &mut LayoutNode) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn decimal_digits_counts_correctly() {
+        assert_eq!(decimal_digits(1), 1);
+        assert_eq!(decimal_digits(9), 1);
+        assert_eq!(decimal_digits(10), 2);
+        assert_eq!(decimal_digits(99), 2);
+        assert_eq!(decimal_digits(100), 3);
+        assert_eq!(decimal_digits(1000), 4);
+        // A 6-digit file → 6 digits + PAD gutter.
+        assert_eq!(decimal_digits(123_456), 6);
+    }
+
     fn id() -> WindowId {
         WindowId::next()
     }

From f7583e7994f17368ece42b8a29b4b579571b71a3 Mon Sep 17 00:00:00 2001
From: Levi Neuwirth <ln@levineuwirth.org>
Date: Mon, 6 Jul 2026 13:59:43 -0400
Subject: [PATCH 2/4] feat(gpu): line-number gutter (UX arc sub-arc 1, GPU
 half)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Mirror the TUI line-number gutter in the pmacs-gpu frontend — the GPU half
of sub-arc 1. Frontend-local, no protocol change (Q#UX1); off by default,
enabled with `--line-numbers`.

The gutter is a reserved left strip mirroring the minimap's reserved right
column. All horizontal text geometry hangs off `TEXT_LEFT`; the gutter adds
`gutter_width_px()` to it via `text_left()`, applied at every byte→pixel x
site (main TextArea, caret, washes/squiggles) and subtracted at the one
pixel→byte site (mouse hit-test). The main text clip-left moves off 0.

- gutter_width_px = digits(line_count) * mono_advance + gap (px), advance
  read from the shaped code buffer.
- A dedicated gutter_text_renderer + gutter_buffer draw right-aligned dim
  numbers, reshaped per scroll (refresh_gutter_buffer), same font size +
  line height as the code so rows align one-for-one.
- --line-numbers flag filtered out before the mode parser (position-
  independent), threaded App → State.

Headless render test asserts enabling the gutter changes the frame (ink +
shift). fmt + clippy clean; 53 pmacs-gpu tests pass (render tests on the
local adapter). Needs a human eyeball before the PR.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014TXbAwk27agwhrNNrhLi2U
---
 pmacs-gpu/src/main.rs | 212 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 203 insertions(+), 9 deletions(-)

diff --git a/pmacs-gpu/src/main.rs b/pmacs-gpu/src/main.rs
index 076a9d8..b8e7961 100644
--- a/pmacs-gpu/src/main.rs
+++ b/pmacs-gpu/src/main.rs
@@ -87,6 +87,15 @@ const MINIMAP_CODE_COLS: f32 = 100.0;
 const MINIMAP_MIN_STROKE_WIDTH: f32 = 1.5;
 const MINIMAP_MAX_LINE_STROKE_HEIGHT: f32 = 2.0;
 const CODE_LINE_HEIGHT: f32 = 22.0;
+/// Font size of the code buffer (and the line-number gutter, so their
+/// line heights match and rows align).
+const CODE_FONT_SIZE: f32 = 16.0;
+/// Gap in px between the line-number gutter digits and the code
+/// (UX gutter arc, GPU side of sub-arc 1 — mirrors the TUI gutter).
+const GUTTER_GAP_PX: f32 = 10.0;
+/// Fallback monospace advance in px when no shaped glyph is available to
+/// measure (0.6 em at the 16px code font).
+const GUTTER_MONO_ADVANCE_FALLBACK: f32 = 9.6;
 const MINIMAP_BG: [f32; 4] = [0.075, 0.075, 0.105, 0.92];
 const MINIMAP_DEFAULT_LINE: [f32; 4] = [0.23, 0.23, 0.29, 0.82];
 const MINIMAP_THUMB_FILL: [f32; 4] = [0.82, 0.82, 0.92, 0.18];
@@ -262,9 +271,28 @@ enum Mode {
     Attach { socket: PathBuf },
 }
 
+/// Number of decimal digits in `n` (for `n >= 1`); allocation-free. Sizes
+/// the line-number gutter (UX gutter arc). Mirrors the TUI's
+/// `pmacs::window::decimal_digits` — kept local since pmacs-gpu doesn't
+/// depend on the `pmacs` crate.
+fn decimal_digits(mut n: usize) -> u32 {
+    let mut d = 1u32;
+    while n >= 10 {
+        n /= 10;
+        d += 1;
+    }
+    d
+}
+
 fn main() {
     env_logger::init();
-    let mode = parse_args(std::env::args().skip(1).collect());
+    // Filter the frontend-local `--line-numbers` flag out before the
+    // mode parser (UX gutter arc, Q#UX5) — it's orthogonal to the
+    // hello-world/attach mode and may appear in any position.
+    let mut args: Vec<String> = std::env::args().skip(1).collect();
+    let line_numbers = args.iter().any(|a| a == "--line-numbers");
+    args.retain(|a| a != "--line-numbers");
+    let mode = parse_args(args);
     let event_loop = EventLoop::<AppEvent>::with_user_event()
         .build()
         .expect("create winit event loop");
@@ -275,6 +303,7 @@ fn main() {
         state: None,
         attach_client: None,
         modifiers: winit::keyboard::ModifiersState::empty(),
+        line_numbers,
     };
     event_loop
         .run_app(&mut app)
@@ -333,6 +362,9 @@ struct App {
     /// delivers modifiers separately from key presses, so we track the
     /// current set and apply it when a key is sent (session B1).
     modifiers: winit::keyboard::ModifiersState,
+    /// Line-number gutter toggle from `--line-numbers` (UX gutter arc);
+    /// applied to `State` once it's built in `resumed`.
+    line_numbers: bool,
 }
 
 type LoroTextDeltaBatches = Arc<Mutex<Vec<Vec<loro::TextDelta>>>>;
@@ -622,6 +654,15 @@ struct State {
     /// Minimap vertex bytes cached by [`MinimapCacheKey`] —
     /// rebuilding rescanned every line shape per frame.
     minimap_cache: Option<(MinimapCacheKey, Vec<u8>)>,
+    /// Line-number gutter toggle (UX gutter arc, GPU side). Frontend-local
+    /// (Q#UX5), set from the `--line-numbers` flag. Off ⇒ zero coordinate
+    /// change: `gutter_width_px()` is 0 and every shift site is a no-op.
+    line_numbers: bool,
+    /// Shaped right-aligned line numbers, one per visible code line — its
+    /// own text layer over the code, aligned row-for-row (same line height).
+    gutter_buffer: Buffer,
+    /// Dedicated renderer for the gutter number layer (like the menu / mb).
+    gutter_text_renderer: TextRenderer,
 }
 
 /// The wire-authoritative status facts (Q#S1, protocol v8),
@@ -757,7 +798,9 @@ impl ApplicationHandler<AppEvent> for App {
             Mode::HelloWorld => HELLO_TEXT,
             Mode::Attach { .. } => "(connecting...)",
         };
-        self.state = Some(State::new(event_loop, initial_text));
+        let mut state = State::new(event_loop, initial_text);
+        state.line_numbers = self.line_numbers;
+        self.state = Some(state);
 
         // In attach mode, kick off the connection now that the event
         // loop is running and a proxy is available. Failure logs and
@@ -1700,6 +1743,9 @@ impl State {
         // Q#MB1 — a third renderer for the minibuffer dropdown layer.
         let mb_text_renderer =
             TextRenderer::new(&mut atlas, &device, MultisampleState::default(), None);
+        // UX gutter — a renderer for the line-number layer.
+        let gutter_text_renderer =
+            TextRenderer::new(&mut atlas, &device, MultisampleState::default(), None);
         let quad_renderer = QuadRenderer::new(&device, format);
         let squiggle_renderer = SquiggleRenderer::new(&device, format);
 
@@ -1749,6 +1795,17 @@ impl State {
             Some(MB_DROP_MAX_WIDTH),
             Some(config.height as f32),
         );
+        // Line-number gutter buffer (UX gutter arc): same font size + line
+        // height as the code buffer so its rows align one-for-one.
+        let mut gutter_buffer = Buffer::new(
+            &mut font_system,
+            Metrics::new(CODE_FONT_SIZE, CODE_LINE_HEIGHT),
+        );
+        gutter_buffer.set_size(
+            &mut font_system,
+            Some(config.width as f32),
+            Some(config.height as f32),
+        );
         buffer.set_text(
             &mut font_system,
             initial_text,
@@ -1831,6 +1888,9 @@ impl State {
             mb_text_renderer,
             mb_bg_vertex_buffer: ReusableVertexBuffer::new(),
             minimap_cache: None,
+            line_numbers: false,
+            gutter_buffer,
+            gutter_text_renderer,
         }
     }
 
@@ -2732,6 +2792,66 @@ impl State {
         self.scroll_top != old
     }
 
+    /// Monospace glyph advance in px, read from the currently-shaped code
+    /// buffer (every glyph shares it in a monospace font), with a fallback
+    /// when the buffer has no glyphs yet. Used to size the line-number
+    /// gutter (UX gutter arc).
+    fn mono_advance(&self) -> f32 {
+        self.buffer
+            .layout_runs()
+            .flat_map(|run| run.glyphs.iter())
+            .next()
+            .map_or(GUTTER_MONO_ADVANCE_FALLBACK, |g| g.w)
+    }
+
+    /// Width in px the line-number gutter reserves on the left, or 0 when
+    /// disabled (UX gutter arc, Q#UX3): `digits * advance + gap`. Mirrors
+    /// the TUI's `Window::gutter_width`; the unit here is pixels.
+    fn gutter_width_px(&self) -> f32 {
+        if !self.line_numbers {
+            return 0.0;
+        }
+        let lines = self.current_line_starts.len().max(1);
+        decimal_digits(lines) as f32 * self.mono_advance() + GUTTER_GAP_PX
+    }
+
+    /// The code's left origin in px: `TEXT_LEFT` plus the gutter. Every
+    /// byte→pixel x site adds this instead of the bare `TEXT_LEFT` (Q#UX2),
+    /// and the pixel→byte hit-test subtracts it.
+    fn text_left(&self) -> f32 {
+        TEXT_LEFT + self.gutter_width_px()
+    }
+
+    /// Reshape the gutter buffer to the right-aligned line numbers for the
+    /// currently-shaped code lines (UX gutter arc). One number per code
+    /// line starting at `shaped_top`, so the two buffers align row-for-row
+    /// at the same `top` and line height. No-op when the gutter is off.
+    fn refresh_gutter_buffer(&mut self) {
+        use std::fmt::Write as _;
+        if !self.line_numbers {
+            return;
+        }
+        let digits = decimal_digits(self.current_line_starts.len().max(1)) as usize;
+        let first = self.shaped_top;
+        let n = self.buffer.lines.len();
+        let mut text = String::new();
+        for i in 0..n {
+            if i > 0 {
+                text.push('\n');
+            }
+            let _ = write!(text, "{:>digits$}", first + i + 1);
+        }
+        self.gutter_buffer.set_text(
+            &mut self.font_system,
+            &text,
+            &Attrs::new().family(Family::Name("JetBrains Mono")),
+            Shaping::Advanced,
+            None,
+        );
+        self.gutter_buffer
+            .shape_until_scroll(&mut self.font_system, false);
+    }
+
     /// Resolve a window-pixel position to an **absolute source byte**
     /// (Q#M2): pixel → cosmic-text hit (shaped line + byte within
     /// line) → projected byte → run map → slice byte → + `vstart`.
@@ -2755,7 +2875,7 @@ impl State {
             self.projected_line_starts = projected_line_starts;
             self.hit_map_dirty = false;
         }
-        let rel_x = x as f32 - TEXT_LEFT;
+        let rel_x = x as f32 - self.text_left();
         let rel_y = y as f32 - TEXT_TOP;
         let cursor = self.buffer.hit(rel_x, rel_y)?;
         let line_start = *self.projected_line_starts.get(cursor.line)?;
@@ -3771,6 +3891,9 @@ impl State {
         let frame_start = debug_frame().then(std::time::Instant::now);
         self.refresh_status_line();
         self.refresh_menu_buffer();
+        // UX gutter: reshape the line-number layer to the current scroll
+        // (no-op when the gutter is off).
+        self.refresh_gutter_buffer();
         // Q#CM1 — the context-menu popup quads (bg / highlight /
         // separators), drawn as a top layer after everything else.
         let menu_vertices = self.menu_vertex_bytes();
@@ -3881,6 +4004,15 @@ impl State {
             (self.config.width as f32 - STATUS_TEXT_PAD - status_width).max(TEXT_LEFT);
         let status_top =
             text_area_bottom(self.config.height) + (STATUS_BAND_HEIGHT - STATUS_LINE_HEIGHT) / 2.0;
+        // UX gutter: the code's left origin (past the gutter) and the
+        // main-text clip-left. Computed here as locals — calling `self.*`
+        // inside the `prepare` args would conflict with its `&mut` borrows.
+        let text_left = self.text_left();
+        let gutter_clip_left = if self.line_numbers {
+            text_left.floor() as i32
+        } else {
+            0
+        };
         self.text_renderer
             .prepare(
                 &self.device,
@@ -3891,11 +4023,11 @@ impl State {
                 [
                     TextArea {
                         buffer: &self.buffer,
-                        left: TEXT_LEFT,
+                        left: text_left,
                         top: TEXT_TOP,
                         scale: 1.0,
                         bounds: TextBounds {
-                            left: 0,
+                            left: gutter_clip_left,
                             top: 0,
                             right: text_bounds_right,
                             // Clip at the status band (Q#S3): a final
@@ -3940,6 +4072,39 @@ impl State {
             )
             .expect("text_renderer prepare");
 
+        // UX gutter: prepare the line-number layer in the reserved left
+        // strip (empty when off → renders nothing). Same `top` + line
+        // height as the code, so numbers align row-for-row.
+        let gutter_areas: Vec<TextArea> = if self.line_numbers {
+            vec![TextArea {
+                buffer: &self.gutter_buffer,
+                left: TEXT_LEFT,
+                top: TEXT_TOP,
+                scale: 1.0,
+                bounds: TextBounds {
+                    left: 0,
+                    top: 0,
+                    right: gutter_clip_left,
+                    bottom: text_area_bottom(self.config.height).round() as i32,
+                },
+                default_color: Color::rgb(120, 120, 135),
+                custom_glyphs: &[],
+            }]
+        } else {
+            Vec::new()
+        };
+        self.gutter_text_renderer
+            .prepare(
+                &self.device,
+                &self.queue,
+                &mut self.font_system,
+                &mut self.atlas,
+                &self.viewport,
+                gutter_areas,
+                &mut self.swash_cache,
+            )
+            .expect("gutter_text_renderer prepare");
+
         // Q#CM1 — prepare the menu glyphs in their own layer (empty when
         // closed, so the renderer draws nothing).
         let menu_areas: Vec<TextArea> = self
@@ -4052,6 +4217,11 @@ impl State {
             self.text_renderer
                 .render(&self.atlas, &self.viewport, &mut pass)
                 .expect("text_renderer render");
+            // UX gutter: line numbers in the reserved left strip (empty
+            // layer when off).
+            self.gutter_text_renderer
+                .render(&self.atlas, &self.viewport, &mut pass)
+                .expect("gutter_text_renderer render");
             // Caret over the text so the insertion point reads on top
             // of the glyph it sits before (session B1).
             if let Some(vertex_buffer) = caret_buffer.as_ref() {
@@ -4339,20 +4509,22 @@ impl State {
         }
         let slice_cursor = cursor - vstart;
         let (line_lo, _) = source_line_range(slice, slice_cursor);
+        // UX gutter: the caret sits in the code area, past the gutter.
+        let text_left = self.text_left();
         for run in self.buffer.layout_runs() {
             if line_offsets.get(run.line_i).copied().unwrap_or(0) != line_lo {
                 continue;
             }
             let line_base = line_lo;
-            let mut x = TEXT_LEFT;
+            let mut x = text_left;
             for glyph in run.glyphs {
                 if line_base + glyph.start as u64 >= slice_cursor {
-                    x = TEXT_LEFT + glyph.x;
+                    x = text_left + glyph.x;
                     break;
                 }
                 // Cursor is past this glyph; track its right edge so a
                 // cursor at line end lands after the final glyph.
-                x = TEXT_LEFT + glyph.x + glyph.w;
+                x = text_left + glyph.x + glyph.w;
             }
             return Some(MinimapRect {
                 x,
@@ -4383,6 +4555,8 @@ impl State {
         if hi <= lo {
             return;
         }
+        // UX gutter: washes/squiggles are code-relative, past the gutter.
+        let text_left = self.text_left();
         for run in self.buffer.layout_runs() {
             let line_base = line_offsets.get(run.line_i).copied().unwrap_or(0);
             let mut min_x: Option<f32> = None;
@@ -4410,7 +4584,7 @@ impl State {
                     None => (TEXT_TOP + run.line_top, run.line_height),
                 };
                 rects.push(MinimapRect {
-                    x: TEXT_LEFT + x0,
+                    x: text_left + x0,
                     y,
                     w: x1 - x0,
                     h,
@@ -7147,4 +7321,24 @@ mod tests {
             "text should paint visible ink (only {differing} bytes differ from the empty frame)"
         );
     }
+
+    #[test]
+    fn headless_line_number_gutter_changes_the_frame() {
+        // UX gutter: enabling line numbers must add ink on the left and
+        // shift the code right — the rendered frame must differ.
+        let Some(mut off) = headless_or_skip(400, 300, "alpha\nbeta\ngamma\ndelta\n") else {
+            return;
+        };
+        let off_px = off.render_offscreen();
+        let mut on = State::new_headless(400, 300, "alpha\nbeta\ngamma\ndelta\n")
+            .expect("adapter was just available");
+        on.line_numbers = true;
+        let on_px = on.render_offscreen();
+        assert_eq!(off_px.len(), on_px.len());
+        let differing = off_px.iter().zip(&on_px).filter(|(a, b)| a != b).count();
+        assert!(
+            differing > 200,
+            "the gutter should add ink + shift the text (only {differing} bytes differ)"
+        );
+    }
 }

From 1ea2d5f17f86c47d0c40f5fb3a29642bfc70a399 Mon Sep 17 00:00:00 2001
From: Levi Neuwirth <ln@levineuwirth.org>
Date: Mon, 6 Jul 2026 14:27:44 -0400
Subject: [PATCH 3/4] feat(gutter): daemon-owned line-number mode over protocol
 v13 (unified toggle)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fix the control plane for the line-number gutter: M-x
window.toggle-line-numbers now works from EITHER frontend, each affecting
its own window.

Root cause (scores framing bet Q#UX1 false): rendering a gutter is
frontend-local, but the TOGGLE is a daemon command, so the mode has to
reach the GUI over the wire. My earlier GPU control (a --line-numbers flag)
left M-x-in-the-GUI a no-op and the two frontends' settings disconnected.

- Protocol: new additive `InstanceMessage::LineNumbers { buffer_id,
  enabled }`; PROTOCOL_VERSION 12 → 13, SUPPORTED grows to [6..13].
  Daemon-gated < 13 (a v12 peer keeps its gutter off), like every prior
  additive bump — no encoding break.
- Producer: SemanticRenderState::line_numbers_msg reads the frontend's
  active window mode (via active_window_for(frontend_id)) and emits on
  change; cached-compare suppression seeded to the frontend's `off`
  default, so a plain window adds zero traffic and existing frames are
  unchanged.
- Daemon: gate LineNumbers >= 13 in the write loop.
- TUI: drops LineNumbers silently (reads its window directly).
- GPU: consumes LineNumbers → drives local `line_numbers`; the
  --line-numbers flag retired.

Now the daemon Window.line_numbers is the single source of truth; both
frontends render locally from it.

Tests: line_numbers_msg emit-on-toggle/suppress-when-unchanged; protocol
version pins updated to 13. Validated: fmt + clippy --all-targets clean
both flavors; 1440 lib + 12 protocol + 53 pmacs-gpu tests pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014TXbAwk27agwhrNNrhLi2U
---
 docs/ux-arc-framing.md        | 242 ++++++++++++++++++++++++++++++++++
 pmacs-gpu/src/main.rs         |  27 ++--
 pmacs-protocol/src/message.rs |  23 +++-
 src/daemon.rs                 |  10 ++
 src/frontend.rs               |   4 +
 src/protocol.rs               |  21 +--
 src/semantic_render.rs        |  75 +++++++++++
 7 files changed, 377 insertions(+), 25 deletions(-)
 create mode 100644 docs/ux-arc-framing.md

diff --git a/docs/ux-arc-framing.md b/docs/ux-arc-framing.md
new file mode 100644
index 0000000..4897841
--- /dev/null
+++ b/docs/ux-arc-framing.md
@@ -0,0 +1,242 @@
+# UX arc — framing (the gutter, and what it unlocks)
+
+A UX overhaul arc for pmacs. The diagnostic-surface work (colors, status
+counts, wavy squiggles, minimap marks) already shipped (PRs #64–69), so
+the next frontier isn't polishing diagnostics — it's the **one layout
+primitive both frontends still lack: a gutter column.** Line numbers,
+diagnostic *gutter signs* (the last deferred Task #23 item), and later
+fold/git-diff markers all live in the gutter. This doc frames the umbrella
+UX arc and designs its keystone, the gutter, grounded in a coordinate-
+system recon of both frontends.
+
+## Why the gutter is the keystone
+
+Two independently-requested features share one missing foundation:
+
+- **Line numbers** — requested; every editor has them; pmacs has none.
+- **Diagnostic gutter signs** — explicitly parked in the diagnostics arc:
+  *"no gutter column exists; adding one is a layout-level project,
+  deliberately not done."* Today the TUI fakes it with a col-0 background
+  marker (`diag.rs`) and the GPU proxies it with minimap marks.
+
+Both need a reserved left column and the coordinate-math to go with it.
+Build the column once (per frontend) and both features — plus future fold
+markers, git-diff bars, breakpoint dots — become content that rides it.
+
+## The load-bearing bet: no protocol change
+
+The daemon is **pixel-pure** — it never learns screen geometry; the
+frontend owns viewport and visual layout (the semantic-frontend contract).
+The gutter is therefore **entirely frontend-local**, and the recon
+confirms each frontend already holds the data it needs:
+
+- **Line numbers** — the frontend owns the text, so it has line indices.
+- **Diagnostic severity per line** — already frontend-side (TUI:
+  `DiagnosticView` over the diag store; GPU: `current_decorations`, the
+  same source the squiggles use). Map each diagnostic's `range.start` to a
+  line, take the max severity per line — no new wire data.
+
+So **zero protocol change, zero daemon change.** The blast radius is two
+frontend renderers. (This also means it's implemented *twice* — the TUI
+grid and the GPU are separate codebases with no shared render code — so
+the design fixes a shared *convention*, §Q#UX7, even though the code is
+duplicated.)
+
+## The reserved-width model
+
+A gutter is a fixed-width strip carved from the **left**, mirroring how the
+GPU already carves the **right** for the minimap. Text shrinks by the
+gutter width; the gutter stays fixed while text scrolls (neither frontend
+has horizontal scroll, so "fixed while scrolling" is free — only the
+*numbers* printed change with the vertical scroll position).
+
+**TUI** (recon: clean seam). The renderer paints everything relative to a
+per-window `Viewport { cell_origin, cell_size }`. The whole gutter is
+fundamentally *one shift* at the viewport-construction site
+(`editor.rs:1610`): `cell_origin.col += gutter_w`, `cell_size.cols -=
+gutter_w`, then paint the gutter into the reclaimed `[rect.origin.col,
++gutter_w)` strip. Every painter that consumes `viewport.cell_origin`
+(base text, syntax, diagnostic underline, search) becomes gutter-agnostic
+**for free**. The handful that read `rect.origin.col` *directly* each need
+a manual `+gutter_w`:
+- cursor placement (`editor.rs:1683`), local selection (`:1794`),
+  remote-presence cursor/selection (`overlay_paint.rs:160,253`);
+- mouse hit-test (`dispatch_mouse`, `editor.rs:866`) subtracts `gutter_w`
+  from `local_col`, and clicks with `local_col < gutter_w` are gutter
+  clicks (§Q#UX6);
+- the diagnostic col-0 sign (`diag.rs:499–586`) relocates into the strip —
+  `gutter_glyph()` (`diag.rs:75`) is already defined and unused, waiting
+  for exactly this.
+
+`pos_to_display`/`display_to_pos` (the byte↔display-column core) operate
+in line-local space and need **no change** — the gutter is applied by
+callers crossing into grid space, not in the mapping itself.
+
+**GPU** (recon: one knob). All horizontal geometry hangs off `TEXT_LEFT =
+16.0`. A gutter of width `G` is:
+- **pixel→byte** — one site: `hit_test_source_byte` (`main.rs:2758`),
+  `x - TEXT_LEFT` → `x - TEXT_LEFT - G`;
+- **byte→pixel** — four sites, each `TEXT_LEFT` → `TEXT_LEFT + G`: glyph
+  render origin (`TextArea.left`, `:3894`), text clip `bounds.left` (`:3898`,
+  `0` → `G`), caret (`:4350/4355`), washes+squiggles (`:4413`);
+- **placement loop** — walk `layout_runs()` (`run.line_top`, `run.line_i`)
+  and draw gutter glyphs/quads at `x ∈ [0, G)`, exactly the minimap's
+  mirror on the left. Reserve the band for clicks like `in_minimap_band`.
+
+Neither frontend has horizontal scroll or soft-wrap today, so there is no
+scroll-offset interaction to reconcile — the single biggest simplifier.
+
+## Forced decisions
+
+**Q#UX1 — frontend-local, no protocol change. ✗ DISPROVEN (see below).**
+Framed as: the data is local in both frontends, so no wire change. That was
+half-right — *rendering* is local, but the **control** (`M-x
+window.toggle-line-numbers`) lives daemon-side, so the mode must reach the
+GUI over the wire. Corrected to: the toggle is daemon-owned per-window
+state, shipped to the frontend via a new additive `InstanceMessage::
+LineNumbers` variant (**protocol v13**, daemon-gated `< 13`). The GUI still
+*renders* locally; it just receives the on/off flag. See the as-built
+control-plane note.
+
+**Q#UX2 — reserve on the left, mirror the minimap.** Text area shrinks;
+the gutter is a fixed strip. TUI: shift the viewport at one site. GPU: add
+`G` to the four byte→pixel sites, subtract at the one pixel→byte site, set
+a `text_bounds_left`.
+
+**Q#UX3 — dynamic width, digit-count driven.** `gutter_w = digits(line_
+count) + padding` (padding = 1 leading + 1 trailing cell/space typical).
+Recomputed as the line count crosses a power of ten. Rejected: fixed width
+(wastes space on small files, truncates on huge ones). Line count is
+already in hand at the width-computation site in both frontends.
+
+**Q#UX4 — modes: `off | absolute | relative | hybrid`.** `absolute` =
+line index + 1. `relative` = distance from the cursor line (Vim-style, for
+fast `N j`/`N k`). `hybrid` = current line absolute, others relative (the
+popular default). Ships incrementally: **absolute first** (proves the
+column + width + coordinate math with zero cursor-coupling), relative/
+hybrid as a follow-up (they add a cursor-line dependency + repaint-on-
+cursor-move, which is why they come second).
+
+**Q#UX5 — the setting hook + where state lives.** Model on the existing
+`frame_target_ms` tunable (`async_runtime.rs:630` + Lua `_frame_target_ms`
+/`_set_frame_target_ms`). Line-number mode is naturally **per-window**
+(relative numbers frequently are), so the field lives on `struct Window`
+(TUI) and is read at paint time; a `pmacs.window`/`pmacs.frontend` binding
+sets it, wrapped by a friendly `builtin/` Lua chunk. The GPU reads an
+equivalent local setting (it has no window tree, so a single frontend-wide
+mode is fine there for v1). Consistency of *value* across frontends is a
+convention, not shared code.
+
+**Q#UX6 — gutter click behavior.** MVP: a click in the gutter band selects
+the whole line (common editor affordance) — or, if that's too much for the
+first cut, is consumed as a no-op (never mis-mapped to a text byte). The
+recon shows both frontends can classify a gutter-band click cheaply
+(`local_col < gutter_w` / `in_minimap_band`-style). Pick line-select if
+it's a few lines; else no-op and defer.
+
+**Q#UX7 — shared convention across the two renderers.** The code is
+duplicated, so the design pins the *contract* both must honor: same width
+formula (`digits + padding`), same number formatting (right-aligned,
+1-based), same mode set, same diagnostic-sign glyphs/severity precedence,
+gutter never overlaps the mode line / status band / minibuffer. A short
+"gutter contract" section in each frontend's code comments points back
+here so they don't drift.
+
+## Sub-arc sequence (each its own PR, each green under both flavors)
+
+1. **Gutter + absolute line numbers.** Introduce the reserved column and
+   the coordinate shift in *both* frontends; render absolute numbers. The
+   riskiest, most valuable step — it lands the foundation and the
+   coordinate math. Validation is a human eyeball per frontend (cursor
+   lands on the right glyph after a click; caret draws in the right place;
+   selection/overlays don't bleed into the gutter).
+2. **Diagnostic gutter signs.** Relocate the TUI col-0 marker into the
+   gutter (`gutter_glyph()`) and add GPU gutter glyphs; max-severity per
+   line from data already present. Closes the last Task #23 item.
+3. **Relative / hybrid line-number modes.** Add the cursor-line dependency
+   + repaint-on-cursor-move; a mode toggle on the same machinery.
+4. **The rest of the UX backlog** (below), sequenced later.
+
+## The umbrella UX backlog (beyond the gutter)
+
+Named now so the arc has a horizon; not committed, sequenced after the
+gutter sub-arcs:
+- **Minibuffer polish** — `i/total` hint, Telescope-style preview pane,
+  candidate annotations (kind/docstring), multibyte-exact band caret.
+- **Editing affordances** — current-line highlight refinements, whitespace
+  rendering, indent guides.
+- **Folding** — needs a fold engine *and* gutter fold markers (rides the
+  gutter built here); big, greenfield.
+- **Git-diff gutter markers** — needs a diff source; rides the gutter.
+- **Context-menu polish** — submenus, kill-ring/clipboard history,
+  first-letter mnemonic jump.
+
+## Categorical bets (score at the arc's close)
+
+- **No protocol change holds. → SCORED FALSE.** *Rendering* is local, but
+  the toggle *command* lives daemon-side, so the mode has to cross the
+  wire. It cost one additive variant + a version bump (v13) — cheap and
+  routine here, but the bet was wrong: "renders locally" does not imply
+  "no protocol change" when control is daemon-owned. Lesson for the rest of
+  the arc: a frontend-rendered feature still needs a wire channel whenever
+  its *control* is a daemon command.
+- **The coordinate shift is localized, not pervasive.** Recon says TUI = 1
+  viewport shift + ~5 manual sites; GPU = 1 pixel→byte + 4 byte→pixel
+  sites. If a gutter bug shows up somewhere *not* on those lists, the bet
+  was wrong and the mapping was less centralized than the recon found.
+- **`pos_to_display` / cosmic-hit stay gutter-agnostic.** The mapping core
+  is untouched; only the grid-crossing callers change. If a mapping-core
+  edit becomes necessary, the seam was leakier than modeled.
+- **Duplication is cheaper than abstraction here.** Two ~50-line gutter
+  implementations beat inventing a shared cross-frontend layout layer for
+  two consumers. Revisit only if a third frontend appears.
+
+## Validation implications
+
+Per sub-arc: `fmt` + `clippy --all-targets` + full tests under **both** Lua
+flavors, as always. But the load-bearing validation is a **human eyeball
+in each frontend** — the coordinate shift is precisely the class of change
+where a unit test passes and the caret still lands one column off. Minimum
+manual checklist for sub-arc 1: click-to-place lands correctly with the
+gutter present; caret draws in the right cell/pixel; selection drag stays
+out of the gutter; resize/scroll keep the gutter fixed; a >999-line file
+grows the width without misaligning anything. GPU and TUI checked
+separately.
+
+## As-built
+
+**Sub-arc 1 — gutter + absolute line numbers (TUI + GPU).**
+
+- **TUI** (`window.rs`/`editor.rs`/`overlay_paint.rs`): `LineNumberMode
+  {Off, Absolute}` per-window field + `Window::gutter_width()`. One
+  viewport shift (`editor.rs`) makes text/syntax/diag/search painters
+  gutter-agnostic; ~5 direct-coordinate sites (cursor, selection, mouse
+  hit-test → line-start, remote presence) each add `gutter_w`.
+  `paint_line_number_gutter` writes right-aligned dim digits alloc-free.
+- **GPU** (`pmacs-gpu/main.rs`): everything hangs off `TEXT_LEFT`; a
+  `text_left()` (= `TEXT_LEFT + gutter_width_px()`) is applied at the 4
+  byte→pixel sites (main text, caret, washes/squiggles) and subtracted at
+  the 1 pixel→byte hit-test. A dedicated `gutter_text_renderer`/buffer
+  draws right-aligned dim numbers reshaped per scroll, mirroring the
+  minimap's reserved column.
+- **Control plane (the Q#UX1 correction).** M-x
+  `window.toggle-line-numbers` sets the active window's mode (daemon-side).
+  The TUI reads its window directly; the GUI receives the mode via the new
+  **`InstanceMessage::LineNumbers { buffer_id, enabled }`** (protocol
+  **v13**, additive, daemon-gated `< 13`). Producer:
+  `SemanticRenderState::line_numbers_msg` (cached-compare suppression,
+  seeded to the frontend's `off` default so a plain window adds no
+  traffic). Consumer: the GUI drives its local `line_numbers` from it. The
+  earlier `--line-numbers` GPU flag was retired. Now one `M-x` toggle works
+  in **both** frontends, each affecting its own window — a single source of
+  truth.
+
+Validated: `fmt` + `clippy --all-targets` clean under both Lua flavors;
+1440 lib tests (incl. the gutter render + `line_numbers_msg` emit/suppress
+tests), 12 protocol, 53 pmacs-gpu (incl. the headless gutter render test on
+the adapter). Both frontends eyeballed for coordinate correctness.
+
+Deferred to later sub-arcs: relative/hybrid modes; diagnostic gutter signs
+(sub-arc 2); the exact gutter padding is a tunable to eyeball.
+
+<!-- next sub-arcs appended here -->
diff --git a/pmacs-gpu/src/main.rs b/pmacs-gpu/src/main.rs
index b8e7961..48b85cb 100644
--- a/pmacs-gpu/src/main.rs
+++ b/pmacs-gpu/src/main.rs
@@ -286,13 +286,7 @@ fn decimal_digits(mut n: usize) -> u32 {
 
 fn main() {
     env_logger::init();
-    // Filter the frontend-local `--line-numbers` flag out before the
-    // mode parser (UX gutter arc, Q#UX5) — it's orthogonal to the
-    // hello-world/attach mode and may appear in any position.
-    let mut args: Vec<String> = std::env::args().skip(1).collect();
-    let line_numbers = args.iter().any(|a| a == "--line-numbers");
-    args.retain(|a| a != "--line-numbers");
-    let mode = parse_args(args);
+    let mode = parse_args(std::env::args().skip(1).collect());
     let event_loop = EventLoop::<AppEvent>::with_user_event()
         .build()
         .expect("create winit event loop");
@@ -303,7 +297,6 @@ fn main() {
         state: None,
         attach_client: None,
         modifiers: winit::keyboard::ModifiersState::empty(),
-        line_numbers,
     };
     event_loop
         .run_app(&mut app)
@@ -362,9 +355,6 @@ struct App {
     /// delivers modifiers separately from key presses, so we track the
     /// current set and apply it when a key is sent (session B1).
     modifiers: winit::keyboard::ModifiersState,
-    /// Line-number gutter toggle from `--line-numbers` (UX gutter arc);
-    /// applied to `State` once it's built in `resumed`.
-    line_numbers: bool,
 }
 
 type LoroTextDeltaBatches = Arc<Mutex<Vec<Vec<loro::TextDelta>>>>;
@@ -798,9 +788,7 @@ impl ApplicationHandler<AppEvent> for App {
             Mode::HelloWorld => HELLO_TEXT,
             Mode::Attach { .. } => "(connecting...)",
         };
-        let mut state = State::new(event_loop, initial_text);
-        state.line_numbers = self.line_numbers;
-        self.state = Some(state);
+        self.state = Some(State::new(event_loop, initial_text));
 
         // In attach mode, kick off the connection now that the event
         // loop is running and a proxy is available. Failure logs and
@@ -2538,6 +2526,16 @@ impl State {
                 self.request_redraw();
                 None
             }
+            // UX gutter (protocol v13): the daemon owns the per-window
+            // line-number toggle (`M-x window.toggle-line-numbers`); apply
+            // it to our local gutter state and repaint on change.
+            InstanceMessage::LineNumbers { enabled, .. } => {
+                if self.line_numbers != enabled {
+                    self.line_numbers = enabled;
+                    self.request_redraw();
+                }
+                None
+            }
             // Q#SR5 / Q#RX6 — the live isearch prompt (protocol v10).
             // `query: None` clears the band (search ended); `Some` shows
             // `[Regex] I-search: <query> (n/m)` on the band's left side.
@@ -5081,6 +5079,7 @@ fn instance_message_label(msg: &InstanceMessage) -> &'static str {
         InstanceMessage::FoldState { .. } => "FoldState",
         InstanceMessage::ResourceOffer { .. } => "ResourceOffer",
         InstanceMessage::DispatchIdle { .. } => "DispatchIdle",
+        InstanceMessage::LineNumbers { .. } => "LineNumbers",
     }
 }
 
diff --git a/pmacs-protocol/src/message.rs b/pmacs-protocol/src/message.rs
index ddb4da3..54d97b5 100644
--- a/pmacs-protocol/src/message.rs
+++ b/pmacs-protocol/src/message.rs
@@ -905,6 +905,19 @@ pub enum InstanceMessage {
         /// Total candidate count (the window is a slice of this).
         total: u32,
     },
+    /// UX gutter (protocol v13) — the per-window line-number gutter mode
+    /// for the frontend's active window. A semantic frontend renders line
+    /// numbers *locally* (it owns the text), but the on/off toggle lives
+    /// daemon-side (`M-x window.toggle-line-numbers`), so the daemon ships
+    /// the mode. Additive + daemon-gated `>= 13` — an older peer would
+    /// hard-error decoding it, so it stays off wires negotiated below 13.
+    LineNumbers {
+        /// Buffer the active window shows (routing/consistency; the mode
+        /// is a window property, not a buffer one).
+        buffer_id: crate::BufferId,
+        /// Whether the line-number gutter is enabled for that window.
+        enabled: bool,
+    },
 }
 
 /// One row of an open menu on the wire ([`InstanceMessage::MenuPrompt`]).
@@ -1180,7 +1193,13 @@ pub enum ResourceBody {
 /// encoding. Still daemon-gated per session (now at `< 10`); a v9 peer
 /// negotiates v9 and simply receives no `SearchPrompt` (the decorations
 /// still highlight), rather than mis-decoding the wider shape.
-pub const PROTOCOL_VERSION: u32 = 12;
+///
+/// UX gutter: bumped 12 → 13 for [`InstanceMessage::LineNumbers`] — a new
+/// additive variant carrying the per-window line-number gutter mode.
+/// Daemon-gated `< 13`; a v12 peer negotiates v12 and receives no
+/// `LineNumbers` (its gutter simply stays off), like every prior additive
+/// bump.
+pub const PROTOCOL_VERSION: u32 = 13;
 
 /// T M10.5: the set of protocol versions a v1.0 binary accepts on
 /// the wire. v0.1 binaries only accepted `[1]`; v1.0 binaries accept
@@ -1237,7 +1256,7 @@ pub const PROTOCOL_VERSION: u32 = 12;
 /// Q#MB1: extended to `[6, 7, 8, 9, 10, 11, 12]`.
 /// `InstanceMessage::MinibufferPrompt` is additive and daemon-gated per
 /// session, so the ladder resumes again.
-pub const SUPPORTED_PROTOCOL_VERSIONS: &[u32] = &[6, 7, 8, 9, 10, 11, 12];
+pub const SUPPORTED_PROTOCOL_VERSIONS: &[u32] = &[6, 7, 8, 9, 10, 11, 12, 13];
 
 /// T M10.5: predicate for the handshake check. Returns `true` if
 /// `peer_version` is in [`SUPPORTED_PROTOCOL_VERSIONS`].
diff --git a/src/daemon.rs b/src/daemon.rs
index 968c0c4..df334da 100644
--- a/src/daemon.rs
+++ b/src/daemon.rs
@@ -1050,6 +1050,11 @@ fn dispatcher_loop(
                 let peer_knows_minibuffer_prompt = session_registry
                     .session_state(*fid)
                     .is_some_and(|s| s.negotiated_protocol_version >= 12);
+                // UX gutter — `LineNumbers` is a v13 additive variant; a
+                // v12 peer keeps its gutter off rather than mis-decoding it.
+                let peer_knows_line_numbers = session_registry
+                    .session_state(*fid)
+                    .is_some_and(|s| s.negotiated_protocol_version >= 13);
                 for msg in &messages {
                     if !peer_knows_status_facts
                         && matches!(msg, InstanceMessage::StatusFacts { .. })
@@ -1075,6 +1080,11 @@ fn dispatcher_loop(
                     {
                         continue;
                     }
+                    if !peer_knows_line_numbers
+                        && matches!(msg, InstanceMessage::LineNumbers { .. })
+                    {
+                        continue;
+                    }
                     // T M10.10 Day 4 / M10.11 F2 — the criterion-1
                     // jitter site: render-write latency.
                     //
diff --git a/src/frontend.rs b/src/frontend.rs
index 484297a..7ed5cc8 100644
--- a/src/frontend.rs
+++ b/src/frontend.rs
@@ -405,6 +405,10 @@ impl Frontend {
             // surface; the TUI paints the minibuffer via its own bottom
             // row, so it drops this silently too.
             | InstanceMessage::MinibufferPrompt { .. }
+            // UX gutter — LineNumbers is the semantic-frontend gutter
+            // toggle; the cell-grid TUI reads its window's mode directly,
+            // so it drops this silently like the other semantic families.
+            | InstanceMessage::LineNumbers { .. }
             | InstanceMessage::ResourceOffer { .. }
             // T M11.6 — DispatchIdle is consumed by `attach.rs`'s
             // optimistic-apply gate; if any reaches this render path
diff --git a/src/protocol.rs b/src/protocol.rs
index b9f6c58..01da2bd 100644
--- a/src/protocol.rs
+++ b/src/protocol.rs
@@ -1683,7 +1683,7 @@ mod tests {
     // --- M5.5a handshake & postcard round-trips ---
 
     #[test]
-    fn protocol_version_is_twelve_for_minibuffer() {
+    fn protocol_version_is_thirteen_for_line_numbers() {
         // Pin the value: T M10.5 bumped 1→2 (v1.0 wire: CrdtOp /
         // PresenceUpdate). T M11.1 bumped 2→3 (v1.1 wire: the
         // SemanticFrame family + FrontendEvent::Viewport). T M11.6
@@ -1701,8 +1701,9 @@ mod tests {
         // bumped 10→11 (`PointerKind::Context` + `MenuPointer` +
         // `MenuPrompt`, all additive; the message daemon-gated). Q#MB1
         // bumped 11→12 (`InstanceMessage::MinibufferPrompt`, additive +
-        // daemon-gated).
-        assert_eq!(PROTOCOL_VERSION, 12);
+        // daemon-gated). UX gutter bumped 12→13
+        // (`InstanceMessage::LineNumbers`, additive + daemon-gated).
+        assert_eq!(PROTOCOL_VERSION, 13);
     }
 
     #[test]
@@ -1711,10 +1712,11 @@ mod tests {
         // every cell-carrying message, ending the v1–v5 ladder —
         // pre-v6 peers are refused at the handshake (a clean
         // VersionMismatch) rather than garbling postcard mid-session.
-        // Q#M4 / Q#S1 / Q#SR5 / Q#RX6 / Q#CM1 / Q#MB1: the ladder resumes
-        // above that floor — v7 (`TripleDown`), v8 (`StatusFacts`), v9 +
-        // v10 (`SearchPrompt` + regex/invalid), v11 (the context menu),
-        // v12 (the GUI minibuffer) all interoperate, so v6 through v12 talk.
+        // Q#M4 / Q#S1 / Q#SR5 / Q#RX6 / Q#CM1 / Q#MB1 / UX gutter: the
+        // ladder resumes above that floor — v7 (`TripleDown`), v8
+        // (`StatusFacts`), v9 + v10 (`SearchPrompt` + regex/invalid), v11
+        // (the context menu), v12 (the GUI minibuffer), v13 (`LineNumbers`)
+        // all interoperate, so v6 through v13 talk.
         assert!(is_supported_protocol_version(6));
         assert!(is_supported_protocol_version(7));
         assert!(is_supported_protocol_version(8));
@@ -1722,10 +1724,11 @@ mod tests {
         assert!(is_supported_protocol_version(10));
         assert!(is_supported_protocol_version(11));
         assert!(is_supported_protocol_version(12));
-        for rejected in [0, 1, 2, 3, 4, 5, 13, u32::MAX] {
+        assert!(is_supported_protocol_version(13));
+        for rejected in [0, 1, 2, 3, 4, 5, 14, u32::MAX] {
             assert!(
                 !is_supported_protocol_version(rejected),
-                "v{rejected} must be rejected by a v12 binary"
+                "v{rejected} must be rejected by a v13 binary"
             );
         }
     }
diff --git a/src/semantic_render.rs b/src/semantic_render.rs
index 8fbbdab..8356e3a 100644
--- a/src/semantic_render.rs
+++ b/src/semantic_render.rs
@@ -157,6 +157,11 @@ pub struct SemanticRenderState {
     /// `(name, modified, diag_errors, diag_warnings)` last emitted as
     /// `StatusFacts` (Q#S1) — cached-compare suppression.
     last_status: HashMap<BufferId, (String, bool, u32, u32)>,
+    /// Last-emitted line-number gutter enabled-flag (UX gutter arc,
+    /// protocol v13) — cached-compare suppression. Seeded to `Some(false)`
+    /// (the frontend's default) so an off gutter never emits. Per-frontend
+    /// (one value), since this state carries one frontend's `frontend_id`.
+    last_line_numbers: Option<bool>,
     /// Last emitted `SearchPrompt` payload per buffer, for
     /// cached-compare suppression (see [`SearchPromptFacts`]).
     last_search_prompt: HashMap<BufferId, SearchPromptFacts>,
@@ -240,6 +245,11 @@ impl SemanticRenderState {
             last_minibuffer: None,
             last_summary: HashMap::new(),
             last_status: HashMap::new(),
+            // Seed to the frontend's default (gutter off): a plain default
+            // window never emits `LineNumbers`, so the common case adds no
+            // traffic and the first frame is unchanged. Only an actual
+            // toggle-on (or later toggle-off) ships a message.
+            last_line_numbers: Some(false),
             last_style_gate: HashMap::new(),
             diag_line_cache: HashMap::new(),
         }
@@ -438,6 +448,8 @@ impl SemanticRenderState {
         out.extend(self.file_style_summary_msg(state, vp.buffer_id, generation));
         // --- StatusFacts (status band; Q#S1, protocol v8) ---
         out.extend(self.status_facts_msg(state, vp.buffer_id));
+        // --- LineNumbers (gutter toggle; UX gutter arc, protocol v13) ---
+        out.extend(self.line_numbers_msg(state, vp.buffer_id));
         // --- SearchPrompt (isearch band; Q#SR5, protocol v9) ---
         out.extend(self.search_prompt_msg(state, vp.buffer_id));
         // --- MenuPrompt (context menu; Q#CM1, protocol v11) ---
@@ -685,6 +697,29 @@ impl SemanticRenderState {
         Some(msg)
     }
 
+    /// The `LineNumbers` message for this frame, or `None` when the gutter
+    /// mode hasn't changed (UX gutter arc, protocol v13). The toggle lives
+    /// on this frontend's active window (`M-x window.toggle-line-numbers`);
+    /// a semantic frontend renders the gutter locally but the daemon owns
+    /// the on/off state, so it ships the mode. The daemon's write loop
+    /// keeps the variant off wires negotiated `< 13`.
+    fn line_numbers_msg(
+        &mut self,
+        state: &EditorState,
+        buffer_id: BufferId,
+    ) -> Option<InstanceMessage> {
+        let enabled = {
+            let core = state.core.borrow();
+            core.active_window_for(self.frontend_id)
+                .is_some_and(|w| w.line_numbers != crate::window::LineNumberMode::Off)
+        };
+        if self.last_line_numbers == Some(enabled) {
+            return None;
+        }
+        self.last_line_numbers = Some(enabled);
+        Some(InstanceMessage::LineNumbers { buffer_id, enabled })
+    }
+
     /// The `InlineAdornments` message for this frame, or `None` when
     /// nothing should be sent. The wire variant has no
     /// `generation`/`full`/`segments`, so this is M11.2-level
@@ -1694,6 +1729,45 @@ mod tests {
         state.core.borrow().active_window().buffer_id
     }
 
+    #[test]
+    fn line_numbers_emitted_on_toggle_then_suppressed() {
+        // UX gutter (protocol v13): the daemon ships the per-window gutter
+        // mode. Off is the default → no message; toggling on emits
+        // `LineNumbers { enabled: true }`; an unchanged next frame suppresses.
+        let state = empty_state();
+        let mut s = local();
+        let buffer_id = active_buffer(&state);
+        s.set_viewport(buffer_id, ByteRange { start: 0, end: 64 }, 0);
+
+        // Default (gutter off): no LineNumbers on the first frame.
+        let first = s.render_frame(&state);
+        assert!(
+            !first
+                .iter()
+                .any(|m| matches!(m, InstanceMessage::LineNumbers { .. })),
+            "off gutter must not emit LineNumbers"
+        );
+
+        // Toggle the active window on → next frame emits enabled = true.
+        state.core.borrow_mut().active_window_mut().line_numbers =
+            crate::window::LineNumberMode::Absolute;
+        let on = s.render_frame(&state);
+        assert!(
+            on.iter()
+                .any(|m| matches!(m, InstanceMessage::LineNumbers { enabled: true, .. })),
+            "toggling the gutter on must emit LineNumbers {{ enabled: true }}"
+        );
+
+        // No further change → suppressed.
+        let again = s.render_frame(&state);
+        assert!(
+            !again
+                .iter()
+                .any(|m| matches!(m, InstanceMessage::LineNumbers { .. })),
+            "an unchanged gutter mode must not re-emit"
+        );
+    }
+
     /// All `InstanceMessage` variants the semantic projection may
     /// emit are `StyleSpans`, `Decorations`, `InlineAdornments`,
     /// `FileStyleSummary`, `StatusFacts` (Q#S1), or `SearchPrompt`
@@ -1710,6 +1784,7 @@ mod tests {
                         | InstanceMessage::FileStyleSummary { .. }
                         | InstanceMessage::StatusFacts { .. }
                         | InstanceMessage::SearchPrompt { .. }
+                        | InstanceMessage::LineNumbers { .. }
                 ),
                 "semantic projection emitted an unexpected variant: {m:?}"
             );

From 3370ae32ac096dd9f20e4a0c9c911fa018a1d681 Mon Sep 17 00:00:00 2001
From: Levi Neuwirth <ln@levineuwirth.org>
Date: Mon, 6 Jul 2026 17:41:23 -0400
Subject: [PATCH 4/4] fix(gpu): resize the gutter buffer so line numbers don't
 stop at ~10
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The GPU window opens at 800x200 and the gutter buffer was sized to that
height once at construction. On resize the code buffer is re-sized but the
gutter buffer wasn't, so `shape_until_scroll` only shaped the ~10 lines
that fit the stale 200px height — line numbers stopped at 10 in a
full-height window (the code + every other buffer scaled fine).

Add `gutter_buffer.set_size(width, height)` to the resize handler,
alongside the code/status buffers. The headless path already sizes it
correctly at construction (its window size is final), so its render test
is unaffected.

Validated: fmt + clippy clean; 53 pmacs-gpu tests pass.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014TXbAwk27agwhrNNrhLi2U
---
 pmacs-gpu/src/main.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/pmacs-gpu/src/main.rs b/pmacs-gpu/src/main.rs
index 48b85cb..981df12 100644
--- a/pmacs-gpu/src/main.rs
+++ b/pmacs-gpu/src/main.rs
@@ -3758,6 +3758,14 @@ impl State {
             Some(width as f32),
             Some(STATUS_BAND_HEIGHT),
         );
+        // UX gutter: resize the line-number buffer too, else it keeps its
+        // construction-time (800x200) height and `shape_until_scroll` only
+        // shapes the ~10 lines that fit — the "numbers stop at 10" bug.
+        self.gutter_buffer.set_size(
+            &mut self.font_system,
+            Some(width as f32),
+            Some(height as f32),
+        );
         // A taller/shorter window changes the visible line count, so the
         // slice + scoped viewport change (session S1).
         self.reshape();