muxr 0.1.10 → 0.2.0

data/lib/muxr/application.rb

@@ -1,5 +1,11 @@
 require "socket"
 require "fileutils"
+require "securerandom"
+require "muxr/remote_pane"
+require "muxr/pane_transfer"
+require "muxr/pane_picker"
+require "muxr/session_directory"
+require "muxr/config"
 
 module Muxr
   # The Application is the muxr server. It owns the Session, panes, Renderer,
@@ -22,26 +28,40 @@ module Muxr
     # showing through.
     MIN_FRAME_INTERVAL = 1.0 / 60
     SOCKETS_DIR    = File.join(Dir.home, ".muxr", "sockets").freeze
+    CAPTURES_DIR   = File.join(Dir.home, ".muxr", "captures").freeze
     DEFAULT_WIDTH  = 80
     DEFAULT_HEIGHT = 24
 
-    attr_reader :session, :renderer, :input, :session_name, :control_server
+    attr_reader :session, :renderer, :input, :session_name, :control_server, :pane_picker
 
     def self.socket_path_for(name)
       File.join(SOCKETS_DIR, "#{name}.sock")
     end
 
+    # The name a bare `muxr` (no name argument) resolves to: a slug of the
+    # current working directory, so re-running `muxr` in the same directory
+    # reattaches the same session. The name is interpolated straight into
+    # <name>.sock / <name>.json / <name>.log filenames, so the path's slashes
+    # (and any other filesystem-unfriendly bytes) are folded to "-"; the
+    # leading "-" from the root slash is trimmed for readability in --list.
+    def self.default_session_name(dir = Dir.pwd)
+      slug = dir.gsub(%r{/}, "-").gsub(/[^A-Za-z0-9._-]/, "-").sub(/\A-+/, "")
+      slug.empty? ? "default" : slug
+    end
+
     def self.control_socket_path_for(name)
       File.join(SOCKETS_DIR, "#{name}.ctrl.sock")
     end
 
     # Names of sessions whose server socket is currently accepting connections.
     # Stale sockets (file exists, no listener) are skipped but left in place;
-    # cleanup happens on the next attach attempt.
+    # cleanup happens on the next attach attempt. The sibling control socket
+    # lives in the same directory under <name>.ctrl.sock and is not a session.
     def self.list_active
       return [] unless File.directory?(SOCKETS_DIR)
       Dir.children(SOCKETS_DIR).filter_map do |entry|
         next unless entry.end_with?(".sock")
+        next if entry.end_with?(".ctrl.sock")
         path = File.join(SOCKETS_DIR, entry)
         next unless alive_socket?(path)
         File.basename(entry, ".sock")
@@ -64,15 +84,40 @@ module Muxr
       @message = nil
       @message_expires = nil
       @help_visible = false
+      @pane_picker = nil
       @current_client = nil
       @client_write_buffer = +"".b
       @listening_socket = nil
+      # The directory bin/muxr was launched from — Process.daemon(true, ...)
+      # preserves it across daemonization. Every new pane (and the drawer)
+      # starts here, treating it as the session's project root regardless of
+      # where the focused pane's shell has wandered.
+      @origin_cwd = Dir.pwd
       @socket_path = self.class.socket_path_for(@session_name)
       @control_socket_path = self.class.control_socket_path_for(@session_name)
       @control_server = nil
       @paste_buffer = +""
+      # Trailing bytes of an in-flight INPUT chunk that look like the start of
+      # a bracketed-paste marker but were cut off by the 4 KiB read boundary.
+      # Held back and prepended to the next chunk so a split marker still gets
+      # recognized — see #strip_bracketed_paste_markers.
+      @paste_marker_tail = +"".b
       @last_render_at = nil
       @foreground_poller = nil
+      # Opt-in diagnostic tap. When MUXR_TRACE_OUTPUT names a writable path, the
+      # server appends every byte it sends to the client — i.e. exactly what the
+      # outer terminal receives. Replaying it (`cat` it into a fresh terminal, or
+      # feed it to a reference emulator) reproduces a rendering bug from the byte
+      # stream alone, which tells us whether corruption is in muxr's emitted
+      # output or somewhere downstream. Off unless the env var is set.
+      @trace_output = open_trace(ENV["MUXR_TRACE_OUTPUT"])
+    end
+
+    def open_trace(path)
+      return nil if path.nil? || path.empty?
+      File.open(path, "ab")
+    rescue SystemCallError
+      nil
     end
 
     # Interval for the background thread that refreshes each pane's
@@ -94,13 +139,117 @@ module Muxr
 
     # ---------- public action API (called from InputHandler / CommandDispatcher) ----------
 
