muxr 0.1.10 → 0.2.0

data/lib/muxr/renderer.rb

@@ -10,6 +10,8 @@ module Muxr
     BORDER_DRAWER_IDLE  = [:c256, 5].freeze   # dark magenta
     STATUS_BG           = [:c256, 236].freeze
     STATUS_FG           = [:c256, 252].freeze
+    BORDER_SYNCED       = [:c256, 160].freeze
+    SYNC_CHIP           = [:c256, 196].freeze
 
     # Vim-style mode palette. Used in two places: the focused pane border
     # (so the user can see at a glance what mode they're in) and the
@@ -27,7 +29,8 @@ module Muxr
       selection:    [:c256, 201].freeze,  # magenta
       confirm_quit:  [:c256, 196].freeze, # red
       confirm_close: [:c256, 196].freeze, # red
-      help:          [:c256, 39].freeze   # blue
+      help:          [:c256, 39].freeze,  # blue
+      pane_picker:   [:c256, 39].freeze   # blue
     }.freeze
 
     # Background applied to cells that match the active scrollback search.
@@ -54,6 +57,7 @@ module Muxr
       @prev = nil
       @prev_w = 0
       @prev_h = 0
+      @scroll_source = :ring
     end
 
     def enter_alt_screen
@@ -74,42 +78,61 @@ module Muxr
       @prev = nil
     end
 
-    def render(session, input_state: :normal, command_buffer: "", search_buffer: "", search_direction: :forward, message: nil, help: false)
+    def self.prefix_letter(prefix)
+      (prefix.ord + 0x60).chr
+    end
+
+    def render(session, input_state: :normal, scroll_source: :ring, command_buffer: "", command_completions: nil, search_buffer: "", search_direction: :forward, message: nil, help: false, picker: nil, prefix: "\x01")
+      @prefix_letter = self.class.prefix_letter(prefix)
       w = session.width
       h = session.height
       return if w < 4 || h < 3
 
       frame = Array.new(h) { Array.new(w) { Cell.new(" ", nil, nil, 0, nil) } }
 
+      @scroll_source = scroll_source
       compose_panes(frame, session, input_state: input_state)
       compose_drawer(frame, session, input_state: input_state) if session.drawer&.visible?
       compose_status_bar(
         frame, session,
         input_state: input_state,
         command_buffer: command_buffer,
+        command_completions: command_completions,
         search_buffer: search_buffer,
         search_direction: search_direction,
         message: message
       )
       compose_help(frame, session) if help
+      compose_pane_picker(frame, session, picker) if picker
 
       emit_frame(frame, session, input_state: input_state, command_buffer: command_buffer, search_buffer: search_buffer)
     end
 
     private
 
+    def content_area(session)
+      LayoutManager::Rect.new(0, 0, session.width, session.height - 1)
+    end
+
+    def layout_label(win, session)
+      return "zoom:#{win.zoom_return}" if win.respond_to?(:zoomed?) && win.zoomed?
+      return win.layout.to_s unless win.layout == :auto
+      "auto:#{LayoutManager.resolve(:auto, content_area(session))}"
+    end
+
     def compose_panes(frame, session, input_state: :normal)
       win = session.window
-      content_area = LayoutManager::Rect.new(0, 0, session.width, session.height - 1)
+      area = content_area(session)
+      layout = LayoutManager.resolve(win.layout, area)
       rects = LayoutManager.compute(
-        win.layout,
+        layout,
         win.panes.length,
-        content_area,
+        area,
         focused_index: win.focused_index,
-        master_index: win.master_index
+        **win.layout_options
       )
 
-      monocle = win.layout == :monocle
+      monocle = layout == :monocle
 
       win.panes.each_with_index do |pane, i|
         rect = rects[i]
@@ -126,14 +149,18 @@ module Muxr
         next if monocle && i != win.focused_index
 
         focused = (i == win.focused_index) && !(session.focus_drawer && session.drawer&.visible?)
-        title = "##{i + 1}"
+        title = "##{i + 1}#{attention_marker(pane)}"
         title += "/#{win.panes.length}" if monocle
         # Stable id sits after the slot number so monocle reads "#1/3 a3f9b2".
         # respond_to? guard keeps renderer tests (which use simple struct fakes)
         # from blowing up when a pane stand-in doesn't implement #id.
