echoes 0.2.0 → 0.3.0

data/lib/echoes/gui.rb

@@ -4,6 +4,7 @@ require 'pty'
 require 'shellwords'
 require 'socket'
 require 'uri'
+require 'json'
 
 module Echoes
   class GUI
@@ -24,6 +25,11 @@ module Echoes
     end
 
     def initialize(command: Echoes.config.shell, rows: Echoes.config.rows, cols: Echoes.config.cols, font_size: nil)
+      # Advertise ourselves the way other terminals do (iTerm2,
+      # WezTerm, Ghostty, …). Child shells and any program they
+      # spawn inherit these via the normal env-inheritance path.
+      ENV['TERM_PROGRAM']         = 'Echoes'
+      ENV['TERM_PROGRAM_VERSION'] = Echoes::VERSION
       @rows = rows
       @cols = cols
       # Persisted font size wins over the config default; both wrappers
@@ -32,17 +38,19 @@ module Echoes
       @command = command
       @tabs = []
       @active_tab = 0
+      @active_profile = Echoes.config.default_profile
       @colors = build_color_table
-      @default_fg = make_color(*Echoes.config.foreground)
-      @default_bg = make_color(*Echoes.config.background)
+      @default_fg = make_color(*@active_profile.foreground)
+      @default_bg = make_color(*@active_profile.background)
       @tab_bg = make_color(0.15, 0.15, 0.15)
-      @tab_active_bg = make_color(0.3, 0.3, 0.3)
-      @tab_fg = make_color(0.8, 0.8, 0.8)
-      @selection_color = make_color(*Echoes.config.selection_color)
+      @tab_fg_active   = make_color(0.95, 0.95, 0.95)
+      @tab_fg_inactive = make_color(0.55, 0.55, 0.55)
+      @selection_color = make_color(*@active_profile.selection_color)
       @search_match_color = make_color(0.6, 0.5, 0.0)
       @search_current_color = make_color(0.8, 0.6, 0.0)
       @selection_anchor = nil
       @selection_end = nil
+      @selection_word_anchor = nil
       @font_cache = {}
       @rgb_color_cache = {}
       @nsstring_cache = {}
@@ -52,6 +60,8 @@ module Echoes
       @search_query = +""
       @search_matches = []
       @search_index = -1
+      @search_regex_mode = false
+      @search_case_insensitive = false
       @bell_flash = 0
       @marked_text = nil
       @current_event = nil
@@ -76,9 +86,20 @@ module Echoes
       tab = Tab.new(command: @command, rows: @rows, cols: @cols, cwd: cwd,
                     embedded: embedded_mode?, editor_file: editor_file)
       tab.title = editor_file ? File.basename(editor_file) : "Tab #{@tabs.size + 1}"
-      tab.panes.each { |pane| wire_screen_handlers(pane.screen) }
-      @tabs << tab
-      @active_tab = @tabs.size - 1
+      tab.panes.each { |pane| wire_screen_handlers(pane) }
+      # Insert next to the current tab (Cmd+T from the middle of
+      # the tab bar lands the new tab immediately to the right of
+      # the active one, not at the far end) — matches Safari /
+      # Chrome / iTerm2 muscle memory.
+      if @tabs.empty?
+        @tabs << tab
+        @active_tab = 0
+      else
+        insert_at = @active_tab + 1
+        @tabs.insert(insert_at, tab)
+        @active_tab = insert_at
+      end
+      reflow_to_current_view_size
     end
 
     # Convert the active pane's OSC 7 `current_directory` URI into a local
@@ -115,6 +136,7 @@ module Echoes
       end
 
       @active_tab = @active_tab.clamp(0, @tabs.size - 1)
+      reflow_to_current_view_size
     end
 
     def current_tab
@@ -218,6 +240,7 @@ module Echoes
     def setup_app
       @app = ObjC::MSG_PTR.call(ObjC.cls('NSApplication'), ObjC.sel('sharedApplication'))
       ObjC::MSG_VOID_I.call(@app, ObjC.sel('setActivationPolicy:'), 0)
+      disable_press_and_hold
       # Disable native NSWindow tabbing so Cmd+N always spawns a real
       # new window. Default macOS behavior in fullscreen is to fold
       # additional NSWindows into the same OS-level tabbed window —
@@ -229,6 +252,24 @@ module Echoes
       setup_menu_bar
     end
 
+    # macOS's "Press and Hold" feature (ApplePressAndHoldEnabled,
+    # default ON) routes every Latin letter through a state machine
+    # that waits to see if the user is summoning the accent popup
+    # — for vowels and a handful of consonants it shows variants
+    # (à á â ä …), for the rest (B, F, J, M, P, Q, V, X — letters
+    # with no diacritical variants in the US English layout) it
+    # just silently suppresses key-repeat. Terminal users want
+    # auto-repeat on every letter, so we register a defaults
+    # override scoped to this process: AppKit sees the value on
+    # the next keyDown and falls back to plain auto-repeat.
+    def disable_press_and_hold
+      std = ObjC::MSG_PTR.call(ObjC.cls('NSUserDefaults'), ObjC.sel('standardUserDefaults'))
+      dict = ObjC.nsdict({
+        ObjC.nsstring('ApplePressAndHoldEnabled') => ObjC.nsnumber_int(0),
+      })
+      ObjC::MSG_VOID_1.call(std, ObjC.sel('registerDefaults:'), dict)
+    end
+
     def setup_menu_bar
       main_menu = create_menu('')
 
@@ -252,18 +293,21 @@ module Echoes
 
       # View menu
       view_menu = create_menu('View')
-      add_menu_item(view_menu, "Bigger", 'increaseFontSize:', '=')
-      add_menu_item(view_menu, "Bigger", 'increaseFontSize:', '+')
-      add_menu_item(view_menu, "Smaller", 'decreaseFontSize:', '-')
-      add_menu_item(view_menu, "Reset Font Size", 'resetFontSize:', '0')
+      add_menu_item(view_menu, "Bigger", 'increaseFontSize:', '=', bind: :increase_font_size)
+      add_menu_item(view_menu, "Bigger", 'increaseFontSize:', '+', bind: :increase_font_size_plus)
+      add_menu_item(view_menu, "Smaller", 'decreaseFontSize:', '-', bind: :decrease_font_size)
+      add_menu_item(view_menu, "Reset Font Size", 'resetFontSize:', '0', bind: :reset_font_size)
       add_separator(view_menu)
-      add_menu_item(view_menu, "Find", 'toggleFind:', 'f')
-      add_menu_item(view_menu, "Find Next", 'findNext:', 'g')
+      add_menu_item(view_menu, "Find", 'toggleFind:', 'f', bind: :toggle_find)
+      add_menu_item(view_menu, "Find Next", 'findNext:', 'g', bind: :find_next)
       add_menu_item(view_menu, "Find Previous", 'findPrevious:', 'g',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :find_previous)
       add_separator(view_menu)
       add_menu_item(view_menu, "Hide Mouse Pointer", 'togglePointer:', 'p',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :toggle_pointer)
+      build_profiles_submenu(view_menu)
       add_submenu(main_menu, view_menu, 'View')
 
       # Window menu
@@ -274,15 +318,18 @@ module Echoes
                     modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagControl)
       add_separator(window_menu)
       add_menu_item(window_menu, "Show Previous Tab", 'showPreviousTab:', '{',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :show_previous_tab)
       add_menu_item(window_menu, "Show Next Tab", 'showNextTab:', '}',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :show_next_tab)
       add_separator(window_menu)
-      add_menu_item(window_menu, "Select Next Pane", 'selectNextPane:', ']')
-      add_menu_item(window_menu, "Select Previous Pane", 'selectPreviousPane:', '[')
+      add_menu_item(window_menu, "Select Next Pane", 'selectNextPane:', ']', bind: :select_next_pane)
+      add_menu_item(window_menu, "Select Previous Pane", 'selectPreviousPane:', '[', bind: :select_previous_pane)
       add_separator(window_menu)
       add_menu_item(window_menu, "Toggle Copy Mode", 'toggleCopyMode:', 'c',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :toggle_copy_mode)
       add_separator(window_menu)
       # Register the menu as NSApplication's "windows menu"; AppKit
       # auto-populates it with one item per NSWindow (using the window's
@@ -292,18 +339,21 @@ module Echoes
 
       # Shell menu
       shell_menu = create_menu('Shell')
-      add_menu_item(shell_menu, "New Window", 'newWindow:', 'n')
-      add_menu_item(shell_menu, "New Tab", 'newTab:', 't')
-      add_menu_item(shell_menu, "Close Tab", 'closeTab:', 'w')
+      add_menu_item(shell_menu, "New Window", 'newWindow:', 'n', bind: :new_window)
+      add_menu_item(shell_menu, "New Tab", 'newTab:', 't', bind: :new_tab)
+      add_menu_item(shell_menu, "Close Tab", 'closeTab:', 'w', bind: :close_tab)
       add_separator(shell_menu)
       add_menu_item(shell_menu, "Edit File…", 'editFile:', 'e',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :edit_file)
       add_separator(shell_menu)