+    # Bytes the outer terminal wraps around a paste once bracketed-paste mode
+    # is on (the client enables it unconditionally — see
+    # Client#enter_terminal_mode).
+    BRACKETED_PASTE_MARKERS = ["\e[200~".b, "\e[201~".b].freeze
+
     def send_to_focused(data)
       target = focused_target
-      target&.write(data)
+      return unless target
+      data = strip_bracketed_paste_markers(data, target)
+      input_targets.each { |pane| pane.write(data) } unless data.empty?
+    end
+
+    def input_targets
+      target = focused_target
+      return [] unless target
+      return [target] unless broadcasting?
+      @session.window.panes.select { |pane| pane.alive? && !handing_off?(pane) }
+    end
+
+    def broadcasting?
+      @session.window.synchronized && !(@session.focus_drawer && @session.drawer&.visible?)
+    end
+
+    def capture_focused(path = nil)
+      target = focused_target
+      return unless target
+      destination = capture_path(target, path)
+      text = target.terminal.dump_history_text
+      FileUtils.mkdir_p(File.dirname(destination))
+      File.write(destination, text)
+      flash("captured #{text.count("\n")} lines to #{shorten_home(destination)}")
+      destination
+    rescue SystemCallError => e
+      flash("capture failed: #{e.message}")
+      nil
+    end
+
+    def capture_path(target, path)
+      return File.expand_path(path, @origin_cwd) if path && !path.empty?
+      label = target.respond_to?(:label) ? target.label : target.id.to_s
+      stamp = Time.now.strftime("%Y%m%d-%H%M%S")
+      File.join(CAPTURES_DIR, "#{@session_name}-#{label}-#{stamp}.txt".gsub(/[^A-Za-z0-9._-]/, "-"))
+    end
+
+    def rename_focused(name)
+      pane = focused_pane
+      return unless pane
+      pane.name = name
+      flash(pane.name ? "pane ##{@session.window.focused_index + 1} is now #{pane.name}" : "pane ##{@session.window.focused_index + 1} name cleared")
+      invalidate
+    end
+
+    def set_sync(arg)
+      win = @session.window
+      case arg
+      when nil then win.synchronized = !win.synchronized
+      when "on" then win.synchronized = true
+      when "off" then win.synchronized = false
+      else return flash("sync: expected on or off")
+      end
+      flash(win.synchronized ? "sync on: typing reaches all #{win.panes.length} panes" : "sync off")
+      invalidate
+    end
+
+    # The client turns bracketed-paste mode on for the *outer* terminal so big
+    # pastes arrive wrapped in \e[200~…\e[201~ (which lets shells/editors that
+    # speak the protocol collapse them). But the focused program may not speak
+    # it — in that case the markers would print as a literal "^[[200~" before
+    # and after the text. So: forward the markers untouched when the focused
+    # program enabled DECSET 2004, strip them otherwise.
+    #
+    # A marker can straddle a 4 KiB read boundary, so any trailing bytes that
+    # form a partial marker (but not a bare ESC, which must reach the program
+    # immediately as the Escape key) are held back and prepended next chunk.
+    def strip_bracketed_paste_markers(data, target)
+      data = data.b
+      term = target.respond_to?(:terminal) ? target.terminal : nil
+      buf = @paste_marker_tail + data
+      @paste_marker_tail = +"".b
+
+      if term&.bracketed_paste?
+        # Program wants the markers — hand back everything, partial included.
+        return buf
+      end
+
+      hold = pending_marker_prefix(buf)
+      if hold.positive?
+        @paste_marker_tail = buf.byteslice(buf.bytesize - hold, hold)
+        buf = buf.byteslice(0, buf.bytesize - hold) || +"".b
+      end
+      BRACKETED_PASTE_MARKERS.each { |m| buf = buf.gsub(m, "") }
+      buf
+    end
+
+    # Length (2..5) of the longest suffix of `buf` that is a proper prefix of a
+    # bracketed-paste marker, so the remainder can arrive in the next chunk. A
+    # bare trailing ESC (length 1) is deliberately not held: it's almost always
+    # the Escape key and the program must see it without waiting on the next
+    # keystroke. Worst case a marker split right after its ESC leaks a few
+    # bytes, which the program reads as a harmless unknown escape.
+    def pending_marker_prefix(buf)
+      max = [buf.bytesize, 5].min
+      max.downto(2) do |k|
+        tail = buf.byteslice(buf.bytesize - k, k)
+        return k if BRACKETED_PASTE_MARKERS.any? { |m| m.byteslice(0, k) == tail }
+      end
+      0
     end
 
     def new_pane(cwd: nil)
-      cwd ||= focused_pane&.cwd
+      cwd ||= @origin_cwd
       pane = make_pane(cwd: cwd)
       @session.window.add_pane(pane)
       @session.focus_drawer = false