-        title += " #{pane.id}" if pane.respond_to?(:id) && pane.id.is_a?(String)
+        title += " #{pane_label(pane)}" if pane.respond_to?(:id) && pane.id.is_a?(String)
         title += " [P]" if pane.respond_to?(:private?) && pane.private?
+        # A borrowed pane names the session that actually owns its shell, so
+        # "who am I about to type at" is answerable without leaving the layout.
+        title += " @#{pane.origin}" if pane.respond_to?(:origin) && pane.origin
         title += " ★" if i == win.master_index
+        title += " [silence #{pane.silence_after}s]" if pane.respond_to?(:silence_after) && pane.silence_after
         # Foreground command (e.g. "npm test", "vim"). Set by the poller
         # thread; nil when the shell itself is foreground. Truncate so a
         # long invocation doesn't push the title past what draw_box will
@@ -146,7 +173,7 @@ module Muxr
           title += " [scrollback #{pane.terminal.view_offset}/#{pane.terminal.scrollback_size}]"
         end
         draw_box(frame, rect,
-                 border: focused ? mode_color(input_state) : BORDER_UNFOCUSED,
+                 border: focused ? mode_color(input_state) : unfocused_border(win),
                  bold_border: focused,
                  title: title,
                  title_focused: focused)
@@ -155,10 +182,41 @@ module Muxr
         # the same edge as the title but on the opposite side keeps both
         # readable without one crowding the other.
         draw_mode_chip(frame, rect, input_state, title) if focused
-        copy_terminal(frame, pane, rect.x + 1, rect.y + 1)
+        copy_terminal(frame, pane, rect)
       end
     end
 
+    def pane_label(pane)
+      pane.respond_to?(:name) && pane.name ? pane.name : pane.id
+    end
+
+    def unfocused_border(win)
+      synchronized?(win) ? BORDER_SYNCED : BORDER_UNFOCUSED
+    end
+
+    def synchronized?(win)
+      win.respond_to?(:synchronized) && win.synchronized
+    end
+
+    def attention_marker(pane)
+      if pane.respond_to?(:bell?) && pane.bell?
+        "!"
+      elsif pane.respond_to?(:silent?) && pane.silent?
+        "~"
+      elsif pane.respond_to?(:activity?) && pane.activity?
+        "•"
+      else
+        ""
+      end
+    end
+
+    def attention_label(win)
+      win.panes.each_with_index.filter_map do |pane, i|
+        marker = attention_marker(pane)
+        "#{i + 1}#{marker}" unless marker.empty?
+      end.join(",")
+    end
+
     def compose_drawer(frame, session, input_state: :normal)
       drawer = session.drawer
       return unless drawer&.pane
@@ -198,7 +256,7 @@ module Muxr
                title: title,
                title_focused: focused)
       draw_mode_chip(frame, rect, input_state, title) if focused
-      copy_terminal(frame, drawer.pane, rect.x + 1, rect.y + 1)
+      copy_terminal(frame, drawer.pane, rect)
     end
 
     def mode_color(input_state)
@@ -228,19 +286,20 @@ module Muxr
       case input_state
       when :normal       then "NORMAL"
       when :passthrough  then "PASS"
-      when :prefix       then "^A"
+      when :prefix       then "^#{@prefix_letter.upcase}"
       when :command      then "CMD"
-      when :scrollback   then "SCROLL"
+      when :scrollback   then @scroll_source == :app ? "SCROLL:APP" : "SCROLL"
       when :search       then "SEARCH"
       when :selection    then "SEL"
       when :confirm_quit  then "QUIT?"
       when :confirm_close then "CLOSE?"
       when :help          then "HELP"
+      when :pane_picker   then "ATTACH"
       else                    "?"
       end
     end
 
-    def compose_status_bar(frame, session, input_state:, command_buffer:, search_buffer: "", search_direction: :forward, message: nil)
+    def compose_status_bar(frame, session, input_state:, command_buffer:, command_completions: nil, search_buffer: "", search_direction: :forward, message: nil)
       y = session.height - 1
       w = session.width
       win = session.window