-      add_menu_item(shell_menu, "Split Right", 'splitRight:', 'd')
+      add_menu_item(shell_menu, "Split Right", 'splitRight:', 'd', bind: :split_right)
       add_menu_item(shell_menu, "Split Down", 'splitDown:', 'd',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :split_down)
       add_menu_item(shell_menu, "Close Pane", 'closePane:', 'w',
-                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift)
+                    modifiers: ObjC::NSEventModifierFlagCommand | ObjC::NSEventModifierFlagShift,
+                    bind: :close_pane)
       add_submenu(main_menu, shell_menu, 'Shell')
 
       ObjC::MSG_VOID_1.call(@app, ObjC.sel('setMainMenu:'), main_menu)
@@ -314,10 +364,20 @@ module Echoes
       ObjC::MSG_PTR_1.call(m, ObjC.sel('initWithTitle:'), ObjC.nsstring(title))
     end
 
-    private def add_menu_item(menu, title, action, key, modifiers: ObjC::NSEventModifierFlagCommand)
+    private def add_menu_item(menu, title, selector, key, modifiers: ObjC::NSEventModifierFlagCommand, bind: nil)
+      # When `bind:` is given, allow `~/.config/echoes/echoes.conf`
+      # to override the default shortcut via `keybind "…", :sym`.
+      # The override fully replaces both the key and the modifier
+      # bits — an override of `""` (or `nil`) disables the
+      # shortcut entirely (menu item stays, no keyboard binding).
+      if bind && (over = Echoes.config.keybind_for(bind))
+        key = over[:key].to_s
+        modifiers = over[:modifiers]
+      end
+
       item = ObjC::MSG_PTR.call(ObjC.cls('NSMenuItem'), ObjC.sel('alloc'))
       item = ObjC::MSG_PTR_3.call(item, ObjC.sel('initWithTitle:action:keyEquivalent:'),
-        ObjC.nsstring(title), action.empty? ? Fiddle::Pointer.new(0) : ObjC.sel(action), ObjC.nsstring(key))
+        ObjC.nsstring(title), selector.empty? ? Fiddle::Pointer.new(0) : ObjC.sel(selector), ObjC.nsstring(key))
       if modifiers != ObjC::NSEventModifierFlagCommand && !key.empty?
         ObjC::MSG_VOID_L.call(item, ObjC.sel('setKeyEquivalentModifierMask:'), modifiers)
       end
@@ -330,6 +390,40 @@ module Echoes
       ObjC::MSG_VOID_1.call(menu, ObjC.sel('addItem:'), sep)
     end
 
+    # Generate `applyProfile_<i>:` selector entries — one per
+    # declared profile — for the view-class selector dict. The
+    # closures already exist in @profile_closures keyed by name;
+    # this just gives them stable selector strings AppKit can
+    # dispatch by index. `profile_selector_for` returns the matching
+    # selector string for a given profile name so the menu builder
+    # can wire the right one to each menu item.
+    private def profile_selectors
+      out = {}
+      Echoes.config.all_profiles.each_key.with_index do |pname, i|
+        out[profile_selector_for(pname)] = ['v@:@', @profile_closures[pname]]
+      end
+      out
+    end
+
+    private def profile_selector_for(name)
+      i = Echoes.config.all_profiles.keys.index(name)
+      "applyProfile_#{i}:"
+    end
+
+    # Add a "Profile" submenu to `view_menu` listing the synthesized
+    # "Default" plus every user-declared profile. Always rendered so
+    # the feature is discoverable even with an empty config.
+    private def build_profiles_submenu(view_menu)
+      profiles = Echoes.config.all_profiles
+      return if profiles.empty?
+      add_separator(view_menu)
+      submenu = create_menu('Profile')
+      profiles.each_key do |pname|
+        add_menu_item(submenu, pname, profile_selector_for(pname), '')
+      end
+      add_submenu(view_menu, submenu, 'Profile')
+    end
+
     private def add_submenu(parent, submenu, title)
       item = ObjC::MSG_PTR.call(ObjC.cls('NSMenuItem'), ObjC.sel('alloc'))
       item = ObjC::MSG_PTR_3.call(item, ObjC.sel('initWithTitle:action:keyEquivalent:'),
@@ -618,6 +712,15 @@ module Echoes
       }
 
       @show_about_closure = menu_action.call(-> { show_about_panel })