@@ -116,6 +265,7 @@ module Muxr
       else
         @session.window.focus_next
       end
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -126,6 +276,7 @@ module Muxr
       else
         @session.window.focus_prev
       end
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -136,6 +287,7 @@ module Muxr
       else
         @session.window.focus_last
       end
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -145,9 +297,27 @@ module Muxr
       return unless idx >= 0 && idx < @session.window.panes.length
       @session.focus_drawer = false
       @session.window.focus_index(idx)
+      sync_input_mode_to_focus
       invalidate
     end
 
+    # After a focus change, reconcile the input mode with the newly-focused
+    # pane: if it was left scrolled back, re-enter scrollback so the user
+    # lands exactly where they were reading ("navigating back to the scrolled
+    # pane puts you back into scrollback"). We only ever auto-ENTER here —
+    # the InputHandler's @prefix_return is what keeps you in scrollback when
+    # you hop onto a live pane, so we never auto-leave.
+    def sync_input_mode_to_focus
+      target = focused_target
+      return unless target
+      if target.terminal.scrolled_back?
+        @input.enter_scrollback_mode(source: :ring)
+        @renderer.reset_frame!
+      elsif @input.state == :scrollback
+        @input.enter_scrollback_mode(source: default_scroll_source(target))
+      end
+    end
+
     # Move focus to the pane spatially adjacent in `direction` (:left/:right/
     # :up/:down). Called by the normal-mode hjkl bindings. Pulling the live
     # layout rects keeps this in sync with whatever the renderer is showing.
@@ -168,12 +338,14 @@ module Muxr
         when :right, :down then win.focus_next
         when :left, :up    then win.focus_prev
         end
+        sync_input_mode_to_focus
         invalidate
         return
       end
 
       return unless idx
       win.focus_index(idx)
+      sync_input_mode_to_focus
       invalidate
     end
 
@@ -222,7 +394,7 @@ module Muxr
     # Ctrl-a-prefixed multiplexer mode.
     def enter_passthrough_mode
       @input.enter_passthrough_mode
-      flash("passthrough mode (^a esc to return)")
+      flash("passthrough mode (^#{Renderer.prefix_letter(@input.prefix)} esc to return)")
       invalidate
     end
 
@@ -269,17 +441,86 @@ module Muxr
       invalidate
     end
 
+    def toggle_zoom
+      win = @session.window
+      return flash("already in monocle") if win.layout == :monocle && !win.zoomed?
+      win.toggle_zoom
+      flash(win.zoomed? ? "zoomed (z to restore #{win.zoom_return})" : "layout: #{win.layout}")
+      @renderer.reset_frame!
+      invalidate
+    end
+
     def cycle_layout
       @session.window.cycle_layout
       flash("layout: #{@session.window.layout}")
       invalidate
     end
 
+    # Bound to `r` (normal) / `Ctrl-a r` (passthrough). Two-layer repaint to
+    # recover from a corrupted display, whichever layer drifted:
+    #   1. Nudge the focused program to redraw itself (SIGWINCH wiggle). This
+    #      fixes muxr's own Terminal grid when an unhandled or wide glyph
+    #      desynced the cursor — reset_frame! alone can't, since it would just
+    #      faithfully re-emit the wrong grid.
+    #   2. Force a full re-emit of our composed frame to the outer terminal,
+    #      fixing the case where the outer display lost/garbled bytes but our
+    #      grid is correct.
+    def refresh_focused
+      target = focused_target
+      target.request_redraw if target.respond_to?(:request_redraw)
+      @renderer.reset_frame!
+      flash("refreshed")
+      invalidate
+    end
+
     def promote_master
       @session.window.promote_to_master
       invalidate
     end
 
+    def grow_master
+      resize_master(Window::RATIO_STEP)
+    end
+
+    def shrink_master
+      resize_master(-Window::RATIO_STEP)
+    end
+
+    def resize_master(delta)
+      @session.window.adjust_master_ratio(delta)
+      flash_master_shape
+    end
+
+    def add_master
+      @session.window.adjust_master_count(1)
+      flash_master_shape
+    end
+
+    def remove_master
+      @session.window.adjust_master_count(-1)
+      flash_master_shape
+    end
+
+    def set_master_ratio(arg)
+      value = Float(arg.to_s.delete_suffix("%"), exception: false)
+      return flash("ratio: expected a percentage like 60") unless value&.positive?
+      @session.window.master_ratio = value > 1 ? value / 100.0 : value
+      flash_master_shape
+    end
+
+    def set_master_count(arg)
+      value = Integer(arg.to_s, exception: false)
+      return flash("masters: expected a number like 2") unless value&.positive?
+      @session.window.master_count = value
+      flash_master_shape
+    end
+
+    def flash_master_shape
+      win = @session.window
+      flash("master #{(win.master_ratio * 100).round}% · masters #{win.master_count}")
+      invalidate
+    end
+
     # Toggle the privacy flag on the focused pane. Private panes are
     # redacted from the MCP control surface (panes.list strips cwd; read /
     # send_input / run / subscribe / kill all refuse). Only the human can