@@ -252,8 +311,9 @@ module Muxr
 
       left = " [#{mode_label(input_state)}]"
       left << " [#{session.name}]"
+      left << " [SYNC]" if synchronized?(win)
       left << " panes:#{win.panes.length}"
-      left << " layout:#{win.layout}"
+      left << " layout:#{layout_label(win, session)}"
       focused_label =
         if session.focus_drawer && session.drawer&.visible?
           "drawer"
@@ -263,9 +323,11 @@ module Muxr
           "##{win.focused_index + 1}"
         end
       left << " focused:#{focused_label}"
+      alerts = attention_label(win)
+      left << " alerts:#{alerts}" unless alerts.empty?
       left << " drawer:#{drawer_state} "
 
-      right = " muxr ^a ? "
+      right = " muxr ^#{@prefix_letter} ? "
 
       bar = (left + " " * w)[0, w - right.length] + right
       bar = bar[0, w]
@@ -292,16 +354,21 @@ module Muxr
         c.fg = chip_color
         c.attrs |= Terminal::BOLD
       end
+      paint_sync_chip(frame, y, bar) if synchronized?(win)
 
       if input_state == :command
-        overlay = ":#{command_buffer}"
-        overlay = overlay[0, w]
+        prompt = ":#{command_buffer}"
+        # Ambiguous Tab-completion candidates trail the prompt in a muted
+        # color, e.g. `:layout s      spiral stack`. Cosmetic — the cursor
+        # stays at the end of the buffer (see #cursor_position).
+        hint = command_completions && !command_completions.empty? ? "    #{command_completions.join(" ")}" : ""
+        overlay = (prompt + hint)[0, w]
         overlay.each_char.with_index do |ch, x|
           c = frame[y][x]
           c.char = ch
-          c.fg = [:c256, 232]
+          c.fg = x < prompt.length ? [:c256, 232] : [:c256, 240]
           c.bg = [:c256, 226]
-          c.attrs = Terminal::BOLD
+          c.attrs = x < prompt.length ? Terminal::BOLD : 0
         end
         (overlay.length...w).each do |x|
           c = frame[y][x]
@@ -311,7 +378,12 @@ module Muxr
           c.attrs = 0
         end
       elsif input_state == :scrollback
-        overlay = " SCROLLBACK  ↑↓/j/k line  d/u half  f/b page  g/G top/bot  / search  n/N next/prev  v select  q quit "
+        overlay =
+          if @scroll_source == :app
+            " APP SCROLL  ↑↓/j/k line  d/u half  f/b page  v select  Tab muxr history  q quit "
+          else
+            " SCROLLBACK  ↑↓/j/k line  d/u half  f/b page  g/G top/bot  / search  n/N next/prev  v select  Tab app scroll  q quit "
+          end
         overlay = overlay[0, w]
         overlay.each_char.with_index do |ch, x|
           c = frame[y][x]
@@ -368,18 +440,33 @@ module Muxr
           c.bg = [:c256, 156]
           c.attrs = 0
         end
-      elsif message
-        msg = " #{message} "
-        start = [w - msg.length, 0].max
-        msg.each_char.with_index do |ch, i|
-          x = start + i
-          next unless x < w
-          c = frame[y][x]
-          c.char = ch
-          c.fg = [:c256, 15]
-          c.bg = [:c256, 28]
-          c.attrs = Terminal::BOLD
-        end
+      end
+
+      draw_status_message(frame, y, w, message) if message
+    end
+
+    def paint_sync_chip(frame, y, bar)
+      start = bar.index("[SYNC]")
+      return unless start
+      (start...start + "[SYNC]".length).each do |x|
+        c = frame[y][x]
+        c.fg = [:c256, 15]
+        c.bg = SYNC_CHIP
+        c.attrs = Terminal::BOLD
+      end
+    end
+
+    def draw_status_message(frame, y, w, message)
+      msg = " #{message} "
+      start = [w - msg.length, 0].max
+      msg.each_char.with_index do |ch, i|
+        x = start + i
+        next unless x < w
+        c = frame[y][x]
+        c.char = ch
+        c.fg = [:c256, 15]
+        c.bg = [:c256, 28]
+        c.attrs = Terminal::BOLD
       end
     end
 