+
+      # One closure per declared profile, indexed by name. The
+      # menu builder later wires each into its own
+      # `applyProfile_<n>:` selector so AppKit can deliver the
+      # right one without us having to dispatch by event payload.
+      @profile_closures = {}
+      Echoes.config.all_profiles.each_key do |pname|
+        @profile_closures[pname] = menu_action.call(-> { apply_profile(pname) })
+      end
       @new_window_closure = menu_action.call(-> { open_new_window })
       @new_tab_closure = menu_action.call(-> {
         create_tab
@@ -670,13 +773,13 @@ module Echoes
       @split_right_closure = menu_action.call(-> {
         tab = current_tab
         new_pane = tab.split_vertical
-        wire_screen_handlers(new_pane.screen)
+        wire_screen_handlers(new_pane)
         ObjC::MSG_VOID_I.call(@view, ObjC.sel('setNeedsDisplay:'), 1)
       })
       @split_down_closure = menu_action.call(-> {
         tab = current_tab
         new_pane = tab.split_horizontal
-        wire_screen_handlers(new_pane.screen)
+        wire_screen_handlers(new_pane)
         ObjC::MSG_VOID_I.call(@view, ObjC.sel('setNeedsDisplay:'), 1)
       })
       @close_pane_closure = menu_action.call(-> {
@@ -783,6 +886,7 @@ module Echoes
         'windowDidBecomeKey:'   => ['v@:@', @focus_gained_closure],
         'windowDidResignKey:'   => ['v@:@', @focus_lost_closure],
         'showAbout:'             => ['v@:@', @show_about_closure],
+        **profile_selectors,
         'newWindow:'             => ['v@:@', @new_window_closure],
         'newTab:'               => ['v@:@', @new_tab_closure],
         'editFile:'             => ['v@:@', @edit_file_closure],
@@ -896,6 +1000,7 @@ module Echoes
         ObjC::NSRectFill.call(0.0, gy_off, @cols * @cell_width, @rows * @cell_height)
       end
 
+
       # Draw search bar
       if @search_mode
         bar_h = @cell_height + 4.0
@@ -905,7 +1010,11 @@ module Echoes
         ObjC::NSRectFill.call(0.0, bar_y, @cols * @cell_width, bar_h)
 
         match_info = @search_matches.empty? ? "" : " [#{@search_index + 1}/#{@search_matches.size}]"
-        label = "Find: #{@search_query}_#{match_info}"
+        mode_flags = []
+        mode_flags << 'regex' if @search_regex_mode
+        mode_flags << 'i'     if @search_case_insensitive
+        mode_tag = mode_flags.empty? ? '' : " (#{mode_flags.join(', ')})"
+        label = "Find#{mode_tag}: #{@search_query}_#{match_info}"
         ns_str = ObjC.nsstring(label)
         ns_attrs = ObjC.nsdict({
           ObjC::NSFontAttributeName => @font,
@@ -942,9 +1051,54 @@ module Echoes
               end
         next unless row
 
+        # Cell-background fills snap their left/right (and
+        # top/bottom) to integer pixel boundaries against the
+        # *next* cell's left edge. When @cell_width is fractional
+        # (most monospace fonts at most sizes), independent per-
+        # cell rounding leaves sub-pixel AA seams between adjacent
+        # fills, which visibly stripe solid-bg regions (selection
+        # ranges, search matches, SF_DATALESS-file highlights from
+        # `ls`, …). Snapping with the next-boundary trick
+        # guarantees neighbors share an exact device-pixel edge,
+        # which is what makes the seams disappear.
+        snap_fill = lambda do |fx, fy, fw, fh|
+          x0 = fx.round
+          x1 = (fx + fw).round
+          y0 = fy.round
+          y1 = (fy + fh).round
+          ObjC::NSRectFill.call(x0.to_f, y0.to_f, (x1 - x0).to_f, (y1 - y0).to_f)
+        end
+
+        # Text-run accumulator. We batch consecutive cells with
+        # matching style into one drawAtPoint call so the font
+        # shaper sees adjacent characters and can apply ligatures
+        # (`=>`, `!=`, `<=`, etc.) on fonts that have them.
+        # Anything that can't extend the run (multicell, blank
+        # non-bg cell, style change) flushes it first.
+        run_chars   = +''
+        run_start_c = nil
+        run_attrs   = nil
+        run_font    = nil
+        run_sig     = nil
+        flush_run = lambda do
+          next if run_chars.empty?
+          ns_run = ObjC.nsstring(run_chars)
+          run_x  = px + run_start_c * @cell_width
+          run_dy = y + y_offset_for_font(run_font)
+          ObjC::MSG_VOID_PT_1.call(ns_run, ObjC.sel('drawAtPoint:withAttributes:'),
+                                   run_x, run_dy, run_attrs)
+          run_chars   = +''
+          run_start_c = nil
+          run_attrs   = nil
+          run_font    = nil
+          run_sig     = nil
+        end
+
         row.each_with_index do |cell, c|
-          next if cell.width == 0
-          next if cell.multicell == :cont
+          if cell.width == 0 || cell.multicell == :cont
+            flush_run.call
+            next
+          end
 
           fg_val = cell.fg
           bg_val = cell.bg
@@ -987,6 +1141,7 @@ module Echoes
           end
 
           if cell.multicell.is_a?(Hash)
+            flush_run.call
             mc = cell.multicell
             x = px + c * @cell_width
             block_w = mc[:cols] * @cell_width
@@ -994,10 +1149,10 @@ module Echoes
 
             if selected
               ObjC::MSG_VOID.call(@selection_color, ObjC.sel('setFill'))
-              ObjC::NSRectFill.call(x, y, block_w, block_h)
+              snap_fill.call(x, y, block_w, block_h)
             elsif has_bg
               ObjC::MSG_VOID.call(bg_color, ObjC.sel('setFill'))
-              ObjC::NSRectFill.call(x, y, block_w, block_h)
+              snap_fill.call(x, y, block_w, block_h)
             end
 
             if mc[:sixel]
@@ -1018,6 +1173,13 @@ module Echoes
               effective_scale *= mc[:frac_n].to_f / mc[:frac_d]
             end
             scaled_font = ObjC.retain(create_nsfont(@font_size * effective_scale, family: mc[:family]))
+            # Capture the regular line height *before* possibly swapping
+            # in the bold variant so we can re-align the bold baseline
+            # below — bold fonts often report a larger
+            # defaultLineHeightForFont and otherwise sit visually lower
+            # than adjacent non-bold OSC 66 cells (same fix the cell-loop
+            # path does via y_offset_for_font for same-family bold).
+            regular_scaled_lh = ObjC::MSG_RET_D.call(scaled_font, ObjC.sel('defaultLineHeightForFont'))
             if cell.bold
               regular = scaled_font
               scaled_font = ObjC.retain(create_bold_nsfont(regular))
@@ -1056,7 +1218,37 @@ module Echoes
                       else y
                       end
 
-            ObjC::MSG_VOID_PT_1.call(ns_char, ObjC.sel('drawAtPoint:withAttributes:'), draw_x, draw_y, ns_attrs)
+            # Baseline compensation: same-family bold variants
+            # report a larger defaultLineHeightForFont; shifting
+            # by LH-delta puts the bold baseline back on the same
+            # row as the regular run beside it. (OSC 66 doesn't
+            # mix unrelated families in a single run, so the
+            # ascender-delta fork the cell-loop path needs doesn't
+            # apply here.)
+            drawn_lh = ObjC::MSG_RET_D.call(scaled_font, ObjC.sel('defaultLineHeightForFont'))
+            draw_y += (regular_scaled_lh - drawn_lh)
+
+            if mc[:flip_h] || mc[:flip_v]
+              # Mirror the glyph(s) around the multicell block's
+              # center. Negative-scale the CTM along the requested
+              # axis and translate twice so the flip pivots on the
+              # block midpoint rather than the origin — keeps the
+              # glyph(s) inside the reserved cell rect.
+              ns_ctx = ObjC::MSG_PTR.call(ObjC.cls('NSGraphicsContext'), ObjC.sel('currentContext'))
+              cg_ctx = ObjC::MSG_PTR.call(ns_ctx, ObjC.sel('CGContext'))
+              cx = x + block_w / 2.0
+              cy = y + block_h / 2.0
+              sx = mc[:flip_h] ? -1.0 : 1.0
+              sy = mc[:flip_v] ? -1.0 : 1.0
+              ObjC::CGContextSaveGState.call(cg_ctx)
+              ObjC::CGContextTranslateCTM.call(cg_ctx, cx, cy)
+              ObjC::CGContextScaleCTM.call(cg_ctx, sx, sy)
+              ObjC::CGContextTranslateCTM.call(cg_ctx, -cx, -cy)
+              ObjC::MSG_VOID_PT_1.call(ns_char, ObjC.sel('drawAtPoint:withAttributes:'), draw_x, draw_y, ns_attrs)
+              ObjC::CGContextRestoreGState.call(cg_ctx)
+            else
+              ObjC::MSG_VOID_PT_1.call(ns_char, ObjC.sel('drawAtPoint:withAttributes:'), draw_x, draw_y, ns_attrs)
+            end
             ObjC.release(scaled_font)
           else
             x = px + c * @cell_width
@@ -1064,19 +1256,22 @@ module Echoes
 
             if is_current_match
               ObjC::MSG_VOID.call(@search_current_color, ObjC.sel('setFill'))
-              ObjC::NSRectFill.call(x, y, cell_w, @cell_height)
+              snap_fill.call(x, y, cell_w, @cell_height)
             elsif is_match
               ObjC::MSG_VOID.call(@search_match_color, ObjC.sel('setFill'))
-              ObjC::NSRectFill.call(x, y, cell_w, @cell_height)
+              snap_fill.call(x, y, cell_w, @cell_height)
             elsif selected
               ObjC::MSG_VOID.call(@selection_color, ObjC.sel('setFill'))
-              ObjC::NSRectFill.call(x, y, cell_w, @cell_height)
+              snap_fill.call(x, y, cell_w, @cell_height)
             elsif has_bg
               ObjC::MSG_VOID.call(bg_color, ObjC.sel('setFill'))
-              ObjC::NSRectFill.call(x, y, cell_w, @cell_height)
+              snap_fill.call(x, y, cell_w, @cell_height)
             end
 
-            next if cell.char == " " && !has_bg && !selected && !is_match
+            if cell.char == " " && !has_bg && !selected && !is_match
+              flush_run.call
+              next
+            end
 
             base_font = cell.bold ? @bold_font : font_for_char(cell.char)
             if cell.italic
@@ -1087,22 +1282,40 @@ module Echoes
             elsif cell.faint
               fg_color = make_color_with_alpha(fg_color, 0.5)
             end
-            attrs = {
-              ObjC::NSFontAttributeName => base_font,
-              ObjC::NSForegroundColorAttributeName => fg_color,
-            }
-            if cell.underline
-              attrs[ObjC::NSUnderlineStyleAttributeName] = ObjC.nsnumber_int(1)
-            end
-            if cell.strikethrough
-              attrs[ObjC::NSStrikethroughStyleAttributeName] = ObjC.nsnumber_int(1)
+
+            sig = [base_font.to_i, fg_color.to_i, cell.underline, cell.strikethrough]
+            if run_sig != sig
+              flush_run.call
+              run_sig     = sig
+              run_start_c = c
+              run_font    = base_font
+              attrs = {
+                ObjC::NSFontAttributeName            => base_font,
+                ObjC::NSForegroundColorAttributeName => fg_color,
+                # Ligature value `2` requests all discretionary
+                # ligatures (`=>`, `!=`, `<=`, `>=`, etc.) on
+                # fonts like Fira Code that ship them; default
+                # `0` only does fi/fl-style essential ones.
+                ObjC::NSLigatureAttributeName        => ObjC.nsnumber_int(2),
+              }
+              attrs[ObjC::NSUnderlineStyleAttributeName]     = ObjC.nsnumber_int(1) if cell.underline
+              attrs[ObjC::NSStrikethroughStyleAttributeName] = ObjC.nsnumber_int(1) if cell.strikethrough
+              run_attrs = ObjC.nsdict(attrs)
             end
-            ns_attrs = ObjC.nsdict(attrs)
-            ns_char = cached_nsstring(cell.char)
-            dy = y + y_offset_for_font(base_font)
-            ObjC::MSG_VOID_PT_1.call(ns_char, ObjC.sel('drawAtPoint:withAttributes:'), x, dy, ns_attrs)
+            run_chars << cell.char
           end
         end
+        flush_run.call
+      end
+
+      # Re-blit kitty graphics placements ON TOP of the rendered
+      # cells. Anchors are stored as logical cell coords on the
+      # Screen; we convert to pixels here using current cell
+      # metrics so font-size and pane-resize changes pick up the
+      # right pixel position automatically — placements need no
+      # bookkeeping when @cell_width / @cell_height shift.
+      screen.placements.each do |pl|
+        blit_kitty_placement(pl, px, py, pane_rows)
       end
 
       # Draw cursor or copy mode cursor
@@ -1124,7 +1337,7 @@ module Echoes
         if @window_focused
           # Active window: filled cursor (blinking if requested)
           if !blink || (is_active ? @cursor_blink_on : true)
-            cursor_color = is_active ? make_color(*Echoes.config.cursor_color) : make_color(0.5, 0.5, 0.5, 0.3)
+            cursor_color = is_active ? make_color(*@active_profile.cursor_color) : make_color(0.5, 0.5, 0.5, 0.3)
             ObjC::MSG_VOID.call(cursor_color, ObjC.sel('setFill'))
             case style
             when 3, 4 # underline
@@ -1152,7 +1365,7 @@ module Echoes
           end
         else
           # Inactive window: hollow square outline (no blinking)
-          ObjC::MSG_VOID.call(make_color(*Echoes.config.cursor_color), ObjC.sel('setFill'))
+          ObjC::MSG_VOID.call(make_color(*@active_profile.cursor_color), ObjC.sel('setFill'))
           ObjC::NSRectFill.call(cx, cy, @cell_width, 1.0)                       # top
           ObjC::NSRectFill.call(cx, cy + @cell_height - 1.0, @cell_width, 1.0)  # bottom
           ObjC::NSRectFill.call(cx, cy, 1.0, @cell_height)                      # left
@@ -1247,6 +1460,7 @@ module Echoes
 
       @selection_anchor = nil
       @selection_end = nil
+      @selection_word_anchor = nil
 
       flags = ObjC::MSG_RET_L.call(event_ptr, ObjC.sel('modifierFlags'))
       chars_ns = ObjC::MSG_PTR.call(event_ptr, ObjC.sel('charactersIgnoringModifiers'))
@@ -1481,6 +1695,18 @@ module Echoes
 
       full_redraw = @bell_flash > 0 || blink_toggled
 
+      # DEC private mode 2026 (synchronized output): when a TUI has
+      # opened a sync window with `\e[?2026h`, hold the redraw — even
+      # though we've already mutated the cell grid — until the
+      # matching `\e[?2026l` arrives. This makes vim/bat/helix bulk
+      # repaints land as a single visual frame instead of tearing
+      # mid-batch. Dirty rows accumulate across sync ticks; when sync
+      # ends, the next tick paints them all at once.
+      if tab.panes.any? { |p| p.screen.sync_active }
+        save_window_state
+        return
+      end
+
       if need_redraw
         ObjC::MSG_VOID_1.call(@window, ObjC.sel('setTitle:'), ObjC.nsstring(tab.title))
 
@@ -1587,8 +1813,12 @@ module Echoes
           @selection_anchor = [abs_row, 0]
           @selection_end    = [abs_row, @cols - 1]
         end
+        @selection_word_anchor = nil
       elsif click_count == 2
-        # Double-click: select word
+        # Double-click: select word, and remember the word's bounds so
+        # a subsequent drag extends from those bounds (keeping the
+        # double-clicked word fully selected) instead of collapsing
+        # to character-level from the click point.
         abs_row, col = pos
         row_data = row_at(tab, abs_row)
         if row_data
@@ -1596,12 +1826,14 @@ module Echoes
           if bounds
             @selection_anchor = [abs_row, bounds[0]]
             @selection_end = [abs_row, bounds[1]]
+            @selection_word_anchor = [abs_row, bounds[0], bounds[1]]
           end
         end
       else
         # Single click: start drag selection
         @selection_anchor = pos
         @selection_end = nil
+        @selection_word_anchor = nil
       end
 
       ObjC::MSG_VOID_I.call(@view, ObjC.sel('setNeedsDisplay:'), 1)
@@ -1616,12 +1848,46 @@ module Echoes
       if tab.screen.mouse_tracking == :button_event || tab.screen.mouse_tracking == :any_event
         row, col = pos
         send_mouse_event(tab, 32, col, row)  # 32 = left drag (button 0 + 32)
+      elsif @selection_word_anchor
+        extend_word_drag_selection(tab, pos)
       else
         @selection_end = pos
       end
       ObjC::MSG_VOID_I.call(@view, ObjC.sel('setNeedsDisplay:'), 1)
     end
 
+    # When dragging after a double-click, snap each end of the
+    # selection to whole-word boundaries — and never let it shrink
+    # below the originally double-clicked word. Selection start is
+    # min((anchor_word_start), (pointer's word_start)); end is
+    # max((anchor_word_end), (pointer's word_end)). If the pointer
+    # is sitting on whitespace the "word" at the pointer is just
+    # that single cell, so the leading edge extends one char at a
+    # time across gaps.
+    def extend_word_drag_selection(tab, pointer_pos)
+      a_row, a_start, a_end = @selection_word_anchor
+      p_row, p_col = pointer_pos
+      p_row_data = row_at(tab, p_row)
+      p_bounds = p_row_data && word_boundaries_in_row(p_row_data, p_col)
+      p_start = p_bounds ? p_bounds[0] : p_col
+      p_end   = p_bounds ? p_bounds[1] : p_col
+
+      sel_start =
+        if p_row < a_row || (p_row == a_row && p_start < a_start)
+          [p_row, p_start]
+        else
+          [a_row, a_start]
+        end
+      sel_end =
+        if p_row > a_row || (p_row == a_row && p_end > a_end)
+          [p_row, p_end]
+        else
+          [a_row, a_end]
+        end
+      @selection_anchor = sel_start
+      @selection_end    = sel_end
+    end
+
     def mouse_up(event_ptr)
       tab = current_tab
       return unless tab
@@ -1746,6 +2012,17 @@ module Echoes
       @tabs.each { |tab| tab.resize(@rows, @cols) }
     end
 
+    # Re-run handle_resize against the current view frame. Toggling
+    # tab_bar_height (when @tabs.size crosses 1↔2) changes the grid
+    # area inside an unchanged window, but AppKit's setFrameSize:
+    # hook only fires on real frame changes — so call it ourselves
+    # so @rows reflows to the new available height.
+    def reflow_to_current_view_size
+      return unless @view && @cell_width && @cell_height
+      _, _, w, h = nsrect_via_invocation(@view, 'frame')
+      handle_resize(w, h)
+    end
+
     def window_focus_changed(focused)
       @window_focused = focused
       save_window_state
@@ -1759,6 +2036,34 @@ module Echoes
       pane.write_input(seq)
     end
 
+    # Switch the active profile (color theme) by name. Releases the
+    # current NSColor cache, rebuilds default fg/bg/selection and
+    # the 256-color palette from the new profile, and triggers a
+    # full repaint so every existing cell picks up the new colors.
+    # Per-pane gradient overlays (OSC 7772 bg-* commands) are left
+    # alone — those are user-driven decoration, not theme.
+    def apply_profile(name)
+      profile = Echoes.config.all_profiles[name.to_s]
+      return unless profile
+      @active_profile = profile
+
+      ObjC.release(@default_fg)        if @default_fg
+      ObjC.release(@default_bg)        if @default_bg
+      ObjC.release(@selection_color)   if @selection_color
+      @colors&.each_value { |c| ObjC.release(c) }
+
+      @colors = build_color_table
+      @default_fg      = make_color(*@active_profile.foreground)
+      @default_bg      = make_color(*@active_profile.background)
+      @selection_color = make_color(*@active_profile.selection_color)
+      @rgb_color_cache = {}  # truecolor cache stale after palette swap
+
+      @window_states.each do |ws|
+        ws[:tabs].each { |tab| tab.panes.each { |p| p.screen.mark_all_dirty } } if ws[:tabs]
+        ObjC::MSG_VOID_I.call(ws[:nsview], ObjC.sel('setNeedsDisplay:'), 1) if ws[:nsview]
+      end
+    end
+
     def update_font(new_size, persist: true)
       @font_size = new_size
       Preferences.set_double(:font_size, new_size) if persist
@@ -1771,6 +2076,8 @@ module Echoes
       @font_cache.each_value { |f| ObjC.release(f) unless f.to_i == old_font&.to_i }
       @font_cache = {}
       @font_y_offset_cache = {}
+      @italic_font_cache&.each_value { |f| ObjC.release(f) }
+      @italic_font_cache = {}
       update_cell_metrics
 
       @window_states.each do |ws|
@@ -1826,7 +2133,7 @@ module Echoes
       # Create tab
       tab = Tab.new(command: @command, rows: @rows, cols: @cols, embedded: embedded_mode?)
       tab.title = "Shell"
-      tab.panes.each { |pane| wire_screen_handlers(pane.screen) }
+      tab.panes.each { |pane| wire_screen_handlers(pane) }
 
       # Build window and view in locals — DO NOT touch @window / @view yet.
       # makeKeyAndOrderFront: below fires NSWindowDidResignKeyNotification on
@@ -1893,6 +2200,8 @@ module Echoes
       @search_query = +""
       @search_matches = []
       @search_index = -1
+      @search_regex_mode = false
+      @search_case_insensitive = false
       @bell_flash = 0
       @marked_text = nil
       @current_event = nil
@@ -1905,6 +2214,15 @@ module Echoes
       @window_states << ws
       @view_to_ws[@view.to_i] = ws
       save_window_state
+
+      # setFrameAutosaveName: above may have restored a window
+      # frame larger than the config-sized initial frame; our
+      # setFrameSize: hook ran handle_resize at that moment, which
+      # updated @rows/@cols but no-op'd the tab loop because @tabs
+      # was still empty. Sync the just-created tab to the current
+      # window dimensions now that it's in @tabs. Idempotent when
+      # the saved frame matches the config (or doesn't exist).
+      @tabs.each { |tab| tab.resize(@rows, @cols) }
     end
 
     def select_all
@@ -2108,6 +2426,48 @@ module Echoes
     rescue Errno::EIO, IOError
     end
 
+    # Re-blit one Screen#placements entry. Pixel coords are
+    # recomputed every frame from anchor row/col × current cell
+    # metrics, so changing the font or resizing the pane needs no
+    # placement edit — the next draw picks up the new coords. The
+    # decoded CGImage is cached on the shared image hash so
+    # repeated frames (60Hz tick, dirty-rect refreshes) don't
+    # rebuild the bitmap context.
+    def blit_kitty_placement(pl, px, py, pane_rows)
+      img = pl[:image]
+      return unless img && img[:rgba] && img[:width].to_i > 0 && img[:height].to_i > 0
+      return if pl[:anchor_row] + pl[:cell_rows] <= 0   # fully scrolled off above
+      return if pl[:anchor_row] >= pane_rows             # below visible
+
+      unless img[:cg_image]
+        rgba_ptr = Fiddle::Pointer.to_ptr(img[:rgba])
+        cs = ObjC::CGColorSpaceCreateDeviceRGB.call
+        ctx = ObjC::CGBitmapContextCreate.call(
+          rgba_ptr, img[:width], img[:height], 8, img[:width] * 4, cs,
+          ObjC::KCGImageAlphaPremultipliedLast
+        )
+        img[:cg_image] = ObjC::CGBitmapContextCreateImage.call(ctx)
+        ObjC::CGContextRelease.call(ctx)
+        ObjC::CGColorSpaceRelease.call(cs)
+      end
+      cg_image = img[:cg_image]
+      return if cg_image.null?
+
+      x = px + pl[:anchor_col] * @cell_width  + pl[:x_off].to_i
+      y = py + pl[:anchor_row] * @cell_height + pl[:y_off].to_i
+      draw_w = pl[:cell_cols] * @cell_width
+      draw_h = pl[:cell_rows] * @cell_height
+
+      ns_ctx = ObjC::MSG_PTR.call(ObjC.cls('NSGraphicsContext'), ObjC.sel('currentContext'))
+      cg_ctx = ObjC::MSG_PTR.call(ns_ctx, ObjC.sel('CGContext'))
+
+      ObjC::CGContextSaveGState.call(cg_ctx)
+      ObjC::CGContextTranslateCTM.call(cg_ctx, x, y + draw_h)
+      ObjC::CGContextScaleCTM.call(cg_ctx, 1.0, -1.0)
+      ObjC::CGContextDrawImage.call(cg_ctx, 0.0, 0.0, draw_w, draw_h, cg_image)
+      ObjC::CGContextRestoreGState.call(cg_ctx)
+    end
+
     def draw_sixel_image(sixel, x, y, draw_w, draw_h)
       # Cache CGImage on first render
       unless sixel[:cg_image]
@@ -2133,9 +2493,15 @@ module Echoes
       ns_ctx = ObjC::MSG_PTR.call(ObjC.cls('NSGraphicsContext'), ObjC.sel('currentContext'))
       cg_ctx = ObjC::MSG_PTR.call(ns_ctx, ObjC.sel('CGContext'))
 
+      # Sub-cell pixel offsets (kitty X= / Y=). Both default to 0
+      # so legacy callers pay nothing; non-zero values shift the
+      # image within its anchor cell for fine alignment.
+      ox = sixel[:px_x_offset].to_i
+      oy = sixel[:px_y_offset].to_i
+
       # Draw with flipping (view is flipped, but CGContext draws bottom-up)
       ObjC::CGContextSaveGState.call(cg_ctx)
-      ObjC::CGContextTranslateCTM.call(cg_ctx, x, y + draw_h)
+      ObjC::CGContextTranslateCTM.call(cg_ctx, x + ox, y + oy + draw_h)
       ObjC::CGContextScaleCTM.call(cg_ctx, 1.0, -1.0)
       ObjC::CGContextDrawImage.call(cg_ctx, 0.0, 0.0, draw_w, draw_h, cg_image)
       ObjC::CGContextRestoreGState.call(cg_ctx)
@@ -2149,31 +2515,34 @@ module Echoes
       ObjC::MSG_VOID.call(@tab_bg, ObjC.sel('setFill'))
       ObjC::NSRectFill.call(0.0, ty, total_w + @cell_width, tbh)
 
-      @tabs.each_with_index do |tab, i|
-        x = i * tab_w
+      # Vertically center titles in the bar.
+      title_y = ty + (tbh - @font_default_line_height) / 2.0
 
-        # Active tab highlight
-        if i == @active_tab
-          ObjC::MSG_VOID.call(@tab_active_bg, ObjC.sel('setFill'))
-          ObjC::NSRectFill.call(x, ty, tab_w, tbh)
-        end
+      accent_color = make_color(*@active_profile.cursor_color)
+      accent_h     = 2.0
+      accent_inset = @cell_width * 0.5
+
+      @tabs.each_with_index do |tab, i|
+        x         = i * tab_w
+        is_active = (i == @active_tab)
 
-        # Tab title
         label = tab.title
-        label = "#{label} " if label.length < 12
         ns_label = ObjC.nsstring(label)
         ns_attrs = ObjC.nsdict({
           ObjC::NSFontAttributeName => @font,
-          ObjC::NSForegroundColorAttributeName => @tab_fg,
+          ObjC::NSForegroundColorAttributeName => is_active ? @tab_fg_active : @tab_fg_inactive,
         })
         text_x = x + @cell_width * 0.5
-        ObjC::MSG_VOID_PT_1.call(ns_label, ObjC.sel('drawAtPoint:withAttributes:'), text_x, ty, ns_attrs)
-
-        # Separator line between tabs
-        if i < @tabs.size - 1
-          sep_color = make_color(0.4, 0.4, 0.4)
-          ObjC::MSG_VOID.call(sep_color, ObjC.sel('setFill'))
-          ObjC::NSRectFill.call(x + tab_w - 0.5, ty + 2.0, 1.0, tbh - 4.0)
+        ObjC::MSG_VOID_PT_1.call(ns_label, ObjC.sel('drawAtPoint:withAttributes:'), text_x, title_y, ns_attrs)
+
+        # Thin accent strip flush to the bottom of the bar marks
+        # the active tab — replaces the previous heavier full-cell
+        # background fill. Inset on each side so it reads as the
+        # tab's own marker rather than a continuous line.
+        if is_active
+          ObjC::MSG_VOID.call(accent_color, ObjC.sel('setFill'))
+          ObjC::NSRectFill.call(x + accent_inset, ty + tbh - accent_h,
+                                 tab_w - 2 * accent_inset, accent_h)
         end
       end
     end
@@ -2222,6 +2591,8 @@ module Echoes
       key_code = ObjC::MSG_RET_L.call(event_ptr, ObjC.sel('keyCode'))
       flags = ObjC::MSG_RET_L.call(event_ptr, ObjC.sel('modifierFlags'))
 
+      cmd_held = (flags & ObjC::NSEventModifierFlagCommand) != 0
+
       case key_code
       when 53 # Escape
         @search_mode = false
@@ -2236,7 +2607,19 @@ module Echoes
         @search_query.chop!
         perform_search
       else
-        unless chars.empty? || chars[0].ord < 0x20
+        # Cmd+R toggles regex; Cmd+I toggles case-insensitive.
+        # Re-run the search live so the user sees results update
+        # without having to retype.
+        if cmd_held && chars.length == 1
+          case chars.downcase
+          when 'r'
+            @search_regex_mode = !@search_regex_mode
+            perform_search
+          when 'i'
+            @search_case_insensitive = !@search_case_insensitive
+            perform_search
+          end
+        elsif !chars.empty? && chars[0].ord >= 0x20
           @search_query << chars
           perform_search
         end
@@ -2253,31 +2636,72 @@ module Echoes
       screen = tab.screen
       scrollback = screen.scrollback
 
+      matcher = build_search_matcher(@search_query)
+      return unless matcher    # invalid regex → no matches, no crash
+
       # Search scrollback
       scrollback.each_with_index do |row, abs_row|
-        text = row.map(&:char).join
-        pos = 0
-        while (idx = text.index(@search_query, pos))
-          @search_matches << [abs_row, idx, @search_query.length]
-          pos = idx + 1
-        end
+        scan_row_for_matches(row, abs_row, matcher)
       end
 
       # Search grid
       screen.grid.each_with_index do |row, grid_row|
         abs_row = scrollback.size + grid_row
-        text = row.map(&:char).join
-        pos = 0
-        while (idx = text.index(@search_query, pos))
-          @search_matches << [abs_row, idx, @search_query.length]
-          pos = idx + 1
-        end
+        scan_row_for_matches(row, abs_row, matcher)
       end
 
       @search_index = @search_matches.size - 1 if @search_matches.any?
       scroll_to_match if @search_index >= 0
     end
 
+    # Returns an object that responds to `find_in(text, pos)` →
+    # `[start_idx, length]` or nil. Encapsulates the two axes —
+    # regex vs substring × case-sensitive vs case-insensitive —
+    # so the row scan stays loop-shaped regardless of mode.
+    # Returns nil if `query` is an invalid regex while in regex mode.
+    def build_search_matcher(query)
+      if @search_regex_mode
+        flags = @search_case_insensitive ? Regexp::IGNORECASE : 0
+        re = Regexp.new(query, flags) rescue nil
+        return nil unless re
+        ->(text, pos) {
+          m = re.match(text, pos)
+          m && [m.begin(0), m.end(0) - m.begin(0)]
+        }
+      elsif @search_case_insensitive
+        needle = query.downcase
+        len = needle.length
+        ->(text, pos) {
+          idx = text.downcase.index(needle, pos)
+          idx && [idx, len]
+        }
+      else
+        len = query.length
+        ->(text, pos) {
+          idx = text.index(query, pos)
+          idx && [idx, len]
+        }
+      end
+    end
+
+    def scan_row_for_matches(row, abs_row, matcher)
+      text = row.map(&:char).join
+      pos = 0
+      while pos <= text.length && (hit = matcher.call(text, pos))
+        idx, len = hit
+        # Ruby's `Regexp#match(s, pos)` past `s.length` still
+        # returns the trailing zero-width match, so any
+        # zero-width regex (`\b`, `(?=…)`, `^`, `$`) would
+        # spin forever without these two guards: bail if the
+        # match doesn't start at or after `pos`, and forcibly
+        # advance by 1 cell when the match is zero-width.
+        break if idx < pos
+        step = [len, 1].max
+        @search_matches << [abs_row, idx, step]
+        pos = idx + step
+      end
+    end
+
     def search_next
       return if @search_matches.empty?
       @search_index = (@search_index + 1) % @search_matches.size
@@ -2442,8 +2866,20 @@ module Echoes
     end
 
     def create_italic_nsfont(font)
+      # NSFontManager's convertFont:toHaveTrait: returns an
+      # autoreleased font whose pointer can shift call-to-call.
+      # Without this cache the same italic cell churns through a
+      # new pointer every frame, which busts y_offset_for_font's
+      # (pointer-keyed) cache, breaks the run-merging signature,
+      # and re-asks defaultLineHeightForFont — which on some
+      # fonts returns a subtly different float each time and
+      # makes italics jitter vertically in neovim et al.
+      @italic_font_cache ||= {}
+      cached = @italic_font_cache[font.to_i]
+      return cached if cached
       fm = ObjC::MSG_PTR.call(ObjC.cls('NSFontManager'), ObjC.sel('sharedFontManager'))
-      ObjC::MSG_PTR_1L.call(fm, ObjC.sel('convertFont:toHaveTrait:'), font, 0x1)  # NSItalicFontMask
+      italic = ObjC::MSG_PTR_1L.call(fm, ObjC.sel('convertFont:toHaveTrait:'), font, 0x1)  # NSItalicFontMask
+      @italic_font_cache[font.to_i] = ObjC.retain(italic)
     end
 
     # Used by Screen#put_multicell when an OSC 66 cell carries a
@@ -2465,15 +2901,408 @@ module Echoes
     end
 
     # Single point that wires every host-callback a Screen needs
-    # (clipboard, palette, glyph measurement, cell metrics). Called
-    # everywhere a new Screen comes into existence — initial setup,
-    # create_tab, split_horizontal/vertical, and the post-config
-    # update path.
-    def wire_screen_handlers(screen)
+    # (clipboard, palette, glyph measurement, cell metrics, OSC 7772
+    # capture). Called everywhere a new Screen comes into existence —
+    # initial setup, create_tab, split_horizontal/vertical, and the
+    # post-config update path.
+    def wire_screen_handlers(pane)
+      screen = pane.screen
       screen.clipboard_handler = method(:handle_clipboard)
       screen.glyph_measurer    = method(:measure_glyph)
       screen.cell_pixel_width  = @cell_width  if @cell_width
       screen.cell_pixel_height = @cell_height if @cell_height
+      # Now that the Screen knows its real cell metrics, re-send
+      # winsize so the pty's TIOCGWINSZ pixel fields carry the
+      # measured dims — kitten icat and similar tools read those
+      # via ioctl before falling back to CSI 14 t.
+      pane.refresh_pty_pixel_size
+      # Capture closure remembers which pane the OSC arrived for so
+      # the renderer grabs the right sub-rect (split layouts have
+      # several panes per view).
+      screen.capture_handler   = ->(path) { capture_pane_to_png(pane, path) }
+      screen.notification_handler = ->(title, message) { post_notification(pane, title, message) }
+      screen.display_info_handler = -> { display_info_json(pane) }
+      screen.open_window_handler  = ->(args) { open_window_from_osc(pane, args) }
+    end
+
+    # Post a macOS notification for an in-pane OSC 9 / OSC 777
+    # request. Uses `osascript -e 'display notification …'` — the
+    # one notification path that works without a properly-bundled
+    # native launcher.
+    #
+    # macOS gates notifications by the calling app's bundle. UN
+    # (UNUserNotificationCenter, the modern API) requires
+    # `bundleProxyForCurrentProcess` to resolve, which only happens
+    # when the process's `_NSGetExecutablePath` points inside a
+    # `.app` bundle. Echoes' launcher is a bash script that `exec`s
+    # into `ruby`, so the running process's main bundle is the
+    # ruby install — UN throws on startup. NSUserNotification has
+    # the same problem and is silently dropped on macOS 14+.
+    #
+    # osascript runs the AppleScript primitive `display notification`
+    # which posts through the Script Editor host bundle. **If banners
+    # don't appear, open System Settings → Notifications → Script
+    # Editor and enable "Banners" or "Alerts"** — the notification
+    # is being filed in Notification Center either way, but macOS's
+    # display gating is per-host-bundle and Script Editor defaults
+    # to "no banner alert". A proper fix is to ship Echoes with a
+    # compiled native launcher so the .app's bundle context is
+    # preserved across the exec into ruby; tracked as a follow-up.
+    # Post a macOS notification for an in-pane OSC 9 / OSC 777
+    # request. Prefers `terminal-notifier` when it's on $PATH —
+    # it ships as its own .app with its own bundle ID, so the
+    # notification registers under "terminal-notifier" in System
+    # Settings → Notifications, where the user can toggle banner
+    # permission and have it stick.
+    #
+    # Falls back to `osascript display notification` if
+    # terminal-notifier isn't installed. The osascript path goes
+    # through Script Editor's notification slot; whether a banner
+    # actually shows depends on Script Editor's "Alert style"
+    # setting in System Settings → Notifications (which is "None"
+    # by default).
+    #
+    # The real fix for Echoes-attributed notifications needs a
+    # compiled native launcher in Contents/MacOS/ so
+    # NSBundle.mainBundle survives the exec into ruby; until then
+    # `brew install terminal-notifier` is the recommended setup.
+    def post_notification(pane, title, message)
+      effective_title = (title && !title.empty? && title) || pane&.title || 'Echoes'
+      if (tn = terminal_notifier_path)
+        pid = Process.spawn(tn, '-title', effective_title.to_s, '-message', message.to_s,
+                            in: '/dev/null', out: '/dev/null', err: '/dev/null')
+      else
+        script = "display notification #{applescript_quote(message)} " \
+                 "with title #{applescript_quote(effective_title)}"
+        pid = Process.spawn('osascript', '-e', script,
+                            in: '/dev/null', out: '/dev/null', err: '/dev/null')
+      end
+      Process.detach(pid)
+    rescue StandardError => e
+      warn "echoes notification: #{e.class}: #{e.message}"
+    end
+
+    # Memoize the discovered path so we don't `which` on every call.
+    def terminal_notifier_path
+      return @terminal_notifier_path if defined?(@terminal_notifier_path)
+      candidates = %w[
+        /opt/homebrew/bin/terminal-notifier
+        /usr/local/bin/terminal-notifier
+      ]
+      path = candidates.find { |p| File.executable?(p) }
+      path ||= begin
+        which = `command -v terminal-notifier 2>/dev/null`.strip
+        which.empty? ? nil : which
+      end
+      @terminal_notifier_path = path
+    end
+
+    # AppleScript string literal: double-quoted, with `\` and `"`
+    # escaped. Newlines pass through as `\n` which AppleScript
+    # interprets as the literal two characters, which is fine for
+    # the "build done" use case.
+    def applescript_quote(str)
+      escaped = str.to_s.gsub('\\', '\\\\\\\\').gsub('"', '\\"')
+      %("#{escaped}")
+    end
+
+    # OSC 7772 ;capture handler. Writes the given pane's pixel buffer
+    # to `path`, dispatching format from the file extension:
+    #   .png  → rasterized PNG via NSBitmapImageRep (matches the
+    #           view's backing scale; 2× pixel dims on Retina).
+    #   else  → vector PDF via [NSView dataWithPDFInsideRect:]
+    #           (default; typical terminal screenshots are 5-20×
+    #           smaller than the PNG equivalent because text and
+    #           rects survive as drawing ops, not raster pixels).
+    # No reply on the wire — the caller polls the filesystem.
+    NS_BITMAP_IMAGE_FILE_TYPE_PNG = 4
+
+    # Pick raster vs vector by file extension. PDF is the default
+    # for anything other than `.png` — it's both the cheaper and
+    # more useful format for terminal content.
+    def self.capture_format_for(path)
+      File.extname(path).downcase == '.png' ? :png : :pdf
+    end
+
+    # OSC 7772 ;display-info handler. Returns a JSON string of
+    # one entry per NSScreen with pixel dimensions and two flags:
+    # `primary` (the screen that owns the menu bar) and `current`
+    # (the screen the requesting Echoes window is on). The caller
+    # uses `current` to pick "anywhere but here" for a second-screen
+    # presentation window. Empty `[]` on any AppKit failure.
+    def display_info_json(pane)
+      screens = ObjC::MSG_PTR.call(ObjC.cls('NSScreen'), ObjC.sel('screens'))
+      return '[]' if screens.nil? || screens.null?
+      count = ObjC::MSG_RET_L.call(screens, ObjC.sel('count'))
+
+      main_screen = ObjC::MSG_PTR.call(ObjC.cls('NSScreen'), ObjC.sel('mainScreen'))
+      win_screen = nsscreen_for_pane(pane)
+
+      entries = []
+      count.times do |i|
+        s = ObjC::MSG_PTR_L.call(screens, ObjC.sel('objectAtIndex:'), i)
+        _, _, w, h = nsrect_via_invocation(s, 'frame')
+        entries << {
+          'index'   => i,
+          'w'       => w.to_i,
+          'h'       => h.to_i,
+          'primary' => s.to_i == main_screen.to_i,
+          'current' => win_screen && s.to_i == win_screen.to_i,
+        }
+      end
+      JSON.generate(entries)
+    rescue StandardError => e
+      warn "echoes display-info: #{e.class}: #{e.message}"
+      '[]'
+    end
+
+    # Return the NSScreen of the NSWindow that owns `pane`, or nil
+    # if the pane isn't currently parented to any window state.
+    def nsscreen_for_pane(pane)
+      ws = @window_states.find { |w| w[:tabs]&.any? { |t| t.panes.include?(pane) } }
+      return nil unless ws && ws[:nswindow]
+      ObjC::MSG_PTR.call(ws[:nswindow], ObjC.sel('screen'))
+    end
+
+    # Invoke a zero-arg method on `target` that returns an NSRect
+    # (4 doubles). Fiddle can't model "return 4 doubles" directly,
+    # so we route through NSInvocation — same pattern as
+    # event_location does for NSPoint.
+    def nsrect_via_invocation(target, sel_name)
+      target_class = ObjC::MSG_PTR.call(target, ObjC.sel('class'))
+      sig = ObjC::MSG_PTR_1.call(
+        target_class, ObjC.sel('instanceMethodSignatureForSelector:'),
+        ObjC.sel(sel_name)
+      )
+      inv = ObjC::MSG_PTR_1.call(
+        ObjC.cls('NSInvocation'), ObjC.sel('invocationWithMethodSignature:'), sig
+      )
+      ObjC::MSG_VOID_1.call(inv, ObjC.sel('setSelector:'), ObjC.sel(sel_name))
+      ObjC::MSG_VOID_1.call(inv, ObjC.sel('invokeWithTarget:'), target)
+      buf = Fiddle::Pointer.malloc(32, Fiddle::RUBY_FREE)
+      ObjC::MSG_VOID_1.call(inv, ObjC.sel('getReturnValue:'), buf)
+      buf[0, 32].unpack('dddd')  # x, y, w, h
+    end
+
+    # Standard macOS / Homebrew search dirs we want a child to be
+    # able to find even when Echoes.app was launched by Finder
+    # (which strips PATH down to /usr/bin:/bin:/usr/sbin:/sbin).
+    DEFAULT_PATH_DIRS = %w[
+      /opt/homebrew/bin
+      /usr/local/bin
+      /usr/bin
+      /bin
+      /usr/sbin
+      /sbin
+    ].freeze
+
+    # Build the env Hash for a child program spawned via OSC 7772
+    # ;open-window. Starts from Echoes' own NSProcessInfo-equivalent
+    # env (Ruby's ENV) so PATH / HOME / USER / LANG / TERM / any
+    # ECHOES_* vars naturally propagate, then patches in defaults
+    # for the basics — Echoes.app launched by launchd from Finder
+    # inherits a minimal env, so a child that came in via a
+    # presentation tool can otherwise wind up without a usable
+    # PATH or LANG.
+    def child_env_for_open_window
+      env = ENV.to_h
+      env['PATH']  = merge_path(env['PATH'])
+      env['HOME']  = ENV['HOME'] || Dir.home
+      env['USER']  ||= (ENV['LOGNAME'] || `id -un 2>/dev/null`.chomp)
+      env['LANG']  ||= 'en_US.UTF-8'
+      env['TERM']  ||= Echoes.config.term
+      env
+    end
+
+    # Union the parent's PATH with DEFAULT_PATH_DIRS, preserving
+    # parent order so the parent's preferences win, and dedup so we
+    # don't double up entries the parent already has. Adding rather
+    # than replacing means a user who already exported a tuned PATH
+    # from their shell config keeps it intact.
+    def merge_path(parent_path)
+      seen = {}
+      out  = []
+      (parent_path.to_s.split(':') + DEFAULT_PATH_DIRS).each do |dir|
+        next if dir.empty? || seen[dir]
+        seen[dir] = true
+        out << dir
+      end
+      out.join(':')
+    end
+
+    # OSC 7772 ;open-window handler. Parses
+    # `display=N:program=<base64-argv>:fullscreen=yes|no`, decodes
+    # the base64 JSON-encoded argv, and opens a new window on
+    # NSScreen.screens[N] running that argv via PTY. fullscreen=yes
+    # uses the screen's full frame with a borderless, above-menu-bar
+    # window; otherwise visibleFrame with the default style mask.
+    # Fire-and-forget: no reply. The caller polls for whatever
+    # signal the launched program emits (e.g. a unix socket).
+    def open_window_from_osc(pane, args_str)
+      params = {}
+      args_str.to_s.split(':').each do |pair|
+        k, v = pair.split('=', 2)
+        next if k.nil? || k.empty? || v.nil?
+        params[k] = v
+      end
+
+      display_index = (params['display'] || '0').to_i
+      fullscreen    = params['fullscreen'] == 'yes'
+      program_b64   = params['program']
+      return unless program_b64
+
+      json_str = program_b64.delete("\r\n\t ").unpack1('m0')
+      argv = JSON.parse(json_str)
+      return unless argv.is_a?(Array) && !argv.empty?
+
+      open_external_window(argv: argv, display_index: display_index, fullscreen: fullscreen)
+    rescue StandardError => e
+      warn "echoes open-window: #{e.class}: #{e.message}"
+    end
+
+    # Open a new window running `argv` (e.g. ["/usr/local/bin/przn",
+    # "--audience", …]) on a specific display. Sizes the content
+    # area to the screen's frame (fullscreen) or visibleFrame, picks
+    # cell rows/cols that fit, and routes lifecycle through the
+    # standard tab/pane/window-state pipeline so the window
+    # auto-closes when the child program exits.
+    def open_external_window(argv:, display_index:, fullscreen:)
+      save_window_state
+
+      screens = ObjC::MSG_PTR.call(ObjC.cls('NSScreen'), ObjC.sel('screens'))
+      count = ObjC::MSG_RET_L.call(screens, ObjC.sel('count'))
+      return if display_index < 0 || display_index >= count
+      target = ObjC::MSG_PTR_L.call(screens, ObjC.sel('objectAtIndex:'), display_index)
+
+      rect_sel = fullscreen ? 'frame' : 'visibleFrame'
+      sx, sy, sw, sh = nsrect_via_invocation(target, rect_sel)
+
+      cols = (sw / @cell_width).floor
+      rows = (sh / @cell_height).floor
+      cols = [cols, 20].max
+      rows = [rows, 5].max
+
+      tab = Tab.new(command: argv, rows: rows, cols: cols, embedded: false,
+                    env: child_env_for_open_window)
+      tab.title = File.basename(argv.first.to_s)
+      tab.panes.each { |pn| wire_screen_handlers(pn) }
+
+      # Borderless mask (0) for fullscreen; default chrome otherwise.
+      style_mask = fullscreen ? 0 : ObjC::NSWindowStyleMaskDefault
+      new_window = ObjC::MSG_PTR.call(ObjC.cls('NSWindow'), ObjC.sel('alloc'))
+      new_window = ObjC::MSG_PTR_RECT_L_L_I.call(
+        new_window, ObjC.sel('initWithContentRect:styleMask:backing:defer:'),
+        sx, sy, sw, sh, style_mask, ObjC::NSBackingStoreBuffered, 0
+      )
+      ObjC::MSG_VOID_1.call(new_window, ObjC.sel('setTitle:'), ObjC.nsstring(tab.title))
+      ObjC::MSG_VOID_L.call(new_window, ObjC.sel('setCollectionBehavior:'), 1 << 7)
+      ObjC::MSG_VOID_I.call(new_window, ObjC.sel('setAcceptsMouseMovedEvents:'), 1)
+      if fullscreen
+        # NSMainMenuWindowLevel + 1 = 25 = NSStatusWindowLevel; floats
+        # above the menu bar so the presentation truly fills the
+        # screen even without going through AppKit's fullscreen
+        # transition.
+        ObjC::MSG_VOID_L.call(new_window, ObjC.sel('setLevel:'), 25)
+      end
+
+      new_view = ObjC::MSG_PTR.call(@view_class, ObjC.sel('alloc'))
+      new_view = ObjC::MSG_PTR_RECT.call(new_view, ObjC.sel('initWithFrame:'),
+                                          0.0, 0.0, sw, sh)
+      drag_types = ObjC::MSG_PTR_1.call(ObjC.cls('NSArray'), ObjC.sel('arrayWithObject:'),
+                                         ObjC::NSPasteboardTypeFileURL)
+      ObjC::MSG_VOID_1.call(new_view, ObjC.sel('registerForDraggedTypes:'), drag_types)
+
+      ObjC::MSG_VOID_1.call(new_window, ObjC.sel('setContentView:'), new_view)
+      ObjC::MSG_VOID_1.call(new_window, ObjC.sel('makeKeyAndOrderFront:'), @app)
+      ObjC::MSG_VOID_1.call(new_window, ObjC.sel('makeFirstResponder:'), new_view)
+      ObjC::MSG_VOID_I.call(@app, ObjC.sel('activateIgnoringOtherApps:'), 1)
+
+      nc = ObjC::MSG_PTR.call(ObjC.cls('NSNotificationCenter'), ObjC.sel('defaultCenter'))
+      ObjC::MSG_VOID_4.call(nc, ObjC.sel('addObserver:selector:name:object:'),
+        new_view, ObjC.sel('windowDidBecomeKey:'),
+        ObjC.nsstring('NSWindowDidBecomeKeyNotification'), new_window)
+      ObjC::MSG_VOID_4.call(nc, ObjC.sel('addObserver:selector:name:object:'),
+        new_view, ObjC.sel('windowDidResignKey:'),
+        ObjC.nsstring('NSWindowDidResignKeyNotification'), new_window)
+
+      @window = new_window
+      @view = new_view
+      @tabs = [tab]
+      @active_tab = 0
+      @search_mode = false
+      @search_query = +""
+      @search_matches = []
+      @search_index = -1
+      @search_regex_mode = false
+      @search_case_insensitive = false
+      @bell_flash = 0
+      @marked_text = nil
+      @current_event = nil
+      @selection_anchor = nil
+      @selection_end = nil
+      @selection_word_anchor = nil
+      @window_focused = true
+
+      ws = {}
+      @window_states << ws
+      @view_to_ws[@view.to_i] = ws
+      save_window_state
+    end
+
+    def capture_pane_to_png(pane, path)
+      return unless @view
+      tab = current_tab
+      return unless tab
+      rect_info = tab.pane_tree.layout(0, 0, @cols, @rows).find { |r| r[:pane] == pane }
+      return unless rect_info
+
+      gy = grid_y_offset
+      px = rect_info[:x] * @cell_width
+      py = gy + rect_info[:y] * @cell_height
+      pw = rect_info[:w] * @cell_width
+      ph = rect_info[:h] * @cell_height
+
+      bytes =
+        case self.class.capture_format_for(path)
+        when :png then png_bytes_for_view_rect(px, py, pw, ph)
+        else           pdf_bytes_for_view_rect(px, py, pw, ph)
+        end
+      return unless bytes
+      File.binwrite(path, bytes)
+    rescue => e
+      warn "echoes capture: #{e.class}: #{e.message}"
+    end
+
+    def pdf_bytes_for_view_rect(px, py, pw, ph)
+      data = ObjC::MSG_PTR_RECT.call(
+        @view, ObjC.sel('dataWithPDFInsideRect:'),
+        px, py, pw, ph
+      )
+      return nil if data.nil? || data.null?
+      length    = ObjC::MSG_RET_L.call(data, ObjC.sel('length'))
+      bytes_ptr = ObjC::MSG_PTR.call(data, ObjC.sel('bytes'))
+      bytes_ptr.to_str(length)
+    end
+
+    def png_bytes_for_view_rect(px, py, pw, ph)
+      rep = ObjC::MSG_PTR_RECT.call(
+        @view, ObjC.sel('bitmapImageRepForCachingDisplayInRect:'),
+        px, py, pw, ph
+      )
+      return nil if rep.nil? || rep.null?
+      ObjC::MSG_VOID_RECT_1.call(
+        @view, ObjC.sel('cacheDisplayInRect:toBitmapImageRep:'),
+        px, py, pw, ph, rep
+      )
+      empty_dict = ObjC.nsdict({})
+      data = ObjC::MSG_PTR_L_1.call(
+        rep, ObjC.sel('representationUsingType:properties:'),
+        NS_BITMAP_IMAGE_FILE_TYPE_PNG, empty_dict
+      )
+      return nil if data.nil? || data.null?
+      length    = ObjC::MSG_RET_L.call(data, ObjC.sel('length'))
+      bytes_ptr = ObjC::MSG_PTR.call(data, ObjC.sel('bytes'))
+      bytes_ptr.to_str(length)
     end
 
     def create_nsfont(size, family: nil)
@@ -2507,6 +3336,8 @@ module Echoes
       leading = ObjC::MSG_RET_D.call(@font, ObjC.sel('leading'))
       @cell_height = ascender - descender + leading
       @font_default_line_height = ObjC::MSG_RET_D.call(@font, ObjC.sel('defaultLineHeightForFont'))
+      @font_default_ascender = ascender
+      @font_default_family = ObjC.to_ruby_string(ObjC::MSG_PTR.call(@font, ObjC.sel('familyName')))
       @font_y_offset_cache = {}
 
       # Propagate cell metrics to all pane screens (sixel sizing,
@@ -2514,7 +3345,7 @@ module Echoes
       # idempotent so re-wiring on every font change is fine.
       @window_states.each do |ws|
         ws[:tabs]&.each do |tab|
-          tab.panes.each { |pane| wire_screen_handlers(pane.screen) }
+          tab.panes.each { |pane| wire_screen_handlers(pane) }
         end
       end
     end
@@ -2536,18 +3367,39 @@ module Echoes
       @font_cache[char]
     end
 
-    # AppKit's NSString drawing positions the line box using
-    # defaultLineHeightForFont, which can differ between regular and bold
-    # variants of the same font (e.g. PlemolJP35 Console NF: regular=24, bold=29).
-    # That difference shifts the bold baseline downward versus regular by
-    # `bold_lh - regular_lh` points. Compensate by shifting the draw origin
-    # by the negative of that difference so all baselines coincide.
+    # Aligns a non-@font run's baseline with the @font baseline.
+    # AppKit's drawAtPoint pins the line box top to (x, y), but
+    # the formula it uses to derive the baseline from y differs
+    # between same-family variants and unrelated families:
+    #
+    #   - Same-family bold/italic siblings: AppKit lays out using
+    #     `defaultLineHeightForFont`, and a wider bold LH pushes
+    #     the bold baseline downward (e.g. PlemolJP35 Console NF:
+    #     regular LH=24, bold LH=29). Shifting by LH-delta puts
+    #     them back on the same row.
+    #   - Unrelated fallbacks (CJK, emoji, symbol fonts pulled in
+    #     by CTFontCreateForString): LH-delta tracks total line
+    #     box height but not where the *glyph* sits inside it. A
+    #     geometric-symbol font with a smaller ascender ends up
+    #     rendering ▶ visibly too high alongside ASCII text. The
+    #     ascender delta is the better metric here.
+    #
+    # So pick the metric based on whether the font shares
+    # @font's family.
     def y_offset_for_font(font)
       return 0.0 if font.to_i == @font.to_i
       cached = @font_y_offset_cache[font.to_i]
       return cached if cached
-      font_lh = ObjC::MSG_RET_D.call(font, ObjC.sel('defaultLineHeightForFont'))
-      @font_y_offset_cache[font.to_i] = @font_default_line_height - font_lh
+      font_family = ObjC.to_ruby_string(ObjC::MSG_PTR.call(font, ObjC.sel('familyName')))
+      offset =
+        if font_family == @font_default_family
+          font_lh = ObjC::MSG_RET_D.call(font, ObjC.sel('defaultLineHeightForFont'))
+          @font_default_line_height - font_lh
+        else
+          font_ascender = ObjC::MSG_RET_D.call(font, ObjC.sel('ascender'))
+          @font_default_ascender - font_ascender
+        end
+      @font_y_offset_cache[font.to_i] = offset
     end
 
     MODIFIED_KEYS = {
@@ -2649,8 +3501,10 @@ module Echoes
         [1.0,  1.0,  1.0],   # 15: bright white
       ]
 
-      # Override with user-configured palette
-      if (palette = Echoes.config.color_palette)
+      # Override with active-profile palette (falls through to the
+      # legacy top-level Echoes.config.color_palette when the user's
+      # config doesn't declare any profiles).
+      if (palette = @active_profile&.color_palette)
         palette.each_with_index do |rgb, i|
           ansi_rgb[i] = rgb if i < 16 && rgb
         end