@@ -371,6 +612,103 @@ module Muxr
       invalidate
     end
 
+    # Open the attach overlay: every pane every other live muxr server is
+    # willing to share, grouped by session. Building the list means a short
+    # blocking round-trip to each server's control socket, which is fine for a
+    # deliberate keypress and bounded by SessionDirectory::QUERY_TIMEOUT.
+    def open_pane_picker
+      entries = SessionDirectory.panes(exclude: @session_name)
+      if entries.empty?
+        flash("no panes to attach (no other muxr sessions running)")
+        return
+      end
+      @pane_picker = PanePicker.new(entries)
+      @input.enter_pane_picker_mode
+      invalidate
+    end
+
+    def move_pane_picker(delta)
+      @pane_picker&.move(delta)
+      invalidate
+    end
+
+    def cancel_pane_picker
+      @pane_picker = nil
+      @renderer.reset_frame!
+      invalidate
+    end
+
+    def confirm_pane_picker(move: false)
+      entry = @pane_picker&.selected
+      cancel_pane_picker
+      return unless entry
+      move ? move_remote_pane(entry) : attach_remote_pane(entry)
+    end
+
+    # Take the pane away from its session rather than sharing it. The pty fd
+    # itself crosses over, so the shell and everything running under it carry
+    # on uninterrupted — it just answers to this session now, and disappears
+    # from the one it came from.
+    def move_remote_pane(entry)
+      result = PaneTransfer.claim(socket_path: entry.socket_path, pane_id: entry.pane_id)
+      pane = result.pane
+      pane.foreground_command = nil
+      @session.window.add_pane(pane)
+      @session.focus_drawer = false
+      @session.window.focused_index = @session.window.panes.length - 1
+      @renderer.reset_frame!
+      flash("moved #{result.session}:#{pane.id} here")
+      invalidate
+      pane
+    rescue PaneTransfer::Error => e
+      flash("move failed: #{e.message}")
+      nil
+    end
+
+    # Mount another session's pane here as a live mirror. The pane keeps
+    # running where it is — both sessions see the same shell, and either can
+    # type into it. Closing it here (or quitting) only drops the mirror; losing
+    # the owning server is what makes the pane go away, and prune_dead_panes
+    # takes care of that.
+    def attach_remote_pane(entry)
+      remote = RemotePane.connect(
+        socket_path: entry.socket_path,
+        pane_id: entry.pane_id,
+        rows: mirror_viewport[0],
+        cols: mirror_viewport[1]
+      )
+      pane = Pane.new(rows: remote.rows, cols: remote.cols, process: remote)
+      remote.bind(pane.terminal)
+      pane.origin = remote.origin
+      pane.name = entry.name if entry.respond_to?(:name)
+      @session.window.add_pane(pane)
+      @session.focus_drawer = false
+      @session.window.focused_index = @session.window.panes.length - 1
+      @renderer.reset_frame!
+      flash("attached #{remote.origin}")
+      invalidate
+      pane
+    rescue RemotePane::Error => e
+      flash("attach failed: #{e.message}")
+      nil
+    end
+
+    # Size to ask the owner for before the Renderer has laid the new pane out.
+    # One more pane in the current layout is the honest guess, and the very next
+    # frame corrects it through Pane#resize.
+    def mirror_viewport
+      rects = LayoutManager.compute(
+        @session.window.layout,
+        @session.window.panes.length + 1,
+        LayoutManager::Rect.new(0, 0, @session.width, @session.height - 1),
+        focused_index: @session.window.panes.length,
+        **@session.window.layout_options
+      )
+      rect = rects.last
+      return [DEFAULT_HEIGHT, DEFAULT_WIDTH] unless rect
+      [[rect.h - 2, 1].max, [rect.w - 2, 1].max]
+    end
+
     def show_help
       @help_visible = true
       @input.enter_help_mode
@@ -385,13 +723,47 @@ module Muxr
     def enter_scrollback
       target = focused_target
       return unless target
-      @input.enter_scrollback_mode
+      @input.enter_scrollback_mode(source: default_scroll_source(target))
+      @renderer.reset_frame!
+      invalidate
+    end
+
+    def app_scroll_available?(target)
+      term = target&.terminal
+      return false unless term
+      term.mouse_tracking? || term.alt_screen?
+    end
+
+    def default_scroll_source(target)
+      app_scroll_available?(target) ? :app : :ring
+    end
+
+    def toggle_scroll_source
+      target = focused_target
+      return unless target
+      if @input.scroll_source == :app
+        if target.terminal.alt_screen?
+          flash("no history while a full-screen app is running")
+          return
+        end
+        @input.enter_scrollback_mode(source: :ring)
+        flash("scrolling muxr history")
+      else
+        unless app_scroll_available?(target)
+          flash("this pane has no scroll of its own")
+          return
+        end
+        target.terminal.scroll_to_bottom
+        @input.enter_scrollback_mode(source: :app)
+        flash("scrolling the app")
+      end
       @renderer.reset_frame!
       invalidate
     end
 
     def exit_scrollback
       target = focused_target