@@ -393,38 +480,66 @@ module Muxr
       "  c / x           new / close pane (close asks y/n)",
       "  t / w / g / m   layout: tall / wide / grid / monocle",
       "  | - f e S       layout: columns / rows / spiral / centered / stack",
+      "  F               layout: auto (spiral on a roomy screen, else stack)",
       "  Tab / Enter     cycle layout / promote to master",
+      "  < / >           shrink / grow the master area (tall, wide, centered)",
+      "  , / .           one fewer / one more master pane",
+      "  z               zoom the focused pane / restore the layout",
       "  a / 1..9        last pane / jump by number",
+      "  r               refresh / redraw (fixes a corrupted pane)",
       "  s               enter scrollback",
       "  ~ / C / P       drawer / Claude drawer / toggle private",
+      "  A               share or move a pane from another muxr session",
       "  : / ?           command prompt / toggle this help",
       "  ] / d / q       paste buffer / detach / kill session",
       "",
       "PASSTHROUGH mode (keys reach the focused pane; prefix is Ctrl-a)",
       "  C-a Esc         return to normal mode",
-      "  C-a c x t w g m same as normal-mode bindings",
+      "  C-a c / x       new / close pane (close asks y/n)",
       "  C-a Tab Enter   cycle layout / promote master",
+      "  C-a < > , .     master size / master count",
+      "  C-a z           zoom the focused pane / restore the layout",
       "  C-a n / p / a   next / prev / last pane",
+      "  C-a r           refresh / redraw (fixes a corrupted pane)",
       "  C-a [ ]         scrollback / paste buffer",
+      "  C-a A           share or move a pane from another muxr session",
       "  C-a C-a         send literal Ctrl-a to focused pane",
       "",
-      "SCROLLBACK mode (exits to the mode you came from)",
+      "SCROLLBACK mode (pane-bound: follows you as you switch panes)",
       "  j/k ↑/↓ d/u f/b g/G  scroll  C-b/C-f page  v→cursor",
+      "  Tab  switch between the app's own scroll and muxr's history",
+      "       (C-a [ starts on the app's scroll when the pane has one)",
       "  / search-fwd  ? search-back  n/N next/prev match",
+      "  C-a n/p/a/1-9   switch pane, stay in scrollback (each keeps its pos)",
+      "  i   insert here (keeps scroll pos)   q/Esc  exit to live bottom",
       "  cursor: h/j/k/l 0/^/$ w/e/b W/E/B H/M/L g/G",
-      "          v select, C-v block, y/Enter yank, q/Esc cancel",
+      "          v select, C-v block, y/Enter yank (stays in scrollback)",
+      "          q/Esc cancel   C-a n/p/a/1-9 switch pane",
       "",
-      "Commands: layout {tall|wide|columns|rows|grid|spiral|centered|stack|monocle},",
+      "COMMAND prompt (: to open;  Tab completes,  Esc/C-c cancels)",
+      "Commands: layout {tall|wide|columns|rows|grid|spiral|centered|stack|monocle|auto},",
       "          drawer {toggle|show|hide|reset},",
-      "          claude, save, restore, sessions, quit, new, close, next, prev",
+      "          claude, save, restore, sessions, attach, quit, new, close, next, prev,",
+      "          silence {<secs>|<n>m|off} (alert when the pane goes quiet),",
+      "          ratio <percent>, masters <n>, zoom,",
+      "          sync {on|off} (type into every pane at once),",
+      "          rename [name] (label the focused pane; bare clears it),",
+      "          reload (re-read ~/.muxr/config.json),",
+      "          capture [path] (save the pane's history as text)",
       "",
       "press any key to dismiss"
     ].freeze
 
+    def help_lines
+      return HELP_LINES if @prefix_letter == "a"
+      HELP_LINES.map { |line| line.gsub("C-a", "C-#{@prefix_letter}").gsub("Ctrl-a", "Ctrl-#{@prefix_letter}") }
+    end
+
     def compose_help(frame, session)
       w = session.width
       h = session.height
-      max_len = HELP_LINES.map(&:length).max
+      lines = help_lines
+      max_len = lines.map(&:length).max
       box_w = [max_len + 4, w - 4].min
       box_h = [HELP_LINES.length + 2, h - 4].min
       x = (w - box_w) / 2
@@ -442,7 +557,7 @@ module Muxr
       end
       draw_box(frame, rect, border: [:c256, 51], bold_border: true, title: "Help", title_focused: true)
 
-      HELP_LINES.first(box_h - 2).each_with_index do |line, i|
+      lines.first(box_h - 2).each_with_index do |line, i|
         line[0, box_w - 4].chars.each_with_index do |ch, j|
           c = frame[rect.y + 1 + i][rect.x + 2 + j]
           c.char = ch
@@ -453,6 +568,75 @@ module Muxr
       end
     end
 
+    PICKER_BG          = [:c256, 236].freeze
+    PICKER_FG          = [:c256, 252].freeze
+    PICKER_SESSION_FG  = [:c256, 45].freeze
+    PICKER_DIM_FG      = [:c256, 245].freeze
+    PICKER_SELECTED_BG = [:c256, 24].freeze
+    PICKER_BORDER      = [:c256, 39].freeze
+    PICKER_HINT        = "j/k select · Enter share · m move here · Esc cancel".freeze
+
+    def compose_pane_picker(frame, session, picker)
+      lines = picker_lines(picker)
+      w = session.width
+      h = session.height
+      box_w = [lines.map { |l| l[0].length }.max + 4, PICKER_HINT.length + 4, 30].max
+      box_w = [box_w, w - 4].min
+      box_h = [lines.length + 4, h - 4].min
+      rect = LayoutManager::Rect.new((w - box_w) / 2, (h - box_h) / 2, box_w, box_h)
+
+      (rect.y...(rect.y + rect.h)).each do |yy|
+        (rect.x...(rect.x + rect.w)).each do |xx|
+          set_cell(frame, yy, xx, " ", fg: PICKER_FG, bg: PICKER_BG)
+        end
+      end
+      draw_box(frame, rect, border: PICKER_BORDER, bold_border: true,
+               title: "Attach pane", title_focused: true)
+
+      inner_w = box_w - 4
+      visible = picker_window(lines, picker.index, box_h - 4)
+      visible.each_with_index do |(text, fg, selected), i|
+        bg = selected ? PICKER_SELECTED_BG : PICKER_BG
+        row = text[0, inner_w].ljust(inner_w)
+        row.chars.each_with_index do |ch, j|
+          set_cell(frame, rect.y + 1 + i, rect.x + 2 + j, ch,
+                   fg: fg, bg: bg, attrs: selected ? Terminal::BOLD : 0)
+        end
+      end
+
+      hint_y = rect.y + rect.h - 2
+      PICKER_HINT[0, inner_w].chars.each_with_index do |ch, j|
+        set_cell(frame, hint_y, rect.x + 2 + j, ch, fg: PICKER_DIM_FG, bg: PICKER_BG)
+      end
+    end
+
+    def picker_lines(picker)
+      picker.rows.each_with_index.map do |row, i|
+        selected = i == picker.index
+        if row.selectable?
+          entry = row.entry
+          text = "  ##{entry.slot} #{entry.name || entry.pane_id}"
+          text += "  #{shorten_path(entry.cwd)}" if entry.cwd
+          [text, PICKER_FG, selected]
+        else
+          ["#{row.session}", PICKER_SESSION_FG, false]
+        end
+      end
+    end
+
+    # Scroll the list so the selected row stays on screen without moving more
+    # than it has to — the cursor sits still until it reaches an edge.
+    def picker_window(lines, index, height)
+      return lines if height <= 0 || lines.length <= height
+      start = (index - height / 2).clamp(0, lines.length - height)
+      lines[start, height]
+    end
+
+    def shorten_path(path)
+      home = Dir.home
+      path.to_s.start_with?(home) ? path.to_s.sub(home, "~") : path.to_s
+    end
+
     def draw_box(frame, rect, border:, bold_border:, title: nil, title_focused: false)
       attrs = bold_border ? Terminal::BOLD : 0
       x2 = rect.x + rect.w - 1