+      target&.terminal&.confine_selection_to_screen!(false)
       target&.terminal&.clear_selection
       target&.terminal&.clear_search
       target&.terminal&.scroll_to_bottom
@@ -403,6 +775,10 @@ module Muxr
     # the user into a buffered prompt; commit_search / cancel_search exit
     # back to scrollback.
     def enter_search(direction: :forward)
+      if @input.scroll_source == :app
+        flash("search reads muxr history — Tab to switch")
+        return
+      end
       @input.enter_search_mode(direction: direction)
       invalidate
     end
@@ -441,6 +817,10 @@ module Muxr
     def step_search(direction)
       target = focused_target
       return unless target
+      if @input.scroll_source == :app
+        flash("search reads muxr history — Tab to switch")
+        return
+      end
       term = target.terminal
       if term.search_matches.empty?
         flash("no search active")
@@ -450,9 +830,12 @@ module Muxr
       invalidate
     end
 
+    WHEEL_BURST_MAX = 200
+
     def scroll_focused(action)
       target = focused_target
       return unless target
+      return scroll_app(target, action) if @input.scroll_source == :app
       term = target.terminal
       rows = term.rows
       case action
@@ -468,6 +851,48 @@ module Muxr
       invalidate
     end
 
+    def scroll_app(target, action)
+      term = target.terminal
+      rows = term.rows
+      direction, count =
+        case action
+        when :line_back    then [:up, 1]
+        when :line_forward then [:down, 1]
+        when :half_back    then [:up, [rows / 2, 1].max]
+        when :half_forward then [:down, [rows / 2, 1].max]
+        when :full_back    then [:up, [rows - 1, 1].max]
+        when :full_forward then [:down, [rows - 1, 1].max]
+        end
+      unless direction
+        flash("only the app knows where its history starts")
+        return
+      end
+      target.write(app_scroll_bytes(term, direction, count))
+      invalidate
+    end
+
+    def app_scroll_bytes(term, direction, count)
+      count = count.clamp(1, WHEEL_BURST_MAX)
+      if term.mouse_tracking?
+        MouseReport.wheel(
+          direction,
+          row: [term.rows / 2 + 1, 1].max,
+          col: [term.cols / 2 + 1, 1].max,
+          encoding: term.mouse_encoding
+        ) * count
+      else
+        arrow_key(term, direction) * count
+      end
+    end
+
+    def arrow_key(term, direction)
+      if term.app_cursor_keys?
+        direction == :up ? "\eOA".b : "\eOB".b
+      else
+        direction == :up ? "\e[A".b : "\e[B".b
+      end
+    end
+
     def enter_selection
       target = focused_target
       return unless target
@@ -476,6 +901,7 @@ module Muxr
       # anchor. Start at the live cursor's visible position so the user lands
       # where their attention already is, instead of the top-left corner.
       term = target.terminal
+      term.confine_selection_to_screen!(@input.scroll_source == :app)
       term.place_selection_cursor(term.cursor_row, term.cursor_col)
       @input.enter_selection_mode
       @renderer.reset_frame!
@@ -502,7 +928,6 @@ module Muxr
     def exit_selection(yank:)
       target = focused_target
       term = target&.terminal
-      yanked = false
       if yank
         # No anchor → no-op. User is still positioning; they can press v
         # first, then yank. Esc/q is the way to exit from navigation.
@@ -512,18 +937,14 @@ module Muxr
           @paste_buffer = text
           spawn_pbcopy(text)
           flash("yanked #{text.bytesize} bytes")
-          yanked = true
         end
       end
       term&.clear_selection
-      if yanked
-        # vim-style: yanking drops you straight back to "normal" (idle),
-        # not back into scrollback navigation.
-        term&.scroll_to_bottom
-        @input.enter_idle_mode
-      else
-        @input.enter_scrollback_mode
-      end
+      # Drop back into scrollback at the current position whether or not we
+      # yanked. We no longer snap to the live bottom on yank — the user stays
+      # where they were reading so they can keep selecting or scrolling, and
+      # `q`/Esc is still there when they want to return to the bottom.
+      @input.enter_scrollback_mode
       @renderer.reset_frame!
       invalidate
     end
@@ -561,10 +982,33 @@ module Muxr
       invalidate
     end
 