@@ -479,10 +663,16 @@ module Muxr
       end
     end
 
-    def copy_terminal(frame, pane, dst_x, dst_y)
+    # Paint a pane's grid into the inside of its box. Clipped to the box, not
+    # just to the frame: a mirrored pane's grid is sized by the session that
+    # owns it, so it can be a row or column out of step with the box we drew
+    # for it here, and overrunning would eat the border.
+    def copy_terminal(frame, pane, rect)
       term = pane.terminal
-      rows = term.rows
-      cols = term.cols
+      dst_x = rect.x + 1
+      dst_y = rect.y + 1
+      rows = [term.rows, rect.h - 2].min
+      cols = [term.cols, rect.w - 2].min
       selection = term.selection_active?
       search = term.search_active?
       rows.times do |r|
@@ -539,10 +729,23 @@ module Muxr
       last_x = nil
 
       frame.each_with_index do |row, y|
+        # When the previous glyph on this row had an uncertain display width
+        # (set below), the outer terminal may have drawn it two columns wide and
+        # stolen the column to its right. Force that next cell to repaint even
+        # if our model says it's unchanged, so a phantom second half can't
+        # linger until a full repaint. Reset per row — a steal can't cross a
+        # line boundary.
+        force_next = false
         row.each_with_index do |cell, x|
-          if same_size && @prev[y][x] == cell
+          if same_size && @prev[y][x] == cell && !force_next
             next
           end
+          force_next = false
+          # The right half of a wide glyph (char "") is painted by its lead
+          # cell to the left, which spans both columns in the outer terminal.
+          # Emitting anything here would clobber that glyph, so skip it — and
+          # leave last_x untouched, since we didn't move the outer cursor.
+          next if cell.char.empty?
           if last_y != y || last_x != x
             out << "\e[#{y + 1};#{x + 1}H"
           end
@@ -559,7 +762,28 @@ module Muxr
           end
           out << cell.char
           last_y = y
-          last_x = x + cell.char.length
+          if contiguous_after?(cell.char)
+            # Advance by the glyph's display width, not its codepoint count: a
+            # wide char ("中") moves the outer cursor two columns though it's
+            # one codepoint, and a base+combining cell ("é") moves one though
+            # it's two. Keeping last_x in sync with the real cursor lets the
+            # next cell skip a redundant CUP.
+            last_x = x + Terminal.char_width(cell.char.ord)
+          else
+            # The outer terminal might advance its cursor by a different number
+            # of columns than we think for this glyph — force an absolute
+            # reposition for the next cell so the disagreement can't cascade.
+            last_x = nil
+            # For a glyph WE model as a single column but whose real width the
+            # outer terminal may stretch to two (East Asian Ambiguous symbols
+            # like ·, …, ●, and the ⏺/✻/❯ glyphs Claude Code animates in place),
+            # also force the next cell to repaint. Otherwise an in-place spinner
+            # leaves its unchanged neighbour skipped by the diff, and the glyph's
+            # phantom second half sits on that column until a manual refresh.
+            # Width-2 glyphs (CJK/emoji) own their continuation cell already, so
+            # they don't need this — only the model-1/draw-2 mismatch does.
+            force_next = true if Terminal.char_width(cell.char.ord) == 1
+          end
         end
       end
       out << "\e]8;;\e\\" if cur_hyperlink
@@ -573,7 +797,28 @@ module Muxr
       @prev_h = frame.length
     end
 
+    # Whether we can trust the outer terminal's cursor to be exactly one
+    # display-width past this glyph, so the next contiguous cell needs no
+    # cursor-position escape. Safe for ASCII (always one column), and for the
+    # box-drawing / block-element band 0x2500–0x259F unless the width probe
+    # measured this terminal drawing that band wide — we emit a lot of those for
+    # borders, so keeping them contiguous matters when it's sound. Everything
+    # else non-ASCII —
+    # CJK, emoji, and East Asian Ambiguous symbols like ·, …, ●, arrows, and
+    # the ⏺/✻/❯ glyphs Claude Code's UI is full of — can be drawn two columns
+    # wide by some terminals. We can't know which, so we force an absolute
+    # reposition after them: a width disagreement then clips a single glyph
+    # instead of shifting the whole rest of the line. A base+combining cell
+    # (multi-codepoint) is treated the same way out of caution.
+    def contiguous_after?(char)
+      return false if char.length > 1
+      cp = char.ord
+      return true if cp < 0x80
+      !Terminal.box_wide && Terminal::BOX_RANGES.any? { |r| r.cover?(cp) }
+    end
+
     def cursor_position(session, input_state:, command_buffer:, search_buffer: "")
+      return "\e[?25l" if input_state == :pane_picker
       if input_state == :command
         col = 1 + command_buffer.length + 1 # ':' + buffer
         return "\e[#{session.height};#{col}H\e[?25h"
@@ -601,40 +846,18 @@ module Muxr
         return "\e[#{row};#{col}H\e[?25h"
       end
       return "\e[?25l" if term.scrolled_back?
+      # Honor the inner program's own cursor visibility (DECTCEM): Claude Code
+      # and other Ink UIs hide the cursor while rendering and only show it at a
+      # text prompt. Painting our block at its last write position otherwise
+      # leaves a phantom cursor smeared across the animating UI.
+      return "\e[?25l" unless term.cursor_visible?
       row = rect.y + 1 + term.cursor_row + 1
       col = rect.x + 1 + term.cursor_col + 1
       "\e[#{row};#{col}H\e[?25h"
     end
 
     def sgr(cell)
-      parts = ["0"]
-      attrs = cell.attrs.to_i
-      parts << "1" if (attrs & Terminal::BOLD) != 0
-      parts << "2" if (attrs & Terminal::DIM) != 0
-      parts << "4" if (attrs & Terminal::UNDERLINE) != 0
-      parts << "7" if (attrs & Terminal::REVERSE) != 0
-      append_color(parts, cell.fg, true)
-      append_color(parts, cell.bg, false)
-      "\e[#{parts.join(';')}m"
-    end
-
-    def append_color(parts, color, fg)
-      return if color.nil?
-      case color
-      when Integer
-        if color < 8
-          parts << ((fg ? 30 : 40) + color).to_s
-        else
-          parts << ((fg ? 90 : 100) + (color - 8)).to_s
-        end
-      when Array
-        case color[0]
-        when :c256
-          parts << "#{fg ? 38 : 48};5;#{color[1]}"
-        when :rgb
-          parts << "#{fg ? 38 : 48};2;#{color[1]};#{color[2]};#{color[3]}"
-        end
-      end
+      Terminal.sgr(cell)
     end
   end
 end

data/lib/muxr/session.rb

@@ -41,11 +41,13 @@ module Muxr
         "name"           => @name,
         "width"          => @width,
         "height"         => @height,
-        "layout"         => @window.layout.to_s,
+        "layout"         => @window.resting_layout.to_s,
         "focused_index"  => @window.focused_index,
         "master_index"   => @window.master_index,
+        "master_ratio"   => @window.master_ratio,
+        "master_count"   => @window.master_count,
         "focus_drawer"   => @focus_drawer,
-        "panes"          => @window.panes.map { |p| { "id" => safe_id(p), "cwd" => safe_cwd(p), "private" => safe_private(p) } },
+        "panes"          => own_panes.map { |p| serialize_pane(p) },
         "drawer"         => serialize_drawer
       }
     end
@@ -72,6 +74,21 @@ module Muxr
 
     private
 
+    # Panes borrowed from another session are that session's to restore, not
+    # ours: persisting one here would cold-start a second shell in its cwd and
+    # quietly fork the thing the user was sharing.
+    def own_panes
+      @window.panes.reject { |p| p.respond_to?(:mirror?) && p.mirror? }
+    end
+
+    def serialize_pane(pane)
+      entry = { "id" => safe_id(pane), "cwd" => safe_cwd(pane), "private" => safe_private(pane) }
+      silence = pane.respond_to?(:silence_after) ? pane.silence_after : nil
+      entry["silence"] = silence if silence
+      entry["name"] = pane.name if pane.respond_to?(:name) && pane.name
+      entry
+    end
+
     def safe_cwd(pane)
       pane.respond_to?(:cwd) ? pane.cwd : nil
     end