+    SILENCE_ARG = /\A(\d+)(s|m)?\z/
+
+    def monitor_silence(arg)
+      pane = focused_pane
+      return unless pane
+      if arg.nil?
+        flash(pane.silence_after ? "silence: #{format_seconds(pane.silence_after)}" : "silence: off")
+      elsif arg == "off"
+        pane.watch_silence(nil)
+        flash("silence monitor off")
+      elsif (m = SILENCE_ARG.match(arg)) && m[1].to_i.positive?
+        seconds = m[1].to_i * (m[2] == "m" ? 60 : 1)
+        pane.watch_silence(seconds)
+        flash("alert when pane ##{@session.window.focused_index + 1} is silent for #{format_seconds(seconds)}")
+      else
+        flash("silence: expected seconds (30, 30s, 2m) or off")
+      end
+      invalidate
+    end
+
+    def format_seconds(seconds)
+      seconds % 60 == 0 && seconds >= 60 ? "#{seconds / 60}m" : "#{seconds}s"
+    end
+
     def paste_from_buffer
       return if @paste_buffer.nil? || @paste_buffer.empty?
-      target = focused_target
-      target&.write(@paste_buffer)
+      input_targets.each { |pane| pane.write(@paste_buffer) }
     end
 
     def flash(msg)
@@ -577,6 +1021,43 @@ module Muxr
       @needs_render = true
     end
 
+    def reload_config
+      config = Config.load
+      apply_config(config)
+      if config.errors.empty?
+        flash("reloaded #{shorten_home(config.path)}")
+      else
+        report_config_problems
+      end
+    end
+
+    def apply_config(config)
+      @config = config
+      config.errors.each { |e| warn("muxr: #{config.path}: #{e}") }
+      @input.configure(config)
+      Terminal.scrollback_max = config.scrollback if config.scrollback && !ENV["MUXR_SCROLLBACK"]
+      LayoutManager.auto_spiral_min_cols = config.auto_spiral_min_cols
+      LayoutManager.auto_spiral_min_rows = config.auto_spiral_min_rows
+      invalidate
+    end
+
+    def apply_window_defaults
+      win = @session.window
+      win.set_layout(@config.layout) if @config.layout
+      win.master_ratio = @config.master_ratio if @config.master_ratio
+      win.master_count = @config.master_count if @config.master_count
+    end
+
+    def report_config_problems
+      return if @config.nil? || @config.errors.empty?
+      count = @config.errors.length
+      flash("config: #{@config.errors.first}#{count > 1 ? " (+#{count - 1} more in the log)" : ""}")
+    end
+
+    def shorten_home(path)
+      path.to_s.start_with?(Dir.home) ? path.to_s.sub(Dir.home, "~") : path.to_s
+    end
+
     def save_session
       path = @session.save
       flash("saved: #{path}")
@@ -592,7 +1073,7 @@ module Muxr
     end
 
     def list_sessions
-      names = Session.list
+      names = (Session.list | self.class.list_active).sort
       if names.empty?
         flash("no saved sessions")
       else
@@ -610,6 +1091,9 @@ module Muxr
     # the server is also trying to read from that same client.
     def deliver_output(bytes)
       return unless @current_client
+      if @trace_output
+        @trace_output.write(bytes) rescue nil
+      end
       @client_write_buffer << Protocol.frame(Protocol::OUTPUT, bytes)
       drain_client_writes
     end
@@ -645,7 +1129,7 @@ module Muxr
       if idx && argv[idx + 1]
         argv[idx + 1]
       else
-        argv.find { |a| !a.start_with?("-") } || "default"
+        argv.find { |a| !a.start_with?("-") } || self.class.default_session_name
       end
     end
 
@@ -667,7 +1151,7 @@ module Muxr
         win.panes.length,
         area,
         focused_index: win.focused_index,
-        master_index: win.master_index
+        **win.layout_options
       )
     end
 
@@ -694,6 +1178,8 @@ module Muxr
       @session  = Session.new(name: @session_name, width: DEFAULT_WIDTH, height: DEFAULT_HEIGHT)
       @renderer = Renderer.new(out: FramedOutput.new(self))
       @input    = InputHandler.new(self)
+      apply_config(Config.load)
+      apply_window_defaults
 
       saved = Session.load(@session_name)
       first_id = saved && saved.dig("panes", 0, "id")
@@ -718,20 +1204,24 @@ module Muxr
       end
       @session&.window&.panes&.each(&:close)
       @session&.drawer&.close
+      if @trace_output
+        @trace_output.close rescue nil
+        @trace_output = nil
+      end
     end
 
     def loop_forever
       while @running
         read_ios  = [@listening_socket]
         read_ios << @current_client if @current_client
-        @session.window.panes.each { |p| read_ios << p.io if p.alive? }
+        @session.window.panes.each { |p| read_ios << p.io if p.alive? && !handing_off?(p) }
         drawer_pane = @session.drawer&.pane
         read_ios << drawer_pane.io if drawer_pane&.alive?
         read_ios.concat(@control_server.read_ios) if @control_server
 
         write_ios = []
         @session.window.panes.each do |p|
-          write_ios << p.writer_io if p.alive? && p.pending_write?
+          write_ios << p.writer_io if p.alive? && p.pending_write? && !handing_off?(p)
         end
         if drawer_pane&.alive? && drawer_pane.pending_write?
           write_ios << drawer_pane.writer_io
@@ -783,6 +1273,7 @@ module Muxr
 
         prune_dead_panes
         prune_dead_drawer
+        report_silent_panes
         expire_message
 
         if @session.window.panes.empty?
@@ -840,12 +1331,30 @@ module Muxr
 
       size = Protocol.decode_size(payload)
       apply_size(*size) if size
+      apply_caps(Protocol.decode_caps(payload))
 
       @current_client = sock
       @renderer.reset_frame!
+      report_config_problems
       invalidate
     end
 
+    # Apply the client's width-probe verdict so the emulator and Renderer measure
+    # glyphs exactly as this terminal draws them, eliminating the width
+    # disagreement that smears in-place animations:
+    #   ambiguous (1 narrow / 2 wide) — tunes the broad East Asian Ambiguous
+    #     class for the long tail of glyphs the probe didn't sample by hand.
+    #   glyphs ({codepoint => width}) — exact per-glyph overrides for the
+    #     emoji-presentation glyphs (Claude Code's ⏺/✻/❯) no class predicts.
+    # A reattaching client re-probes, so a different terminal re-tunes; the full
+    # repaint on attach absorbs the change.
+    def apply_caps(caps)
+      return if caps.nil? || caps.empty?
+      Terminal.ambiguous_wide = (caps[:ambiguous] == 2) if caps.key?(:ambiguous)
+      Terminal.box_wide = (caps[:box] == 2) if caps.key?(:box)
+      Terminal.width_overrides = caps[:glyphs] if caps.key?(:glyphs)
+    end
+
     def consume_client_frame
       type, payload = Protocol.read(@current_client)
       if type.nil?
@@ -874,15 +1383,68 @@ module Muxr
     def consume_pane_io(io)
       pane = pane_for_io(io)
       return unless pane
-      data = pane.read_from_pty
+      control = @control_server
+      relay = pane.id.is_a?(String) && control&.mirrored?(pane.id)
+      data =
+        if relay
+          pane.read_from_pty { |chunk| control.on_pane_raw(pane.id, chunk) }
+        else
+          pane.read_from_pty
+        end
       if data
         invalidate
+        pane.note_output(attended: attended?(pane))
         # Notify the control surface so any pending pane.run waiters reset
         # their idle window and any pane.subscribe clients get a new frame.
         # read_from_pty already fed the bytes into the Terminal; the control
         # server pulls the resulting text out of pane.terminal.dump_text.
         @control_server&.on_pane_output(pane.id, data) if pane.id.is_a?(String)
       end
+      forward_notifications(pane)
+      forward_clipboard(pane)
+    end
+
+    # Push any bell / desktop-notification bytes the pane's emulator collected
+    # straight to the outer terminal — out of band from the rendered frame, so a
+    # background pane (an unfocused Claude Code finishing a task) still alerts
+    # the user. When no client is attached deliver_output is a no-op; the queue
+    # is still drained so it can't accumulate while detached.
+    def forward_notifications(pane)
+      bytes = pane.terminal.take_pending_notifications!
+      return unless bytes
+      pane.note_bell unless attended?(pane)
+      deliver_output(bytes) if @current_client
+    end
+
+    def report_silent_panes
+      now = Pane.now
+      @session.window.panes.each_with_index do |pane, i|
+        next unless pane.silence_due?(now)
+        pane.note_silence!
+        flash("pane ##{i + 1} silent for #{format_seconds(pane.silence_after)}")
+        deliver_output("\a".b) if @current_client
+      end
+    end
+
+    def attended?(pane)
+      !@current_client.nil? && pane.equal?(focused_target)
+    end
+
+    def clear_focused_attention
+      target = focused_target
+      target.clear_attention! if target.respond_to?(:clear_attention!)
+    end
+
+    # Copy any OSC 52 clipboard write the pane's emulator collected to the
+    # system clipboard, and mirror it into the internal paste buffer so Ctrl-a p
+    # pastes the same text (same as copy-mode's yank). Unlike notifications this
+    # runs even when no client is attached — pbcopy is local to the server host,
+    # so a background pane's yank still lands on the clipboard.
+    def forward_clipboard(pane)
+      text = pane.terminal.take_pending_clipboard!
+      return if text.nil? || text.empty?
+      @paste_buffer = text
+      spawn_pbcopy(text)
     end
 
     def pane_for_io(io)
@@ -899,8 +1461,15 @@ module Muxr
       nil
     end
 
+    # A pane whose pty has been sent to another server but whose move is not
+    # committed yet. Its fd stays out of the select sets: two servers reading
+    # one master would split the byte stream between them.
+    def handing_off?(pane)
+      !!@control_server&.handing_off?(pane)
+    end
+
     def prune_dead_panes
-      dead = @session.window.panes.reject(&:alive?)
+      dead = @session.window.panes.reject { |p| p.alive? || handing_off?(p) }
       return if dead.empty?
       dead.each { |p| @session.window.remove_pane(p) }
       invalidate
@@ -940,17 +1509,40 @@ module Muxr
     end
 
     def render
+      leave_stale_scrollback
+      clear_focused_attention
       @renderer.render(
         @session,
         input_state: @input.state,
+        scroll_source: @input.scroll_source,
         command_buffer: @input.command_buffer,
+        command_completions: @input.command_completions,
         search_buffer: @input.search_buffer,
         search_direction: @input.search_direction,
         message: @message,
-        help: @help_visible
+        help: @help_visible,
+        picker: @pane_picker,
+        prefix: @input.prefix
       )
     end
 
+    def leave_stale_scrollback
+      return unless @input.state == :scrollback
+      target = focused_target
+      term = target&.terminal
+      return unless term
+      if @input.scroll_source == :app
+        return if app_scroll_available?(target)
+        @input.enter_scrollback_mode(source: :ring)
+        flash("app exited — scrolling muxr history")
+        @renderer.reset_frame!
+        return
+      end
+      return unless term.alt_screen?
+      @input.enter_idle_mode
+      @renderer.reset_frame!
+    end
+
     def disconnect_client(reason: nil)
       return unless @current_client
       # Best-effort: drop any queued OUTPUT (the client is going away),
@@ -1044,12 +1636,13 @@ module Muxr
     end
 
     def make_pane(cwd: nil, id: nil)
-      Pane.new(id: id, rows: 24, cols: 80, cwd: cwd)
+      pane_id = id || SecureRandom.hex(3)
+      Pane.new(id: pane_id, rows: 24, cols: 80, cwd: cwd, env_overrides: pane_env(pane_id))
     end
 
     def ensure_drawer(command: nil)
       return if @session.drawer
-      cwd = focused_pane&.cwd
+      cwd = @origin_cwd
       pane = Pane.new(
         id: :drawer,
         rows: 10,
@@ -1084,15 +1677,19 @@ module Muxr
       invalidate
     end
 
-    # Env vars exposed to every drawer PTY. The MCP bridge reads these to
-    # auto-connect to the right session; MUXR_DRAWER_SELF lets it refuse
-    # drawer.* methods so a claude drawer can't recurse into its own PTY.
-    def drawer_env
-      env = {
+    def session_env
+      {
         "MUXR_SESSION"        => @session_name.to_s,
-        "MUXR_CONTROL_SOCKET" => @control_socket_path.to_s,
-        "MUXR_DRAWER_SELF"    => "1"
+        "MUXR_CONTROL_SOCKET" => @control_socket_path.to_s
       }
+    end
+
+    def pane_env(pane_id)
+      session_env.merge("MUXR_PANE" => pane_id.to_s)
+    end
+
+    def drawer_env
+      env = session_env.merge("MUXR_DRAWER_SELF" => "1")
       focused = focused_pane
       env["MUXR_FOCUSED_PANE"] = focused.id.to_s if focused&.id.is_a?(String)
       env
@@ -1117,6 +1714,11 @@ module Muxr
         pane.mark_private! if entry["private"]
         @session.window.add_pane(pane)
       end
+      panes_data.each_with_index do |entry, i|
+        pane = @session.window.panes[i]
+        pane.name = entry["name"] if pane && entry["name"]
+        pane.watch_silence(entry["silence"]) if pane && entry["silence"].is_a?(Integer) && entry["silence"].positive?
+      end
 
       if data["drawer"]
         cwd = data["drawer"]["cwd"]
@@ -1137,6 +1739,8 @@ module Muxr
 
       @session.window.focused_index = (data["focused_index"] || 0).clamp(0, @session.window.panes.length - 1)
       @session.window.master_index  = (data["master_index"]  || 0).clamp(0, @session.window.panes.length - 1)
+      @session.window.master_ratio = data["master_ratio"] if data["master_ratio"].is_a?(Numeric)
+      @session.window.master_count = data["master_count"] if data["master_count"].is_a?(Integer)
       flash("session restored")
     end