batplot 1.7.24__py3-none-any.whl → 1.7.26__py3-none-any.whl

batplot/cpc_interactive.py

@@ -36,11 +36,45 @@ from __future__ import annotations
 from typing import Dict, Optional
 import json
 import os
+import sys
+import contextlib
+from io import StringIO
 
 import matplotlib.pyplot as plt
 from matplotlib.ticker import AutoMinorLocator, NullFormatter, NullLocator
 import random as _random
 
+
+class _FilterIMKWarning:
+    """Filter that suppresses macOS IMKCFRunLoopWakeUpReliable warnings while preserving other errors."""
+    def __init__(self, original_stderr):
+        self.original_stderr = original_stderr
+    
+    def write(self, message):
+        # Filter out the harmless macOS IMK warning
+        if 'IMKCFRunLoopWakeUpReliable' not in message:
+            self.original_stderr.write(message)
+    
+    def flush(self):
+        self.original_stderr.flush()
+
+
+def _safe_input(prompt: str = "") -> str:
+    """Wrapper around input() that suppresses macOS IMKCFRunLoopWakeUpReliable warnings.
+    
+    This is a harmless macOS system message that appears when using input() in terminals.
+    """
+    # Filter stderr to hide macOS IMK warnings while preserving other errors
+    original_stderr = sys.stderr
+    sys.stderr = _FilterIMKWarning(original_stderr)
+    try:
+        result = input(prompt)
+        return result
+    except (KeyboardInterrupt, EOFError):
+        raise
+    finally:
+        sys.stderr = original_stderr
+
 from .ui import (
     resize_plot_frame, resize_canvas,
     update_tick_visibility as _ui_update_tick_visibility,
@@ -57,10 +91,20 @@ from .utils import (
     get_organized_path,
 )
 import time
-from .color_utils import resolve_color_token
+from .color_utils import resolve_color_token, color_block, palette_preview, manage_user_colors, get_user_color_list, ensure_colormap
 
 
 def _legend_no_frame(ax, *args, **kwargs):
+    # Compact legend defaults and labelcolor matching marker/line color
+    kwargs.setdefault('frameon', False)
+    kwargs.setdefault('handlelength', 1.0)
+    kwargs.setdefault('handletextpad', 0.35)
+    kwargs.setdefault('labelspacing', 0.25)
+    kwargs.setdefault('borderaxespad', 0.5)
+    kwargs.setdefault('borderpad', 0.3)
+    kwargs.setdefault('columnspacing', 0.6)
+    # Let matplotlib color legend text from line/marker colors
+    kwargs.setdefault('labelcolor', 'linecolor')
     leg = ax.legend(*args, **kwargs)
     if leg is not None:
         try:
@@ -69,6 +113,27 @@ def _legend_no_frame(ax, *args, **kwargs):
             pass
     return leg
 
+
+def _visible_handles_labels(ax, ax2):
+    """Return handles/labels for visible artists only."""
+    try:
+        h1, l1 = ax.get_legend_handles_labels()
+    except Exception:
+        h1, l1 = [], []
+    try:
+        h2, l2 = ax2.get_legend_handles_labels()
+    except Exception:
+        h2, l2 = [], []
+    H, L = [], []
+    for h, l in list(zip(h1, l1)) + list(zip(h2, l2)):
+        try:
+            if hasattr(h, 'get_visible') and not h.get_visible():
+                continue
+        except Exception:
+            pass
+        H.append(h); L.append(l)
+    return H, L
+
 def _colorize_menu(text):
     """Colorize menu items: command in cyan, colon in white, description in default."""
     if ':' not in text:
@@ -99,8 +164,8 @@ def _color_of(artist):
     return None
 
 
-def _get_legend_title(fig, default: str = "Legend") -> str:
-    """Fetch stored legend title, falling back to current legend text or default."""
+def _get_legend_title(fig, default: Optional[str] = None) -> Optional[str]:
+    """Fetch stored legend title, falling back to current legend text or None."""
     try:
         title = getattr(fig, '_cpc_legend_title', None)
         if isinstance(title, str) and title:
@@ -215,7 +280,7 @@ def _print_menu():
         " v: show/hide files",
     ]
     col2 = [
-        "r: rename titles",
+        "r: rename",
         "x: x range",
         "y: y ranges",
     ]
@@ -262,9 +327,22 @@ def _print_file_list(file_data, current_idx):
     print()
 
 
-def _rebuild_legend(ax, ax2, file_data):
-    """Rebuild legend from all visible files."""
+def _rebuild_legend(ax, ax2, file_data, preserve_position=True):
+    """Rebuild legend from all visible files.
+    
+    Args:
+        preserve_position: If True, preserve legend position after rebuilding.
+    """
     try:
+        fig = ax.figure
+        # Get stored position before rebuilding
+        xy_in = None
+        if preserve_position:
+            try:
+                xy_in = getattr(fig, '_cpc_legend_xy_in', None)
+            except Exception:
+                pass
+        
         h1, l1 = ax.get_legend_handles_labels()
         h2, l2 = ax2.get_legend_handles_labels()
         # Filter to only visible items
@@ -273,8 +351,22 @@ def _rebuild_legend(ax, ax2, file_data):
             if h.get_visible():
                 h_all.append(h)
                 l_all.append(l)
+        
         if h_all:
-            _legend_no_frame(ax, h_all, l_all, loc='best', borderaxespad=1.0, title=_get_legend_title(ax.figure))
+            # Get legend title (None if not set, to avoid showing "Legend")
+            leg_title = _get_legend_title(fig, default=None)
+            
+            if xy_in is not None and preserve_position:
+                # Use stored position
+                try:
+                    fw, fh = fig.get_size_inches()
+                    fx = 0.5 + float(xy_in[0]) / float(fw)
+                    fy = 0.5 + float(xy_in[1]) / float(fh)
+                    _legend_no_frame(ax, h_all, l_all, loc='center', bbox_to_anchor=(fx, fy), bbox_transform=fig.transFigure, borderaxespad=1.0, title=leg_title)
+                except Exception:
+                    _legend_no_frame(ax, h_all, l_all, loc='best', borderaxespad=1.0, title=leg_title)
+            else:
+                _legend_no_frame(ax, h_all, l_all, loc='best', borderaxespad=1.0, title=leg_title)
         else:
             leg = ax.get_legend()
             if leg:
@@ -338,24 +430,35 @@ def _style_snapshot(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_data=Non
             return None
         return None
 
-    # Current tick visibility (best-effort from axes)
+    def _label_visible(lbl):
+        try:
+            return bool(lbl.get_visible()) and bool(lbl.get_text())
+        except Exception:
+            return bool(lbl.get_text()) if hasattr(lbl, 'get_text') else False
+
+    # Current tick visibility (prefer persisted WASD state when available)
     tick_vis = {
-        'bx': True,
-        'tx': False,
-        'ly': True,
-        'ry': True,
-        'mbx': False,
-        'mtx': False,
-        'mly': False,
-        'mry': False,
+        'bx': True, 'tx': False, 'ly': True, 'ry': True,
+        'mbx': False, 'mtx': False, 'mly': False, 'mry': False,
     }
     try:
-        # Infer from current axes state
-        import matplotlib as _mpl
-        tick_vis['bx'] = any(lbl.get_visible() for lbl in ax.get_xticklabels())
-        tick_vis['tx'] = False  # CPC doesn't duplicate top labels by default
-        tick_vis['ly'] = any(lbl.get_visible() for lbl in ax.get_yticklabels())
-        tick_vis['ry'] = any(lbl.get_visible() for lbl in ax2.get_yticklabels())
+        wasd_from_fig = getattr(fig, '_cpc_wasd_state', None)
+        if isinstance(wasd_from_fig, dict) and wasd_from_fig:
+            # Use stored state (authoritative)
+            tick_vis['bx'] = bool(wasd_from_fig.get('bottom', {}).get('labels', True))
+            tick_vis['tx'] = bool(wasd_from_fig.get('top', {}).get('labels', False))
+            tick_vis['ly'] = bool(wasd_from_fig.get('left', {}).get('labels', True))
+            tick_vis['ry'] = bool(wasd_from_fig.get('right', {}).get('labels', True))
+            tick_vis['mbx'] = bool(wasd_from_fig.get('bottom', {}).get('minor', False))
+            tick_vis['mtx'] = bool(wasd_from_fig.get('top', {}).get('minor', False))
+            tick_vis['mly'] = bool(wasd_from_fig.get('left', {}).get('minor', False))
+            tick_vis['mry'] = bool(wasd_from_fig.get('right', {}).get('minor', False))
+        else:
+            # Infer from current axes state
+            tick_vis['bx'] = any(lbl.get_visible() for lbl in ax.get_xticklabels())
+            tick_vis['tx'] = False  # CPC doesn't duplicate top labels by default
+            tick_vis['ly'] = any(lbl.get_visible() for lbl in ax.get_yticklabels())
+            tick_vis['ry'] = any(lbl.get_visible() for lbl in ax2.get_yticklabels())
     except Exception:
         pass
 
@@ -373,36 +476,38 @@ def _style_snapshot(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_data=Non
         except Exception:
             return False
     
-    wasd_state = {
-        'bottom': {
-            'spine': _get_spine_visible(ax, 'bottom'),
-            'ticks': bool(tick_vis.get('bx', True)),
-            'minor': bool(tick_vis.get('mbx', False)),
-            'labels': bool(tick_vis.get('bx', True)),  # bottom x labels
-            'title': bool(ax.get_xlabel())  # bottom x title
-        },
-        'top': {
-            'spine': _get_spine_visible(ax, 'top'),
-            'ticks': bool(tick_vis.get('tx', False)),
-            'minor': bool(tick_vis.get('mtx', False)),
-            'labels': bool(tick_vis.get('tx', False)),
-            'title': bool(getattr(ax, '_top_xlabel_text', None) and getattr(ax._top_xlabel_text, 'get_visible', lambda: False)())
-        },
-        'left': {
-            'spine': _get_spine_visible(ax, 'left'),
-            'ticks': bool(tick_vis.get('ly', True)),
-            'minor': bool(tick_vis.get('mly', False)),
-            'labels': bool(tick_vis.get('ly', True)),  # left y labels (capacity)
-            'title': bool(ax.get_ylabel())  # left y title
-        },
-        'right': {
-            'spine': _get_spine_visible(ax2, 'right'),
-            'ticks': bool(tick_vis.get('ry', True)),
-            'minor': bool(tick_vis.get('mry', False)),
-            'labels': bool(tick_vis.get('ry', True)),  # right y labels (efficiency)
-            'title': bool(ax2.get_ylabel())  # right y title
-        },
-    }
+    wasd_state = getattr(fig, '_cpc_wasd_state', None)
+    if not isinstance(wasd_state, dict) or not wasd_state:
+        wasd_state = {
+            'bottom': {
+                'spine': _get_spine_visible(ax, 'bottom'),
+                'ticks': bool(tick_vis.get('bx', True)),
+                'minor': bool(tick_vis.get('mbx', False)),
+                'labels': bool(tick_vis.get('bx', True)),  # bottom x labels
+                'title': bool(ax.get_xlabel())  # bottom x title
+            },
+            'top': {
+                'spine': _get_spine_visible(ax, 'top'),
+                'ticks': bool(tick_vis.get('tx', False)),
+                'minor': bool(tick_vis.get('mtx', False)),
+                'labels': bool(tick_vis.get('tx', False)),
+                'title': bool(getattr(ax, '_top_xlabel_text', None) and getattr(ax._top_xlabel_text, 'get_visible', lambda: False)())
+            },
+            'left': {
+                'spine': _get_spine_visible(ax, 'left'),
+                'ticks': bool(tick_vis.get('ly', True)),
+                'minor': bool(tick_vis.get('mly', False)),
+                'labels': bool(tick_vis.get('ly', True)),  # left y labels (capacity)
+                'title': _label_visible(ax.yaxis.label)  # left y title
+            },
+            'right': {
+                'spine': _get_spine_visible(ax2, 'right'),
+                'ticks': bool(tick_vis.get('ry', True)),
+                'minor': bool(tick_vis.get('mry', False)),
+                'labels': bool(tick_vis.get('ry', True)),  # right y labels (efficiency)
+                'title': _label_visible(ax2.yaxis.label)  # right y title respects visibility
+            },
+        }
 
     # Capture legend state
     legend_visible = False
@@ -487,16 +592,19 @@ def _style_snapshot(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_data=Non
         'series': {
             'charge': {
                 'color': _color_of(sc_charge),
+                'marker': getattr(sc_charge, 'get_marker', lambda: 'o')(),
                 'markersize': float(getattr(sc_charge, 'get_sizes', lambda: [32])()[0]) if hasattr(sc_charge, 'get_sizes') else 32.0,
                 'alpha': float(sc_charge.get_alpha()) if sc_charge.get_alpha() is not None else 1.0,
             },
             'discharge': {
                 'color': _color_of(sc_discharge),
+                'marker': getattr(sc_discharge, 'get_marker', lambda: 's')(),
                 'markersize': float(getattr(sc_discharge, 'get_sizes', lambda: [32])()[0]) if hasattr(sc_discharge, 'get_sizes') else 32.0,
                 'alpha': float(sc_discharge.get_alpha()) if sc_discharge.get_alpha() is not None else 1.0,
             },
             'efficiency': {
                 'color': (sc_eff.get_facecolors()[0].tolist() if hasattr(sc_eff, 'get_facecolors') and len(sc_eff.get_facecolors()) else '#2ca02c'),
+                'marker': getattr(sc_eff, 'get_marker', lambda: '^')(),
                 'markersize': float(getattr(sc_eff, 'get_sizes', lambda: [40])()[0]) if hasattr(sc_eff, 'get_sizes') else 40.0,
                 'alpha': float(sc_eff.get_alpha()) if sc_eff.get_alpha() is not None else 1.0,
                 'visible': bool(getattr(sc_eff, 'get_visible', lambda: True)()),
@@ -508,15 +616,42 @@ def _style_snapshot(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_data=Non
     if file_data and isinstance(file_data, list) and len(file_data) > 0:
         multi_files = []
         for f in file_data:
+            sc_chg = f.get('sc_charge')
+            sc_dchg = f.get('sc_discharge')
+            sc_eff = f.get('sc_eff')
             file_info = {
                 'filename': f.get('filename', 'unknown'),
                 'visible': f.get('visible', True),
-                'charge_color': _color_of(f.get('sc_charge')),
-                'discharge_color': _color_of(f.get('sc_discharge')),
-                'efficiency_color': _color_of(f.get('sc_eff')),
+                'charge_color': _color_of(sc_chg),
+                'charge_marker': getattr(sc_chg, 'get_marker', lambda: 'o')() if sc_chg else 'o',
+                'discharge_color': _color_of(sc_dchg),
+                'discharge_marker': getattr(sc_dchg, 'get_marker', lambda: 's')() if sc_dchg else 's',
+                'efficiency_color': _color_of(sc_eff),
+                'efficiency_marker': getattr(sc_eff, 'get_marker', lambda: '^')() if sc_eff else '^',
             }
+            # Save legend labels
+            try:
+                sc_chg = f.get('sc_charge')
+                sc_dchg = f.get('sc_discharge')
+                sc_eff = f.get('sc_eff')
+                if sc_chg and hasattr(sc_chg, 'get_label'):
+                    file_info['charge_label'] = sc_chg.get_label() or ''
+                if sc_dchg and hasattr(sc_dchg, 'get_label'):
+                    file_info['discharge_label'] = sc_dchg.get_label() or ''
+                if sc_eff and hasattr(sc_eff, 'get_label'):
+                    file_info['efficiency_label'] = sc_eff.get_label() or ''
+            except Exception:
+                pass
             multi_files.append(file_info)
         cfg['multi_files'] = multi_files
+    else:
+        # Single file mode: save legend labels
+        try:
+            cfg['series']['charge']['label'] = sc_charge.get_label() if hasattr(sc_charge, 'get_label') else ''
+            cfg['series']['discharge']['label'] = sc_discharge.get_label() if hasattr(sc_discharge, 'get_label') else ''
+            cfg['series']['efficiency']['label'] = sc_eff.get_label() if hasattr(sc_eff, 'get_label') else ''
+        except Exception:
+            pass
     
     return cfg
 
@@ -644,6 +779,13 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
         # Apply marker sizes and alpha globally to all files in multi-file mode
         if is_multi_file:
             for f in file_data:
+                # Marker types (global)
+                if ch.get('marker') is not None and hasattr(f['sc_charge'], 'set_marker'):
+                    f['sc_charge'].set_marker(ch['marker'])
+                if dh.get('marker') is not None and hasattr(f['sc_discharge'], 'set_marker'):
+                    f['sc_discharge'].set_marker(dh['marker'])
+                if ef.get('marker') is not None and hasattr(f['sc_eff'], 'set_marker'):
+                    f['sc_eff'].set_marker(ef['marker'])
                 # Marker sizes (global)
                 if ch.get('markersize') is not None and hasattr(f['sc_charge'], 'set_sizes'):
                     f['sc_charge'].set_sizes([float(ch['markersize'])])
@@ -677,6 +819,8 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
             if ch:
                 if ch.get('color') is not None:
                     sc_charge.set_color(ch['color'])
+                if ch.get('marker') is not None and hasattr(sc_charge, 'set_marker'):
+                    sc_charge.set_marker(ch['marker'])
                 if ch.get('markersize') is not None and hasattr(sc_charge, 'set_sizes'):
                     sc_charge.set_sizes([float(ch['markersize'])])
                 if ch.get('alpha') is not None:
@@ -684,6 +828,8 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
             if dh:
                 if dh.get('color') is not None:
                     sc_discharge.set_color(dh['color'])
+                if dh.get('marker') is not None and hasattr(sc_discharge, 'set_marker'):
+                    sc_discharge.set_marker(dh['marker'])
                 if dh.get('markersize') is not None and hasattr(sc_discharge, 'set_sizes'):
                     sc_discharge.set_sizes([float(dh['markersize'])])
                 if dh.get('alpha') is not None:
@@ -694,6 +840,8 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
                         sc_eff.set_color(ef['color'])
                     except Exception:
                         pass
+                if ef.get('marker') is not None and hasattr(sc_eff, 'set_marker'):
+                    sc_eff.set_marker(ef['marker'])
                 if ef.get('markersize') is not None and hasattr(sc_eff, 'set_sizes'):
                     sc_eff.set_sizes([float(ef['markersize'])])
                 if ef.get('alpha') is not None:
@@ -721,6 +869,27 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
                 leg.set_visible(leg_visible)
             if leg_visible:
                 _apply_legend_position()
+                # Re-apply legend label colors to match handles after position/visibility changes
+                try:
+                    leg = ax.get_legend()
+                    if leg is not None:
+                        handles = list(getattr(leg, "legendHandles", []))
+                        for h, txt in zip(handles, leg.get_texts()):
+                            col = _color_of(h)
+                            if col is None and hasattr(h, 'get_edgecolor'):
+                                col = h.get_edgecolor()
+                            if isinstance(col, (list, tuple)) and len(col) and not isinstance(col, str):
+                                col = col[0]
+                            try:
+                                import numpy as _np
+                                if hasattr(col, "__len__") and not isinstance(col, str):
+                                    col = tuple(_np.array(col).ravel().tolist())
+                            except Exception:
+                                pass
+                            if col is not None:
+                                txt.set_color(col)
+                except Exception:
+                    pass
     except Exception:
         pass
     # Apply tick visibility/widths and spines
@@ -728,6 +897,11 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
         tk = cfg.get('ticks', {})
         # Try wasd_state first (version 2), fall back to visibility dict (version 1)
         wasd = cfg.get('wasd_state', {})
+        if isinstance(wasd, dict) and wasd:
+            try:
+                setattr(fig, '_cpc_wasd_state', wasd)
+            except Exception:
+                pass
         if wasd:
             # Use WASD state (20 parameters)
             bx = bool(wasd.get('bottom', {}).get('labels', True))
@@ -754,6 +928,12 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
             ax.tick_params(axis='x', bottom=bx, labelbottom=bx, top=tx, labeltop=tx)
             ax.tick_params(axis='y', left=ly, labelleft=ly)
             ax2.tick_params(axis='y', right=ry, labelright=ry)
+            try:
+                ax.xaxis.label.set_visible(bool(wasd.get('bottom', {}).get('title', True)) if wasd else bx)
+                ax.yaxis.label.set_visible(bool(wasd.get('left', {}).get('title', True)) if wasd else ly)
+                ax2.yaxis.label.set_visible(bool(wasd.get('right', {}).get('title', True)) if wasd else ry)
+            except Exception:
+                pass
             # Minor ticks
             from matplotlib.ticker import AutoMinorLocator, NullFormatter, NullLocator, NullLocator
             if mbx or mtx:
@@ -949,6 +1129,94 @@ def _apply_style(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, cfg: Dict, file_
         _ui_position_right_ylabel(ax2, fig, tick_state)
     except Exception:
         pass
+    # Restore legend labels
+    try:
+        if is_multi_file and file_data:
+            multi_files = cfg.get('multi_files', [])
+            if multi_files and len(multi_files) == len(file_data):
+                for i, f_info in enumerate(multi_files):
+                    if i < len(file_data):
+                        f = file_data[i]
+                        # Restore colors FIRST (before labels)
+                        if 'charge_color' in f_info and f.get('sc_charge'):
+                            try:
+                                col = f_info['charge_color']
+                                f['sc_charge'].set_color(col)
+                                f['color'] = col
+                                # Force update of facecolors for scatter plots
+                                if hasattr(f['sc_charge'], 'set_facecolors'):
+                                    from matplotlib.colors import to_rgba
+                                    rgba = to_rgba(col)
+                                    f['sc_charge'].set_facecolors(rgba)
+                            except Exception:
+                                pass
+                        if 'discharge_color' in f_info and f.get('sc_discharge'):
+                            try:
+                                col = f_info['discharge_color']
+                                f['sc_discharge'].set_color(col)
+                                # Force update of facecolors for scatter plots
+                                if hasattr(f['sc_discharge'], 'set_facecolors'):
+                                    from matplotlib.colors import to_rgba
+                                    rgba = to_rgba(col)
+                                    f['sc_discharge'].set_facecolors(rgba)
+                            except Exception:
+                                pass
+                        if 'efficiency_color' in f_info and f.get('sc_eff'):
+                            try:
+                                col = f_info['efficiency_color']
+                                f['sc_eff'].set_color(col)
+                                f['eff_color'] = col
+                                # Force update of facecolors for scatter plots
+                                if hasattr(f['sc_eff'], 'set_facecolors'):
+                                    from matplotlib.colors import to_rgba
+                                    rgba = to_rgba(col)
+                                    f['sc_eff'].set_facecolors(rgba)
+                            except Exception:
+                                pass
+                        # Restore legend labels
+                        if 'charge_label' in f_info and f.get('sc_charge'):
+                            try:
+                                f['sc_charge'].set_label(f_info['charge_label'])
+                            except Exception:
+                                pass
+                        if 'discharge_label' in f_info and f.get('sc_discharge'):
+                            try:
+                                f['sc_discharge'].set_label(f_info['discharge_label'])
+                            except Exception:
+                                pass
+                        if 'efficiency_label' in f_info and f.get('sc_eff'):
+                            try:
+                                f['sc_eff'].set_label(f_info['efficiency_label'])
+                            except Exception:
+                                pass
+                        # Update filename if present
+                        if 'filename' in f_info:
+                            f['filename'] = f_info['filename']
+        else:
+            # Single file mode: restore legend labels
+            s = cfg.get('series', {})
+            ch = s.get('charge', {})
+            dh = s.get('discharge', {})
+            ef = s.get('efficiency', {})
+            if 'label' in ch and hasattr(sc_charge, 'set_label'):
+                try:
+                    sc_charge.set_label(ch['label'])
+                except Exception:
+                    pass
+            if 'label' in dh and hasattr(sc_discharge, 'set_label'):
+                try:
+                    sc_discharge.set_label(dh['label'])
+                except Exception:
+                    pass
+            if 'label' in ef and hasattr(sc_eff, 'set_label'):
+                try:
+                    sc_eff.set_label(ef['label'])
+                except Exception:
+                    pass
+        # Rebuild legend after restoring labels
+        _rebuild_legend(ax, ax2, file_data, preserve_position=True)
+    except Exception:
+        pass
     try:
         fig.canvas.draw_idle()
     except Exception:
@@ -1061,8 +1329,22 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
     if file_data is None:
         # Backward compatibility: create file_data structure from single file
         # This allows the function to work with old code that passes individual artists
+        # Try to get filename from label if available
+        filename = 'Data'
+        try:
+            if hasattr(sc_charge, 'get_label') and sc_charge.get_label():
+                label = sc_charge.get_label()
+                # Extract filename from label like "filename (Chg)" or use label as-is
+                if ' (Chg)' in label:
+                    filename = label.replace(' (Chg)', '')
+                elif ' (Dch)' in label:
+                    filename = label.replace(' (Dch)', '')
+                elif label and label != 'Charge capacity':
+                    filename = label
+        except Exception:
+            pass
         file_data = [{
-            'filename': 'Data',  # Default filename
+            'filename': filename,
             'sc_charge': sc_charge,      # Charge capacity scatter artist
             'sc_discharge': sc_discharge,  # Discharge capacity scatter artist
             'sc_eff': sc_eff,            # Efficiency scatter artist
@@ -1105,6 +1387,19 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         'mly': False, # minor left y-axis ticks - hidden by default
         'mry': False, # minor right y-axis ticks - hidden by default
     }
+    try:
+        saved_wasd = getattr(fig, '_cpc_wasd_state', None)
+        if isinstance(saved_wasd, dict) and saved_wasd:
+            tick_state['bx'] = bool(saved_wasd.get('bottom', {}).get('labels', tick_state['bx']))
+            tick_state['tx'] = bool(saved_wasd.get('top', {}).get('labels', tick_state['tx']))
+            tick_state['ly'] = bool(saved_wasd.get('left', {}).get('labels', tick_state['ly']))
+            tick_state['ry'] = bool(saved_wasd.get('right', {}).get('labels', tick_state['ry']))
+            tick_state['mbx'] = bool(saved_wasd.get('bottom', {}).get('minor', tick_state['mbx']))
+            tick_state['mtx'] = bool(saved_wasd.get('top', {}).get('minor', tick_state['mtx']))
+            tick_state['mly'] = bool(saved_wasd.get('left', {}).get('minor', tick_state['mly']))
+            tick_state['mry'] = bool(saved_wasd.get('right', {}).get('minor', tick_state['mry']))
+    except Exception:
+        pass
 
     # --- Undo stack using style snapshots ---
     state_history = []  # list of cfg dicts
@@ -1169,6 +1464,27 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 if k in tick_state:
                     tick_state[k] = bool(v)
             _update_ticks()
+            # Re-apply legend text colors after state restore (undo)
+            try:
+                leg = ax.get_legend()
+                if leg is not None:
+                    handles = list(getattr(leg, "legendHandles", []))
+                    for h, txt in zip(handles, leg.get_texts()):
+                        col = _color_of(h)
+                        if col is None and hasattr(h, 'get_edgecolor'):
+                            col = h.get_edgecolor()
+                        if isinstance(col, (list, tuple)) and len(col) and not isinstance(col, str):
+                            col = col[0]
+                        try:
+                            import numpy as _np
+                            if hasattr(col, "__len__") and not isinstance(col, str):
+                                col = tuple(_np.array(col).ravel().tolist())
+                        except Exception:
+                            pass
+                        if col is not None:
+                            txt.set_color(col)
+            except Exception:
+                pass
             try:
                 fig.canvas.draw()
             except Exception:
@@ -1181,6 +1497,8 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         try:
             # Apply shared visibility to primary ax; then adjust twin for right side
             _ui_update_tick_visibility(ax, tick_state)
+            # Ensure left axis ticks/labels don't appear on right axis
+            ax.tick_params(axis='y', right=False, labelright=False)
             # Right axis tick params follow r_* keys
             ax2.tick_params(axis='y',
                             right=tick_state.get('r_ticks', tick_state.get('ry', False)),
@@ -1239,7 +1557,6 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         """Reapply legend position using stored inches offset relative to canvas center."""
         try:
             xy_in = _sanitize_legend_offset(getattr(fig, '_cpc_legend_xy_in', None))
-            leg = ax.get_legend()
             if xy_in is None:
                 return
             # Compute figure-fraction anchor from inches
@@ -1248,14 +1565,13 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 return
             fx = 0.5 + float(xy_in[0]) / float(fw)
             fy = 0.5 + float(xy_in[1]) / float(fh)
-            # Use current handles/labels
-            h1, l1 = ax.get_legend_handles_labels()
-            h2, l2 = ax2.get_legend_handles_labels()
-            if h1 or h2:
+            # Use current visible handles/labels
+            H, L = _visible_handles_labels(ax, ax2)
+            if H:
                 _legend_no_frame(
                     ax,
-                    h1 + h2,
-                    l1 + l2,
+                    H,
+                    L,
                     loc='center',
                     bbox_to_anchor=(fx, fy),
                     bbox_transform=fig.transFigure,
@@ -1279,16 +1595,13 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         pass
 
     _print_menu()
-    if is_multi_file:
-        print(f"\n[Multi-file mode: {len(file_data)} files loaded]")
-        _print_file_list(file_data, current_file_idx)
     
     while True:
         try:
             # Update current file's scatter artists for commands that need them
             sc_charge, sc_discharge, sc_eff = _get_current_file_artists(file_data, current_file_idx)
             
-            key = input("Press a key: ").strip().lower()
+            key = _safe_input("Press a key: ").strip().lower()
         except (KeyboardInterrupt, EOFError):
             print("\n\nExiting interactive menu...")
             break
@@ -1300,7 +1613,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
             try:
                 if is_multi_file:
                     _print_file_list(file_data, current_file_idx)
-                    choice = input(f"Toggle visibility for file (1-{len(file_data)}), 'a' for all, or q=cancel: ").strip()
+                    choice = _safe_input(f"Toggle visibility for file (1-{len(file_data)}), 'a' for all, or q=cancel: ").strip()
                     if choice.lower() == 'q':
                         _print_menu()
                         _print_file_list(file_data, current_file_idx)
@@ -1350,7 +1663,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         
         if key == 'q':
             try:
-                confirm = input(_colorize_prompt("Quit CPC interactive? Remember to save! Quit now? (y/n): ")).strip().lower()
+                confirm = _safe_input(_colorize_prompt("Quit CPC interactive? Remember to save! Quit now? (y/n): ")).strip().lower()
             except Exception:
                 confirm = 'y'
             if confirm == 'y':
@@ -1361,283 +1674,282 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
             restore_state()
             _print_menu(); continue
         elif key == 'c':
-            # Colors submenu: ly (left Y series) and ry (right Y efficiency)
+            # Colors submenu: ly (left Y series) and ry (right Y efficiency), with user colors and palettes
             try:
+                # Use same palettes as EC interactive
+                palette_opts = ['tab10', 'Set2', 'Dark2', 'viridis', 'plasma']
+                def _palette_color(name, idx=0, total=1, default_val=0.4):
+                    import matplotlib.cm as cm
+                    import matplotlib.colors as mcolors
+                    import numpy as _np
+                    # Ensure colormap is registered before use
+                    if not ensure_colormap(name):
+                        # Fallback to viridis if colormap can't be registered
+                        name = 'viridis'
+                        ensure_colormap(name)
+                    try:
+                        cmap = cm.get_cmap(name)
+                    except Exception:
+                        # Fallback if get_cmap fails
+                        ensure_colormap('viridis')
+                        cmap = cm.get_cmap('viridis')
+                    
+                    # Special handling for tab10 to match hardcoded colors exactly
+                    if name.lower() == 'tab10':
+                        default_tab10_colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd',
+                                               '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
+                        return default_tab10_colors[idx % len(default_tab10_colors)]
+                    
+                    # For discrete colormaps (Set2, Dark2), access colors directly
+                    if hasattr(cmap, 'colors') and cmap.colors is not None:
+                        # Discrete colormap: access colors directly by index
+                        colors = cmap.colors
+                        rgb = colors[idx % len(colors)]
+                        if isinstance(rgb, tuple) and len(rgb) >= 3:
+                            return mcolors.rgb2hex(rgb[:3])
+                    
+                    # For continuous colormaps (viridis, plasma), sample evenly
+                    if total == 1:
+                        vals = [0.55]
+                    elif total == 2:
+                        vals = [0.15, 0.85]
+                    else:
+                        vals = _np.linspace(0.08, 0.88, total)
+                    rgb = cmap(vals[idx % len(vals)])
+                    return mcolors.rgb2hex(rgb[:3])
+                def _resolve_color(spec, idx=0, total=1, default_cmap='tab10'):
+                    spec = spec.strip()
+                    if not spec:
+                        return None
+                    if spec.lower() == 'r':
+                        return _palette_color(default_cmap, idx, total, 0.4)
+                    # user colors: u# or plain number referencing saved list
+                    uc = None
+                    if spec.lower().startswith('u') and len(spec) > 1 and spec[1:].isdigit():
+                        uc = resolve_color_token(spec, fig)
+                    elif spec.isdigit():
+                        # number as palette index if within palette list
+                        n = int(spec)
+                        if 1 <= n <= len(palette_opts):
+                            palette_name = palette_opts[n-1]
+                            return _palette_color(palette_name, idx, total, 0.4)
+                    if uc:
+                        return uc
+                    # Check if spec is a palette name (case-insensitive)
+                    spec_lower = spec.lower()
+                    base = spec.rstrip('_r').rstrip('_R')
+                    base_lower = base.lower()
+                    # Check against palette_opts (case-insensitive)
+                    for pal in palette_opts:
+                        if spec_lower == pal.lower() or base_lower == pal.lower() or spec_lower == (pal + '_r').lower():
+                            return _palette_color(pal if not spec.endswith('_r') and not spec.endswith('_R') else spec, idx, total, 0.4)
+                    # Fall back to resolve_color_token for hex colors, named colors, etc.
+                    return resolve_color_token(spec, fig)
+
                 while True:
-                    print("\nColors: ly=capacity curves, ry=efficiency triangles, q=back")
-                    sub = input("Colors> ").strip().lower()
+                    print("\nColors: ly=capacity curves, ry=efficiency triangles, u=user colors, q=back")
+                    sub = _safe_input("Colors> ").strip().lower()
                     if not sub:
                         continue
                     if sub == 'q':
                         break
+                    if sub == 'u':
+                        manage_user_colors(fig); continue
                     if sub == 'ly':
-                        if is_multi_file:
-                            # Show file list for selection
-                            print("\nSelect curve to color:")
-                            for i, f in enumerate(file_data, 1):
-                                vis_mark = "●" if f.get('visible', True) else "○"
-                                print(f"  {i}. {vis_mark} {f['filename']}")
-                            choice = input("Enter curve number (1-{}) or 'a' for all, q=cancel: ".format(len(file_data))).strip()
-                            if not choice or choice.lower() == 'q':
-                                continue
-                            
-                            push_state("colors-ly")
-                            if choice.lower() == 'a':
-                                # Apply to all files
-                                print("\nCharge color palettes (discharge will be auto-generated):")
-                                print("  1. Reds: #d62728, #c62828, #b71c1c, #8b0000, #a30000")
-                                print("  2. Oranges: #ff7f0e, #ff6f00, #ff5722, #f4511e, #e64a19")
-                                print("  3. Pinks/Magentas: #e377c2, #d81b60, #c2185b, #ad1457, #880e4f")
-                                print("  4. Purples: #9c27b0, #8e24aa, #7b1fa2, #6a1b9a, #4a148c")
-                                print("  5. Deep oranges/reds: #d84315, #bf360c, #c2185b, #d32f2f, #c62828")
-                                spec = input("Enter color (name/hex), palette number (1-5), or 'r' for random (q=cancel): ").strip()
-                                if not spec or spec.lower() == 'q':
+                        push_state("colors-ly")
+                        print("\nCurrent capacity curves:")
+                        for i, f in enumerate(file_data, 1):
+                            cur = _color_of(f['sc_charge'])
+                            vis_mark = "●" if f.get('visible', True) else "○"
+                            print(f"  {i}. {vis_mark} {f['filename']}  {color_block(cur)} {cur}")
+                        uc = get_user_color_list(fig)
+                        if uc:
+                            print("\nSaved colors (refer as number or u#):")
+                            for i, c in enumerate(uc, 1):
+                                print(f"  {i}: {color_block(c)} {c}")
+                        print("\nPalettes:")
+                        for idx, name in enumerate(palette_opts, 1):
+                            bar = palette_preview(name)
+                            print(f"  {idx}. {name}")
+                            if bar:
+                                print(f"      {bar}")
+                        color_input = _safe_input("Enter file+color pairs (e.g., 1:2 2:3 or 1 2 2 3) or palette/number for all, q=cancel: ").strip()
+                        if not color_input or color_input.lower() == 'q':
+                            continue
+                        tokens = color_input.split()
+                        if len(tokens) == 1:
+                            # Single token: apply palette to all files
+                            spec = tokens[0]
+                            for i, f in enumerate(file_data):
+                                charge_col = _resolve_color(spec, i, len(file_data), default_cmap='tab10')
+                                if not charge_col:
                                     continue
-                                for i, f in enumerate(file_data):
-                                    if spec.lower() == 'r':
-                                        # Use Viridis colormap
-                                        import matplotlib.cm as cm
-                                        import matplotlib.colors as mcolors
-                                        viridis = cm.get_cmap('viridis', 10)
-                                        charge_col = mcolors.rgb2hex(viridis(_random.random())[:3])
-
-                                    elif spec in ['1', '2', '3', '4', '5']:
-                                        # Use selected palette
-                                        charge_palettes = [
-                                            ['#d62728', '#c62828', '#b71c1c', '#8b0000', '#a30000'],
-                                            ['#ff7f0e', '#ff6f00', '#ff5722', '#f4511e', '#e64a19'],
-                                            ['#e377c2', '#d81b60', '#c2185b', '#ad1457', '#880e4f'],
-                                            ['#9c27b0', '#8e24aa', '#7b1fa2', '#6a1b9a', '#4a148c'],
-                                            ['#d84315', '#bf360c', '#c2185b', '#d32f2f', '#c62828']
-                                        ]
-                                        palette = charge_palettes[int(spec) - 1]
-                                        charge_col = palette[i % len(palette)]
+                                discharge_col = _generate_similar_color(charge_col)
+                                try:
+                                    f['sc_charge'].set_color(charge_col)
+                                    f['sc_discharge'].set_color(discharge_col)
+                                    f['color'] = charge_col
+                                    # Force update of facecolors for scatter plots
+                                    if hasattr(f['sc_charge'], 'set_facecolors'):
+                                        from matplotlib.colors import to_rgba
+                                        rgba = to_rgba(charge_col)
+                                        f['sc_charge'].set_facecolors(rgba)
+                                    if hasattr(f['sc_discharge'], 'set_facecolors'):
+                                        from matplotlib.colors import to_rgba
+                                        rgba = to_rgba(discharge_col)
+                                        f['sc_discharge'].set_facecolors(rgba)
+                                except Exception as e:
+                                    print(f"Error setting color: {e}")
+                                    pass
+                        else:
+                            # Multiple tokens: parse file:color pairs
+                            def _apply_manual_entries(tokens):
+                                idx_color_pairs = []
+                                i = 0
+                                while i < len(tokens):
+                                    tok = tokens[i]
+                                    if ':' in tok:
+                                        idx_str, color = tok.split(':', 1)
                                     else:
-                                        charge_col = spec
+                                        if i + 1 >= len(tokens):
+                                            print(f"Skip incomplete entry: {tok}")
+                                            break
+                                        idx_str = tok
+                                        color = tokens[i + 1]
+                                        i += 1
+                                    idx_color_pairs.append((idx_str, color))
+                                    i += 1
+                                for idx_str, color in idx_color_pairs:
+                                    try:
+                                        file_idx = int(idx_str) - 1
+                                    except ValueError:
+                                        print(f"Bad index: {idx_str}")
+                                        continue
+                                    if not (0 <= file_idx < len(file_data)):
+                                        print(f"Index out of range: {idx_str}")
+                                        continue
+                                    resolved = resolve_color_token(color, fig)
+                                    charge_col = resolved if resolved else color
+                                    if not charge_col:
+                                        continue
                                     discharge_col = _generate_similar_color(charge_col)
                                     try:
-                                        f['sc_charge'].set_color(charge_col)
-                                        f['sc_discharge'].set_color(discharge_col)
-                                        f['color'] = charge_col
+                                        file_data[file_idx]['sc_charge'].set_color(charge_col)
+                                        file_data[file_idx]['sc_discharge'].set_color(discharge_col)
+                                        file_data[file_idx]['color'] = charge_col
+                                        # Force update of facecolors for scatter plots
+                                        if hasattr(file_data[file_idx]['sc_charge'], 'set_facecolors'):
+                                            from matplotlib.colors import to_rgba
+                                            rgba = to_rgba(charge_col)
+                                            file_data[file_idx]['sc_charge'].set_facecolors(rgba)
+                                        if hasattr(file_data[file_idx]['sc_discharge'], 'set_facecolors'):
+                                            from matplotlib.colors import to_rgba
+                                            rgba = to_rgba(discharge_col)
+                                            file_data[file_idx]['sc_discharge'].set_facecolors(rgba)
                                     except Exception:
                                         pass
-                            else:
-                                # Apply to selected file
-                                try:
-                                    idx = int(choice) - 1
-                                    if 0 <= idx < len(file_data):
-                                        print("\nCharge color palettes (discharge will be auto-generated):")
-                                        print("  1. Reds: #d62728, #c62828, #b71c1c, #8b0000, #a30000")
-                                        print("  2. Oranges: #ff7f0e, #ff6f00, #ff5722, #f4511e, #e64a19")
-                                        print("  3. Pinks/Magentas: #e377c2, #d81b60, #c2185b, #ad1457, #880e4f")
-                                        print("  4. Purples: #9c27b0, #8e24aa, #7b1fa2, #6a1b9a, #4a148c")
-                                        print("  5. Deep oranges/reds: #d84315, #bf360c, #c2185b, #d32f2f, #c62828")
-                                        spec = input("Enter color (name/hex), palette number (1-5), or 'r' for random (q=cancel): ").strip()
-                                        if not spec or spec.lower() == 'q':
-                                            continue
-                                        if spec.lower() == 'r':
-                                            # Use Viridis colormap
-                                            import matplotlib.cm as cm
-                                            import matplotlib.colors as mcolors
-                                            viridis = cm.get_cmap('viridis', 10)
-                                            charge_col = mcolors.rgb2hex(viridis(_random.random())[:3])
-                                        elif spec in ['1', '2', '3', '4', '5']:
-                                            # Use selected palette
-                                            charge_palettes = [
-                                                ['#d62728', '#c62828', '#b71c1c', '#8b0000', '#a30000'],
-                                                ['#ff7f0e', '#ff6f00', '#ff5722', '#f4511e', '#e64a19'],
-                                                ['#e377c2', '#d81b60', '#c2185b', '#ad1457', '#880e4f'],
-                                                ['#9c27b0', '#8e24aa', '#7b1fa2', '#6a1b9a', '#4a148c'],
-                                                ['#d84315', '#bf360c', '#c2185b', '#d32f2f', '#c62828']
-                                            ]
-                                            palette = charge_palettes[int(spec) - 1]
-                                            charge_col = palette[0]  # Use first color from palette for single file
-                                        else:
-                                            charge_col = spec
-                                        discharge_col = _generate_similar_color(charge_col)
-                                        try:
-                                            file_data[idx]['sc_charge'].set_color(charge_col)
-                                            file_data[idx]['sc_discharge'].set_color(discharge_col)
-                                            file_data[idx]['color'] = charge_col
-                                        except Exception:
-                                            pass
-                                    else:
-                                        print("Invalid file number.")
-                                except ValueError:
-                                    print("Invalid input.")
-                        else:
-                            # Single file mode
-                            push_state("colors-ly")
-                            print("\nCharge color palettes (discharge will be auto-generated):")
-                            print("  1. Reds: #d62728, #c62828, #b71c1c, #8b0000, #a30000")
-                            print("  2. Oranges: #ff7f0e, #ff6f00, #ff5722, #f4511e, #e64a19")
-                            print("  3. Pinks/Magentas: #e377c2, #d81b60, #c2185b, #ad1457, #880e4f")
-                            print("  4. Purples: #9c27b0, #8e24aa, #7b1fa2, #6a1b9a, #4a148c")
-                            print("  5. Deep oranges/reds: #d84315, #bf360c, #c2185b, #d32f2f, #c62828")
-                            spec = input("Enter color (name/hex), palette number (1-5), or 'r' for random (q=cancel): ").strip()
-                            if not spec or spec.lower() == 'q':
-                                continue
-                            if spec.strip().lower() == 'r':
-                                # Use Viridis colormap
-                                import matplotlib.cm as cm
-                                import matplotlib.colors as mcolors
-                                viridis = cm.get_cmap('viridis', 10)
-                                charge_col = mcolors.rgb2hex(viridis(_random.random())[:3])
-                            elif spec in ['1', '2', '3', '4', '5']:
-                                # Use selected palette
-                                charge_palettes = [
-                                    ['#d62728', '#c62828', '#b71c1c', '#8b0000', '#a30000'],
-                                    ['#ff7f0e', '#ff6f00', '#ff5722', '#f4511e', '#e64a19'],
-                                    ['#e377c2', '#d81b60', '#c2185b', '#ad1457', '#880e4f'],
-                                    ['#9c27b0', '#8e24aa', '#7b1fa2', '#6a1b9a', '#4a148c'],
-                                    ['#d84315', '#bf360c', '#c2185b', '#d32f2f', '#c62828']
-                                ]
-                                palette = charge_palettes[int(spec) - 1]
-                                charge_col = palette[0]  # Use first color from palette
-                            else:
-                                charge_col = spec
-                            discharge_col = _generate_similar_color(charge_col)
+                            _apply_manual_entries(tokens)
+                        if not is_multi_file and getattr(fig, '_cpc_spine_auto', False):
                             try:
-                                sc_charge.set_color(charge_col)
-                                sc_discharge.set_color(discharge_col)
-                                # Apply auto colors if enabled
-                                if not is_multi_file and getattr(fig, '_cpc_spine_auto', False):
-                                    _set_spine_color('left', charge_col)
+                                cur_col = _color_of(sc_charge)
+                                if cur_col:
+                                    _set_spine_color('left', cur_col)
                             except Exception:
                                 pass
                         try:
-                            _rebuild_legend(ax, ax2, file_data)
-                            fig.canvas.draw_idle()
+                            _rebuild_legend(ax, ax2, file_data); fig.canvas.draw_idle()
                         except Exception:
                             pass
                     elif sub == 'ry':
                         push_state("colors-ry")
-                        if is_multi_file:
-                            # Show file list for efficiency triangle selection
-                            print("\nSelect curve's efficiency to color:")
-                            for i, f in enumerate(file_data, 1):
-                                vis_mark = "●" if f.get('visible', True) else "○"
-                                print(f"  {i}. {vis_mark} {f['filename']}")
-                            choice = input("Enter curve number (1-{}) or 'a' for all, q=cancel: ".format(len(file_data))).strip()
-                            if not choice or choice.lower() == 'q':
-                                continue
-                            
-                            if choice.lower() == 'a':
-                                print("\nEfficiency color palettes:")
-                                print("  1. Blues: #1f77b4, #1976d2, #1565c0, #0d47a1, #01579b")
-                                print("  2. Cyans/Teals: #17becf, #00acc1, #0097a7, #00838f, #006064")
-                                print("  3. Purples/Indigos: #9467bd, #5e35b1, #512da8, #4527a0, #311b92")
-                                print("  4. Deep blues: #2196f3, #1e88e5, #1976d2, #1565c0, #0d47a1")
-                                print("  5. Dark cyans/purples: #0097a7, #00838f, #006064, #5e35b1, #4527a0")
-                                val = input("Enter color (hex/name), palette number (1-5), or 'r' for random (q=cancel): ").strip()
-                                if not val or val.lower() == 'q':
+                        print("\nCurrent efficiency curves:")
+                        for i, f in enumerate(file_data, 1):
+                            cur = _color_of(f['sc_eff'])
+                            vis_mark = "●" if f.get('visible', True) else "○"
+                            print(f"  {i}. {vis_mark} {f['filename']}  {color_block(cur)} {cur}")
+                        uc = get_user_color_list(fig)
+                        if uc:
+                            print("\nSaved colors (refer as number or u#):")
+                            for i, c in enumerate(uc, 1):
+                                print(f"  {i}: {color_block(c)} {c}")
+                        print("\nPalettes:")
+                        for idx, name in enumerate(palette_opts, 1):
+                            bar = palette_preview(name)
+                            print(f"  {idx}. {name}")
+                            if bar:
+                                print(f"      {bar}")
+                        color_input = _safe_input("Enter file+color pairs (e.g., 1:2 2:3 or 1 2 2 3) or palette/number for all, q=cancel: ").strip()
+                        if not color_input or color_input.lower() == 'q':
+                            continue
+                        tokens = color_input.split()
+                        if len(tokens) == 1:
+                            # Single token: apply palette to all files
+                            spec = tokens[0]
+                            for i, f in enumerate(file_data):
+                                col = _resolve_color(spec, i, len(file_data), default_cmap='viridis')
+                                if not col:
                                     continue
-                                for i, f in enumerate(file_data):
-                                    if val.lower() == 'r':
-                                        # Use Plasma colormap
-                                        import matplotlib.cm as cm
-                                        import matplotlib.colors as mcolors
-                                        plasma = cm.get_cmap('plasma', 10)
-                                        col = mcolors.rgb2hex(plasma(_random.random())[:3])
-                                    elif val in ['1', '2', '3', '4', '5']:
-                                        # Use selected palette
-                                        efficiency_palettes = [
-                                            ['#1f77b4', '#1976d2', '#1565c0', '#0d47a1', '#01579b'],
-                                            ['#17becf', '#00acc1', '#0097a7', '#00838f', '#006064'],
-                                            ['#9467bd', '#5e35b1', '#512da8', '#4527a0', '#311b92'],
-                                            ['#2196f3', '#1e88e5', '#1976d2', '#1565c0', '#0d47a1'],
-                                            ['#0097a7', '#00838f', '#006064', '#5e35b1', '#4527a0']
-                                        ]
-                                        palette = efficiency_palettes[int(val) - 1]
-                                        col = palette[i % len(palette)]
+                                try:
+                                    f['sc_eff'].set_color(col)
+                                    f['eff_color'] = col
+                                    # Force update of facecolors for scatter plots
+                                    if hasattr(f['sc_eff'], 'set_facecolors'):
+                                        from matplotlib.colors import to_rgba
+                                        rgba = to_rgba(col)
+                                        f['sc_eff'].set_facecolors(rgba)
+                                except Exception:
+                                    pass
+                        else:
+                            # Multiple tokens: parse file:color pairs
+                            def _apply_manual_entries_eff(tokens):
+                                idx_color_pairs = []
+                                i = 0
+                                while i < len(tokens):
+                                    tok = tokens[i]
+                                    if ':' in tok:
+                                        idx_str, color = tok.split(':', 1)
                                     else:
-                                        col = val
+                                        if i + 1 >= len(tokens):
+                                            print(f"Skip incomplete entry: {tok}")
+                                            break
+                                        idx_str = tok
+                                        color = tokens[i + 1]
+                                        i += 1
+                                    idx_color_pairs.append((idx_str, color))
+                                    i += 1
+                                for idx_str, color in idx_color_pairs:
                                     try:
-                                        f['sc_eff'].set_color(col)
-                                        f['eff_color'] = col  # Store efficiency color
+                                        file_idx = int(idx_str) - 1
+                                    except ValueError:
+                                        print(f"Bad index: {idx_str}")
+                                        continue
+                                    if not (0 <= file_idx < len(file_data)):
+                                        print(f"Index out of range: {idx_str}")
+                                        continue
+                                    resolved = resolve_color_token(color, fig)
+                                    col = resolved if resolved else color
+                                    if not col:
+                                        continue
+                                    try:
+                                        file_data[file_idx]['sc_eff'].set_color(col)
+                                        file_data[file_idx]['eff_color'] = col
+                                        # Force update of facecolors for scatter plots
+                                        if hasattr(file_data[file_idx]['sc_eff'], 'set_facecolors'):
+                                            from matplotlib.colors import to_rgba
+                                            rgba = to_rgba(col)
+                                            file_data[file_idx]['sc_eff'].set_facecolors(rgba)
                                     except Exception:
                                         pass
-                            else:
-                                try:
-                                    idx = int(choice) - 1
-                                    if 0 <= idx < len(file_data):
-                                        print("\nEfficiency color palettes:")
-                                        print("  1. Blues: #1f77b4, #1976d2, #1565c0, #0d47a1, #01579b")
-                                        print("  2. Cyans/Teals: #17becf, #00acc1, #0097a7, #00838f, #006064")
-                                        print("  3. Purples/Indigos: #9467bd, #5e35b1, #512da8, #4527a0, #311b92")
-                                        print("  4. Deep blues: #2196f3, #1e88e5, #1976d2, #1565c0, #0d47a1")
-                                        print("  5. Dark cyans/purples: #0097a7, #00838f, #006064, #5e35b1, #4527a0")
-                                        val = input("Enter color (hex/name), palette number (1-5), or 'r' for random (q=cancel): ").strip()
-                                        if not val or val.lower() == 'q':
-                                            continue
-                                        if val.lower() == 'r':
-                                            # Use Plasma colormap
-                                            import matplotlib.cm as cm
-                                            import matplotlib.colors as mcolors
-                                            plasma = cm.get_cmap('plasma', 10)
-                                            col = mcolors.rgb2hex(plasma(_random.random())[:3])
-                                        elif val in ['1', '2', '3', '4', '5']:
-                                            # Use selected palette
-                                            efficiency_palettes = [
-                                                ['#1f77b4', '#1976d2', '#1565c0', '#0d47a1', '#01579b'],
-                                                ['#17becf', '#00acc1', '#0097a7', '#00838f', '#006064'],
-                                                ['#9467bd', '#5e35b1', '#512da8', '#4527a0', '#311b92'],
-                                                ['#2196f3', '#1e88e5', '#1976d2', '#1565c0', '#0d47a1'],
-                                                ['#0097a7', '#00838f', '#006064', '#5e35b1', '#4527a0']
-                                            ]
-                                            palette = efficiency_palettes[int(val) - 1]
-                                            col = palette[0]  # Use first color from palette for single file
-                                        else:
-                                            col = val
-                                        try:
-                                            file_data[idx]['sc_eff'].set_color(col)
-                                            file_data[idx]['eff_color'] = col  # Store efficiency color
-                                        except Exception:
-                                            pass
-                                    else:
-                                        print("Invalid file number.")
-                                except ValueError:
-                                    print("Invalid input.")
-                        else:
-                            # Single file mode
-                            print("\nEfficiency color palettes:")
-                            print("  1. Blues: #1f77b4, #1976d2, #1565c0, #0d47a1, #01579b")
-                            print("  2. Cyans/Teals: #17becf, #00acc1, #0097a7, #00838f, #006064")
-                            print("  3. Purples/Indigos: #9467bd, #5e35b1, #512da8, #4527a0, #311b92")
-                            print("  4. Deep blues: #2196f3, #1e88e5, #1976d2, #1565c0, #0d47a1")
-                            print("  5. Dark cyans/purples: #0097a7, #00838f, #006064, #5e35b1, #4527a0")
-                            val = input("Enter color (hex/name), palette number (1-5), or 'r' for random (q=cancel): ").strip()
-                            if not val or val.lower() == 'q':
-                                continue
-                            if val.lower() == 'r':
-                                # Use Plasma colormap
-                                import matplotlib.cm as cm
-                                import matplotlib.colors as mcolors
-                                plasma = cm.get_cmap('plasma', 10)
-                                col = mcolors.rgb2hex(plasma(_random.random())[:3])
-                            elif val in ['1', '2', '3', '4', '5']:
-                                # Use selected palette
-                                efficiency_palettes = [
-                                    ['#1f77b4', '#1976d2', '#1565c0', '#0d47a1', '#01579b'],
-                                    ['#17becf', '#00acc1', '#0097a7', '#00838f', '#006064'],
-                                    ['#9467bd', '#5e35b1', '#512da8', '#4527a0', '#311b92'],
-                                    ['#2196f3', '#1e88e5', '#1976d2', '#1565c0', '#0d47a1'],
-                                    ['#0097a7', '#00838f', '#006064', '#5e35b1', '#4527a0']
-                                ]
-                                palette = efficiency_palettes[int(val) - 1]
-                                col = palette[0]  # Use first color from palette
-                            else:
-                                col = val
+                            _apply_manual_entries_eff(tokens)
+                        if not is_multi_file and getattr(fig, '_cpc_spine_auto', False):
                             try:
-                                sc_eff.set_color(col)
-                                # Apply auto colors if enabled
-                                if not is_multi_file and getattr(fig, '_cpc_spine_auto', False):
-                                    _set_spine_color('right', col)
+                                cur_col = _color_of(sc_eff)
+                                if cur_col:
+                                    _set_spine_color('right', cur_col)
                             except Exception:
                                 pass
                         try:
-                            _rebuild_legend(ax, ax2, file_data)
-                            fig.canvas.draw_idle()
+                            _rebuild_legend(ax, ax2, file_data); fig.canvas.draw_idle()
                         except Exception:
                             pass
                     else:
@@ -1662,7 +1974,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                         auto_status = "ON" if auto_enabled else "OFF"
                         print(_colorize_inline_commands(f"  a : auto (apply capacity curve color to left y-axis, efficiency to right y-axis) [{auto_status}]"))
                     print("q: back to main menu")
-                    line = input("Enter mappings (e.g., w:red a:#4561F7) or q: ").strip()
+                    line = _safe_input("Enter mappings (e.g., w:red a:#4561F7) or q: ").strip()
                     if not line or line.lower() == 'q':
                         break
                     # Handle auto toggle when only one file is loaded
@@ -1734,9 +2046,9 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 
                 last_figure_path = getattr(fig, '_last_figure_export_path', None)
                 if last_figure_path:
-                    fname = input("Export filename (default .svg if no extension), number to overwrite, or o to overwrite last (q=cancel): ").strip()
+                    fname = _safe_input("Export filename (default .svg if no extension), number to overwrite, or o to overwrite last (q=cancel): ").strip()
                 else:
-                    fname = input("Export filename (default .svg if no extension) or number to overwrite (q=cancel): ").strip()
+                    fname = _safe_input("Export filename (default .svg if no extension) or number to overwrite (q=cancel): ").strip()
                 if not fname or fname.lower() == 'q':
                     _print_menu(); continue
                 
@@ -1748,7 +2060,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     if not os.path.exists(last_figure_path):
                         print(f"Previous export file not found: {last_figure_path}")
                         _print_menu(); continue
-                    yn = input(f"Overwrite '{os.path.basename(last_figure_path)}'? (y/n): ").strip().lower()
+                    yn = _safe_input(f"Overwrite '{os.path.basename(last_figure_path)}'? (y/n): ").strip().lower()
                     if yn != 'y':
                         _print_menu(); continue
                     target = last_figure_path
@@ -1757,7 +2069,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     idx = int(fname)
                     if 1 <= idx <= len(files):
                         name = files[idx-1]
-                        yn = input(f"Overwrite '{name}'? (y/n): ").strip().lower()
+                        yn = _safe_input(f"Overwrite '{name}'? (y/n): ").strip().lower()
                         if yn != 'y':
                             _print_menu(); continue
                         target = file_list[idx-1][1]  # Full path from list
@@ -1774,10 +2086,17 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     else:
                         target = get_organized_path(fname, 'figure', base_path=base_path)
                     if os.path.exists(target):
-                        yn = input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
+                        yn = _safe_input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
                         if yn != 'y':
                             _print_menu(); continue
                 if target:
+                    # Save current legend position before export (savefig can change layout)
+                    saved_legend_pos = None
+                    try:
+                        saved_legend_pos = getattr(fig, '_cpc_legend_xy_in', None)
+                    except Exception:
+                        pass
+                    
                     # Remove numbering from legend labels before export
                     original_labels = {}
                     if is_multi_file:
@@ -1800,18 +2119,88 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             pass
                     
                     # Export the figure
-                    fig.savefig(target, bbox_inches='tight')
-                    print(f"Exported figure to {target}")
-                    fig._last_figure_export_path = target
-                    
-                    # Restore original labels
-                    if is_multi_file and original_labels:
+                    _, _ext = os.path.splitext(target)
+                    if _ext.lower() == '.svg':
+                        # Temporarily force transparent patches so SVG background stays transparent
                         try:
-                            for artist, label in original_labels.items():
-                                artist.set_label(label)
-                            _rebuild_legend(ax, ax2, file_data)
+                            _fig_fc = fig.get_facecolor()
+                        except Exception:
+                            _fig_fc = None
+                        try:
+                            _ax_fc = ax.get_facecolor()
+                        except Exception:
+                            _ax_fc = None
+                        try:
+                            _ax2_fc = ax2.get_facecolor()
+                        except Exception:
+                            _ax2_fc = None
+                        try:
+                            if getattr(fig, 'patch', None) is not None:
+                                fig.patch.set_alpha(0.0); fig.patch.set_facecolor('none')
+                            if getattr(ax, 'patch', None) is not None:
+                                ax.patch.set_alpha(0.0); ax.patch.set_facecolor('none')
+                            if getattr(ax2, 'patch', None) is not None:
+                                ax2.patch.set_alpha(0.0); ax2.patch.set_facecolor('none')
                         except Exception:
                             pass
+                        try:
+                            fig.savefig(target, bbox_inches='tight', transparent=True, facecolor='none', edgecolor='none')
+                        finally:
+                            try:
+                                if _fig_fc is not None and getattr(fig, 'patch', None) is not None:
+                                    fig.patch.set_alpha(1.0); fig.patch.set_facecolor(_fig_fc)
+                            except Exception:
+                                pass
+                            try:
+                                if _ax_fc is not None and getattr(ax, 'patch', None) is not None:
+                                    ax.patch.set_alpha(1.0); ax.patch.set_facecolor(_ax_fc)
+                            except Exception:
+                                pass
+                            try:
+                                if _ax2_fc is not None and getattr(ax2, 'patch', None) is not None:
+                                    ax2.patch.set_alpha(1.0); ax2.patch.set_facecolor(_ax2_fc)
+                            except Exception:
+                                pass
+                        print(f"Exported figure to {target}")
+                        fig._last_figure_export_path = target
+                        
+                        # Restore original labels and legend position
+                        if is_multi_file and original_labels:
+                            try:
+                                for artist, label in original_labels.items():
+                                    artist.set_label(label)
+                                _rebuild_legend(ax, ax2, file_data)
+                            except Exception:
+                                pass
+                        # Restore legend position after savefig (which may have changed layout)
+                        if saved_legend_pos is not None:
+                            try:
+                                fig._cpc_legend_xy_in = saved_legend_pos
+                                _rebuild_legend(ax, ax2, file_data)
+                                fig.canvas.draw_idle()
+                            except Exception:
+                                pass
+                    else:
+                        fig.savefig(target, bbox_inches='tight')
+                        print(f"Exported figure to {target}")
+                        fig._last_figure_export_path = target
+                        
+                        # Restore original labels and legend position
+                        if is_multi_file and original_labels:
+                            try:
+                                for artist, label in original_labels.items():
+                                    artist.set_label(label)
+                                _rebuild_legend(ax, ax2, file_data)
+                            except Exception:
+                                pass
+                        # Restore legend position after savefig (which may have changed layout)
+                        if saved_legend_pos is not None:
+                            try:
+                                fig._cpc_legend_xy_in = saved_legend_pos
+                                _rebuild_legend(ax, ax2, file_data)
+                                fig.canvas.draw_idle()
+                            except Exception:
+                                pass
             except Exception as e:
                 print(f"Export failed: {e}")
             _print_menu(); continue
@@ -1819,6 +2208,58 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
             # Save CPC session (.pkl) with all data and styles
             try:
                 from .session import dump_cpc_session
+                # Sync current tick/title visibility (including minors) into stored WASD state before save
+                try:
+                    wasd = getattr(fig, '_cpc_wasd_state', {})
+                    if not isinstance(wasd, dict):
+                        wasd = {}
+                    # bottom
+                    w = wasd.setdefault('bottom', {})
+                    w['ticks'] = bool(tick_state.get('b_ticks', tick_state.get('bx', True)))
+                    w['labels'] = bool(tick_state.get('b_labels', tick_state.get('bx', True)))
+                    w['minor'] = bool(tick_state.get('mbx', False))
+                    w['title'] = bool(ax.xaxis.label.get_visible())
+                    try:
+                        sp = ax.spines.get('bottom')
+                        w['spine'] = bool(sp.get_visible()) if sp else w.get('spine', True)
+                    except Exception:
+                        pass
+                    # top
+                    w = wasd.setdefault('top', {})
+                    w['ticks'] = bool(tick_state.get('t_ticks', tick_state.get('tx', False)))
+                    w['labels'] = bool(tick_state.get('t_labels', tick_state.get('tx', False)))
+                    w['minor'] = bool(tick_state.get('mtx', False))
+                    w['title'] = bool(getattr(ax, '_top_xlabel_on', False))
+                    try:
+                        sp = ax.spines.get('top')
+                        w['spine'] = bool(sp.get_visible()) if sp else w.get('spine', False)
+                    except Exception:
+                        pass
+                    # left
+                    w = wasd.setdefault('left', {})
+                    w['ticks'] = bool(tick_state.get('l_ticks', tick_state.get('ly', True)))
+                    w['labels'] = bool(tick_state.get('l_labels', tick_state.get('ly', True)))
+                    w['minor'] = bool(tick_state.get('mly', False))
+                    w['title'] = bool(ax.yaxis.label.get_visible())
+                    try:
+                        sp = ax.spines.get('left')
+                        w['spine'] = bool(sp.get_visible()) if sp else w.get('spine', True)
+                    except Exception:
+                        pass
+                    # right
+                    w = wasd.setdefault('right', {})
+                    w['ticks'] = bool(tick_state.get('r_ticks', tick_state.get('ry', True)))
+                    w['labels'] = bool(tick_state.get('r_labels', tick_state.get('ry', True)))
+                    w['minor'] = bool(tick_state.get('mry', False))
+                    w['title'] = bool(ax2.yaxis.label.get_visible() if ax2 is not None else False)
+                    try:
+                        sp = ax2.spines.get('right') if ax2 is not None else None
+                        w['spine'] = bool(sp.get_visible()) if sp else w.get('spine', True)
+                    except Exception:
+                        pass
+                    setattr(fig, '_cpc_wasd_state', wasd)
+                except Exception:
+                    pass
                 folder = choose_save_path(file_paths, purpose="CPC session save")
                 if not folder:
                     _print_menu(); continue
@@ -1841,7 +2282,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     prompt = "Enter new filename (no ext needed), number to overwrite, or o to overwrite last (q=cancel): "
                 else:
                     prompt = "Enter new filename (no ext needed) or number to overwrite (q=cancel): "
-                choice = input(prompt).strip()
+                choice = _safe_input(prompt).strip()
                 if not choice or choice.lower() == 'q':
                     _print_menu(); continue
                 if choice.lower() == 'o':
@@ -1852,7 +2293,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     if not os.path.exists(last_session_path):
                         print(f"Previous save file not found: {last_session_path}")
                         _print_menu(); continue
-                    yn = input(f"Overwrite '{os.path.basename(last_session_path)}'? (y/n): ").strip().lower()
+                    yn = _safe_input(f"Overwrite '{os.path.basename(last_session_path)}'? (y/n): ").strip().lower()
                     if yn != 'y':
                         _print_menu(); continue
                     dump_cpc_session(last_session_path, fig=fig, ax=ax, ax2=ax2, sc_charge=sc_charge, sc_discharge=sc_discharge, sc_eff=sc_eff, file_data=file_data, skip_confirm=True)
@@ -1862,7 +2303,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     idx = int(choice)
                     if 1 <= idx <= len(files):
                         name = files[idx-1]
-                        yn = input(f"Overwrite '{name}'? (y/n): ").strip().lower()
+                        yn = _safe_input(f"Overwrite '{name}'? (y/n): ").strip().lower()
                         if yn != 'y':
                             _print_menu(); continue
                         target = os.path.join(folder, name)
@@ -1879,7 +2320,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                         name = name + '.pkl'
                     target = name if os.path.isabs(name) else os.path.join(folder, name)
                     if os.path.exists(target):
-                        yn = input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
+                        yn = _safe_input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
                         if yn != 'y':
                             _print_menu(); continue
                     dump_cpc_session(target, fig=fig, ax=ax, ax2=ax2, sc_charge=sc_charge, sc_discharge=sc_discharge, sc_eff=sc_eff, file_data=file_data, skip_confirm=True)
@@ -2009,9 +2450,9 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     
                     last_style_path = getattr(fig, '_last_style_export_path', None)
                     if last_style_path:
-                        sub = input(_colorize_prompt("Style submenu: (e=export, o=overwrite last, q=return, r=refresh): ")).strip().lower()
+                        sub = _safe_input(_colorize_prompt("Style submenu: (e=export, o=overwrite last, q=return, r=refresh): ")).strip().lower()
                     else:
-                        sub = input(_colorize_prompt("Style submenu: (e=export, q=return, r=refresh): ")).strip().lower()
+                        sub = _safe_input(_colorize_prompt("Style submenu: (e=export, q=return, r=refresh): ")).strip().lower()
                     if sub == 'q':
                         break
                     if sub == 'r' or sub == '':
@@ -2024,7 +2465,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                         if not os.path.exists(last_style_path):
                             print(f"Previous export file not found: {last_style_path}")
                             continue
-                        yn = input(f"Overwrite '{os.path.basename(last_style_path)}'? (y/n): ").strip().lower()
+                        yn = _safe_input(f"Overwrite '{os.path.basename(last_style_path)}'? (y/n): ").strip().lower()
                         if yn != 'y':
                             continue
                         # Rebuild config based on current state
@@ -2050,7 +2491,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                         print("Export options:")
                         print("  ps  = style only (.bps)")
                         print("  psg = style + geometry (.bpsg)")
-                        exp_choice = input(_colorize_prompt("Export choice (ps/psg, q=cancel): ")).strip().lower()
+                        exp_choice = _safe_input(_colorize_prompt("Export choice (ps/psg, q=cancel): ")).strip().lower()
                         if not exp_choice or exp_choice == 'q':
                             print("Style export canceled.")
                             continue
@@ -2103,9 +2544,9 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                                 else:
                                     print(f"  {i}: {fname}")
                         if last_style_path:
-                            choice = input("Enter new filename, number to overwrite, or o to overwrite last (q=cancel): ").strip()
+                            choice = _safe_input("Enter new filename, number to overwrite, or o to overwrite last (q=cancel): ").strip()
                         else:
-                            choice = input("Enter new filename or number to overwrite (q=cancel): ").strip()
+                            choice = _safe_input("Enter new filename or number to overwrite (q=cancel): ").strip()
                         if not choice or choice.lower() == 'q':
                             print("Style export canceled.")
                             continue
@@ -2117,7 +2558,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             if not os.path.exists(last_style_path):
                                 print(f"Previous export file not found: {last_style_path}")
                                 continue
-                            yn = input(f"Overwrite '{os.path.basename(last_style_path)}'? (y/n): ").strip().lower()
+                            yn = _safe_input(f"Overwrite '{os.path.basename(last_style_path)}'? (y/n): ").strip().lower()
                             if yn != 'y':
                                 continue
                             # Rebuild config based on current state
@@ -2143,7 +2584,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             idx = int(choice)
                             if 1 <= idx <= len(files):
                                 name = files[idx-1]
-                                yn = input(f"Overwrite '{name}'? (y/n): ").strip().lower()
+                                yn = _safe_input(f"Overwrite '{name}'? (y/n): ").strip().lower()
                                 if yn == 'y':
                                     target = file_list[idx-1][1]  # Full path from list
                             else:
@@ -2160,7 +2601,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             else:
                                 target = get_organized_path(name, 'style', base_path=save_base)
                             if os.path.exists(target):
-                                yn = input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
+                                yn = _safe_input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
                                 if yn != 'y':
                                     target = None
                         if target:
@@ -2222,11 +2663,28 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
             # Toggle efficiency visibility on the right axis
             try:
                 push_state("toggle-eff")
-                vis = bool(sc_eff.get_visible()) if hasattr(sc_eff, 'get_visible') else True
-                new_vis = not vis
                 
-                # 1. Hide/show efficiency points
-                sc_eff.set_visible(new_vis)
+                # Determine current visibility state (check if any efficiency is visible)
+                if is_multi_file:
+                    # In multi-file mode, check if any efficiency is visible
+                    any_eff_visible = any(f.get('sc_eff', {}).get_visible() if hasattr(f.get('sc_eff'), 'get_visible') else True for f in file_data if f.get('sc_eff'))
+                    new_vis = not any_eff_visible
+                else:
+                    # Single file mode
+                    vis = bool(sc_eff.get_visible()) if hasattr(sc_eff, 'get_visible') else True
+                    new_vis = not vis
+                
+                # 1. Hide/show efficiency points (all files in multi-file mode)
+                if is_multi_file:
+                    for f in file_data:
+                        eff_sc = f.get('sc_eff')
+                        if eff_sc is not None:
+                            try:
+                                eff_sc.set_visible(new_vis)
+                            except Exception:
+                                pass
+                else:
+                    sc_eff.set_visible(new_vis)
                 
                 # 2. Hide/show right y-axis title
                 try:
@@ -2242,68 +2700,42 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 except Exception:
                     pass
                 
-                # 4. Rebuild legend to remove/add efficiency entry
-                try:
-                    h1, l1 = ax.get_legend_handles_labels()
-                except Exception:
-                    h1, l1 = [], []
+                # Persist WASD state so save/load and styles honor the toggle
                 try:
-                    h2, l2 = ax2.get_legend_handles_labels()
-                except Exception:
-                    h2, l2 = [], []
-                
-                # Filter out efficiency entry if hidden
-                eff_label = None
-                try:
-                    eff_label = sc_eff.get_label()
+                    wasd = getattr(fig, '_cpc_wasd_state', None)
+                    if not isinstance(wasd, dict):
+                        wasd = {
+                            'top':    {'spine': bool(ax.spines.get('top').get_visible()) if ax.spines.get('top') else False,
+                                       'ticks': bool(tick_state.get('t_ticks', tick_state.get('tx', False))),
+                                       'minor': bool(tick_state.get('mtx', False)),
+                                       'labels': bool(tick_state.get('t_labels', tick_state.get('tx', False))),
+                                       'title': bool(getattr(ax, '_top_xlabel_on', False))},
+                            'bottom': {'spine': bool(ax.spines.get('bottom').get_visible()) if ax.spines.get('bottom') else True,
+                                       'ticks': bool(tick_state.get('b_ticks', tick_state.get('bx', True))),
+                                       'minor': bool(tick_state.get('mbx', False)),
+                                       'labels': bool(tick_state.get('b_labels', tick_state.get('bx', True))),
+                                       'title': bool(ax.xaxis.label.get_visible()) and bool(ax.get_xlabel())},
+                            'left':   {'spine': bool(ax.spines.get('left').get_visible()) if ax.spines.get('left') else True,
+                                       'ticks': bool(tick_state.get('l_ticks', tick_state.get('ly', True))),
+                                       'minor': bool(tick_state.get('mly', False)),
+                                       'labels': bool(tick_state.get('l_labels', tick_state.get('ly', True))),
+                                       'title': bool(ax.yaxis.label.get_visible()) and bool(ax.get_ylabel())},
+                            'right':  {'spine': bool(ax2.spines.get('right').get_visible()) if ax2.spines.get('right') else True,
+                                       'ticks': bool(tick_state.get('r_ticks', tick_state.get('ry', True))),
+                                       'minor': bool(tick_state.get('mry', False)),
+                                       'labels': bool(tick_state.get('r_labels', tick_state.get('ry', True))),
+                                       'title': bool(ax2.yaxis.label.get_visible()) and bool(ax2.get_ylabel())},
+                        }
+                    wasd.setdefault('right', {})
+                    wasd['right']['ticks'] = bool(new_vis)
+                    wasd['right']['labels'] = bool(new_vis)
+                    wasd['right']['title'] = bool(new_vis)
+                    setattr(fig, '_cpc_wasd_state', wasd)
                 except Exception:
                     pass
                 
-                pairs1 = list(zip(h1, l1))
-                pairs2 = list(zip(h2, l2))
-                
-                def _keep(pair):
-                    h, l = pair
-                    # Drop invisible handles
-                    try:
-                        if hasattr(h, 'get_visible') and not h.get_visible():
-                            return False
-                    except Exception:
-                        pass
-                    # Drop the efficiency label when hidden
-                    if eff_label and (l == eff_label) and not new_vis:
-                        return False
-                    return True
-                
-                vis_pairs1 = [p for p in pairs1 if _keep(p)]
-                vis_pairs2 = [p for p in pairs2 if _keep(p)]
-                H = [h for h, _ in vis_pairs1 + vis_pairs2]
-                L = [l for _, l in vis_pairs1 + vis_pairs2]
-                
-                if H:
-                    try:
-                        # Honor stored inch-based anchor if present; else fallback to 'best'
-                        xy_in = getattr(fig, '_cpc_legend_xy_in', None)
-                        if xy_in is not None:
-                            try:
-                                fw, fh = fig.get_size_inches()
-                                fx = 0.5 + float(xy_in[0]) / float(fw)
-                                fy = 0.5 + float(xy_in[1]) / float(fh)
-                                _legend_no_frame(ax, H, L, loc='center', bbox_to_anchor=(fx, fy), bbox_transform=fig.transFigure, borderaxespad=1.0)
-                            except Exception:
-                                _legend_no_frame(ax, H, L, loc='best', borderaxespad=1.0)
-                        else:
-                            _legend_no_frame(ax, H, L, loc='best', borderaxespad=1.0)
-                    except Exception:
-                        pass
-                else:
-                    # No visible series: hide legend if present
-                    try:
-                        leg = ax.get_legend()
-                        if leg is not None:
-                            leg.set_visible(False)
-                    except Exception:
-                        pass
+                # 4. Rebuild legend to remove/add efficiency entries (preserve position)
+                _rebuild_legend(ax, ax2, file_data, preserve_position=True)
                 
                 fig.canvas.draw_idle()
             except Exception:
@@ -2346,7 +2778,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 xy_in = _sanitize_legend_offset(xy_in) or (0.0, 0.0)
                 print(f"Legend is {'ON' if vis else 'off'}; position (inches from center): x={xy_in[0]:.2f}, y={xy_in[1]:.2f}")
                 while True:
-                    sub = input("Legend: t=toggle, p=set position, q=back: ").strip().lower()
+                    sub = _safe_input("Legend: t=toggle, p=set position, q=back: ").strip().lower()
                     if not sub:
                         continue
                     if sub == 'q':
@@ -2359,15 +2791,14 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                                 leg.set_visible(False)
                             else:
                                 # Ensure a legend exists at the stored position
-                                h1, l1 = ax.get_legend_handles_labels()
-                                h2, l2 = ax2.get_legend_handles_labels()
-                                if h1 or h2:
+                                H, L = _visible_handles_labels(ax, ax2)
+                                if H:
                                     offset = _sanitize_legend_offset(getattr(fig, '_cpc_legend_xy_in', None))
                                     if offset is not None:
                                         fig._cpc_legend_xy_in = offset
                                         _apply_legend_position()
                                     else:
-                                        _legend_no_frame(ax, h1 + h2, l1 + l2, loc='best', borderaxespad=1.0)
+                                        _legend_no_frame(ax, H, L, loc='best', borderaxespad=1.0)
                             fig.canvas.draw_idle()
                         except Exception:
                             pass
@@ -2377,7 +2808,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             xy_in = getattr(fig, '_cpc_legend_xy_in', (0.0, 0.0))
                             xy_in = _sanitize_legend_offset(xy_in) or (0.0, 0.0)
                             print(f"Current position: x={xy_in[0]:.2f}, y={xy_in[1]:.2f}")
-                            pos_cmd = input("Position: (x y) or x=x only, y=y only, q=back: ").strip().lower()
+                            pos_cmd = _safe_input("Position: (x y) or x=x only, y=y only, q=back: ").strip().lower()
                             if not pos_cmd or pos_cmd == 'q':
                                 break
                             if pos_cmd == 'x':
@@ -2386,7 +2817,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                                     xy_in = getattr(fig, '_cpc_legend_xy_in', (0.0, 0.0))
                                     xy_in = _sanitize_legend_offset(xy_in) or (0.0, 0.0)
                                     print(f"Current position: x={xy_in[0]:.2f}, y={xy_in[1]:.2f}")
-                                    val = input(f"Enter new x position (current y: {xy_in[1]:.2f}, q=back): ").strip()
+                                    val = _safe_input(f"Enter new x position (current y: {xy_in[1]:.2f}, q=back): ").strip()
                                     if not val or val.lower() == 'q':
                                         break
                                     try:
@@ -2409,7 +2840,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                                     xy_in = getattr(fig, '_cpc_legend_xy_in', (0.0, 0.0))
                                     xy_in = _sanitize_legend_offset(xy_in) or (0.0, 0.0)
                                     print(f"Current position: x={xy_in[0]:.2f}, y={xy_in[1]:.2f}")
-                                    val = input(f"Enter new y position (current x: {xy_in[0]:.2f}, q=back): ").strip()
+                                    val = _safe_input(f"Enter new y position (current x: {xy_in[0]:.2f}, q=back): ").strip()
                                     if not val or val.lower() == 'q':
                                         break
                                     try:
@@ -2450,11 +2881,11 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 pass
             _print_menu(); continue
         elif key == 'f':
-            sub = input("Font: f=family, s=size, q=back: ").strip().lower()
+            sub = _safe_input("Font: f=family, s=size, q=back: ").strip().lower()
             if sub == 'q' or not sub:
                 _print_menu(); continue
             if sub == 'f':
-                fam = input("Enter font family (e.g., Arial, DejaVu Sans): ").strip()
+                fam = _safe_input("Enter font family (e.g., Arial, DejaVu Sans): ").strip()
                 if fam:
                     try:
                         push_state("font-family")
@@ -2510,7 +2941,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     except Exception:
                         pass
             elif sub == 's':
-                val = input("Enter font size (number): ").strip()
+                val = _safe_input("Enter font size (number): ").strip()
                 try:
                     size = float(val)
                     push_state("font-size")
@@ -2604,13 +3035,13 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     print(f"  {_colorize_menu('f  : change frame (axes spines) and tick widths')}")
                     print(f"  {_colorize_menu('g  : toggle grid lines')}")
                     print(f"  {_colorize_menu('q  : return')}")
-                    sub = input(_colorize_prompt("Choose (f/g/q): ")).strip().lower()
+                    sub = _safe_input(_colorize_prompt("Choose (f/g/q): ")).strip().lower()
                     if not sub:
                         continue
                     if sub == 'q':
                         break
                     if sub == 'f':
-                        fw_in = input("Enter frame/tick width (e.g., 1.5) or 'm M' (major minor) or q: ").strip()
+                        fw_in = _safe_input("Enter frame/tick width (e.g., 1.5) or 'm M' (major minor) or q: ").strip()
                         if not fw_in or fw_in.lower() == 'q':
                             print("Canceled.")
                             continue
@@ -2682,7 +3113,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 except Exception:
                     e_ms = 40
                 print(f"  charge ms={c_ms}, discharge ms={d_ms}, efficiency ms={e_ms}")
-                spec = input("Set marker size: 'c <ms>', 'd <ms>', 'e <ms>' (q=cancel): ").strip().lower()
+                spec = _safe_input("Set marker size: 'c <ms>', 'd <ms>', 'e <ms>' (q=cancel): ").strip().lower()
                 if not spec or spec == 'q':
                     _print_menu(); continue
                 parts = spec.split()
@@ -2939,7 +3370,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 print(_colorize_inline_commands("Type 'i' to invert tick direction, 'l' to change tick length, 'list' to show current state, 'q' to go back."))
                 print(_colorize_inline_commands("  p = adjust title offsets (w=top, s=bottom, a=left, d=right)"))
                 while True:
-                    cmd = input(_colorize_prompt("t> ")).strip().lower()
+                    cmd = _safe_input(_colorize_prompt("t> ")).strip().lower()
                     if not cmd:
                         continue
                     if cmd == 'q':
@@ -2964,7 +3395,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             # Get current major tick length from axes
                             current_major = ax.xaxis.get_major_ticks()[0].tick1line.get_markersize() if ax.xaxis.get_major_ticks() else 4.0
                             print(f"Current major tick length: {current_major}")
-                            new_length_str = input("Enter new major tick length (e.g., 6.0): ").strip()
+                            new_length_str = _safe_input("Enter new major tick length (e.g., 6.0): ").strip()
                             if not new_length_str:
                                 continue
                             new_major = float(new_length_str)
@@ -3039,7 +3470,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                                 current_y_px = _px_value('_top_xlabel_manual_offset_y_pts')
                                 current_x_px = _px_value('_top_xlabel_manual_offset_x_pts')
                                 print(f"Top title offset: Y={current_y_px:+.2f} px (positive=up), X={current_x_px:+.2f} px (positive=right)")
-                                sub = input(_colorize_prompt("top (w=up, s=down, a=left, d=right, 0=reset, q=back): ")).strip().lower()
+                                sub = _safe_input(_colorize_prompt("top (w=up, s=down, a=left, d=right, 0=reset, q=back): ")).strip().lower()
                                 if not sub:
                                     continue
                                 if sub == 'q':
@@ -3076,7 +3507,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             while True:
                                 current_y_px = _px_value('_bottom_xlabel_manual_offset_y_pts')
                                 print(f"Bottom title offset: Y={current_y_px:+.2f} px (positive=down)")
-                                sub = input(_colorize_prompt("bottom (s=down, w=up, 0=reset, q=back): ")).strip().lower()
+                                sub = _safe_input(_colorize_prompt("bottom (s=down, w=up, 0=reset, q=back): ")).strip().lower()
                                 if not sub:
                                     continue
                                 if sub == 'q':
@@ -3106,7 +3537,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             while True:
                                 current_x_px = _px_value('_left_ylabel_manual_offset_x_pts')
                                 print(f"Left title offset: X={current_x_px:+.2f} px (positive=left)")
-                                sub = input(_colorize_prompt("left (a=left, d=right, 0=reset, q=back): ")).strip().lower()
+                                sub = _safe_input(_colorize_prompt("left (a=left, d=right, 0=reset, q=back): ")).strip().lower()
                                 if not sub:
                                     continue
                                 if sub == 'q':
@@ -3137,7 +3568,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                                 current_x_px = _px_value('_right_ylabel_manual_offset_x_pts')
                                 current_y_px = _px_value('_right_ylabel_manual_offset_y_pts')
                                 print(f"Right title offset: X={current_x_px:+.2f} px (positive=right), Y={current_y_px:+.2f} px (positive=up)")
-                                sub = input(_colorize_prompt("right (d=right, a=left, w=up, s=down, 0=reset, q=back): ")).strip().lower()
+                                sub = _safe_input(_colorize_prompt("right (d=right, a=left, w=up, s=down, 0=reset, q=back): ")).strip().lower()
                                 if not sub:
                                     continue
                                 if sub == 'q':
@@ -3175,7 +3606,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                             print("  " + _colorize_menu('d : adjust right title (d=right, a=left, w=up, s=down)'))
                             print("  " + _colorize_menu('r : reset all offsets'))
                             print("  " + _colorize_menu('q : return'))
-                            choice = input(_colorize_prompt("p> ")).strip().lower()
+                            choice = _safe_input(_colorize_prompt("p> ")).strip().lower()
                             if not choice:
                                 continue
                             if choice == 'q':
@@ -3276,7 +3707,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         elif key == 'g':
             while True:
                 print("Geometry: p=plot frame, c=canvas, q=back")
-                sub = input("Geom> ").strip().lower()
+                sub = _safe_input("Geom> ").strip().lower()
                 if not sub:
                     continue
                 if sub == 'q':
@@ -3299,18 +3730,234 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
             # Rename axis titles
             print("Tip: Use LaTeX/mathtext for special characters:")
             print("  Subscript: H$_2$O → H₂O  |  Superscript: m$^2$ → m²")
-            print("  Greek: $\\alpha$, $\\beta$  |  Angstrom: $\\AA$ → Å")
+            print("  Bullet: $\\bullet$ → •   |  Greek: $\\alpha$, $\\beta$  |  Angstrom: $\\AA$ → Å")
             while True:
-                print("Rename titles: x=x-axis, ly=left y-axis, ry=right y-axis, q=back")
-                sub = input("Rename> ").strip().lower()
+                print("Rename: x=x-axis, ly=left y-axis, ry=right y-axis, l=legend labels, q=back")
+                sub = _safe_input("Rename> ").strip().lower()
                 if not sub:
                     continue
                 if sub == 'q':
                     break
-                if sub == 'x':
+                if sub == 'l':
+                    # Rename legend labels (file name in legend)
+                    if not is_multi_file:
+                        # Single file mode: rename the default file
+                        current_file = file_data[0]
+                        sc_chg = current_file['sc_charge']
+                        sc_dchg = current_file['sc_discharge']
+                        sc_eff = current_file['sc_eff']
+                        
+                        # Get current labels
+                        chg_label = sc_chg.get_label() or ''
+                        dchg_label = sc_dchg.get_label() or ''
+                        eff_label = sc_eff.get_label() or ''
+                        
+                        # Extract base filename (everything before " charge", " discharge", or " efficiency")
+                        # Also handle patterns like "filename (Chg)", "filename (Dchg)", "filename (Eff)"
+                        base_name = current_file.get('filename', 'Data')
+                        
+                        # Try to extract from labels
+                        import re
+                        for label in [chg_label, dchg_label, eff_label]:
+                            if label:
+                                # First try to extract from bracket pattern: "filename (Chg)" -> "filename"
+                                bracket_match = re.search(r'^(.+?)\s*\([^)]+\)\s*$', label)
+                                if bracket_match:
+                                    potential_base = bracket_match.group(1).strip()
+                                    if potential_base:
+                                        base_name = potential_base
+                                        break
+                                else:
+                                    # Try to extract from text suffix patterns
+                                    for suffix in [' charge', ' discharge', ' efficiency']:
+                                        if label.endswith(suffix):
+                                            potential_base = label[:-len(suffix)].strip()
+                                            if potential_base:
+                                                base_name = potential_base
+                                                break
+                                    if base_name != current_file.get('filename', 'Data'):
+                                        break
+                        
+                        print(f"Current file name in legend: '{base_name}'")
+                        new_name = _safe_input("Enter new file name (q=cancel): ").strip()
+                        if new_name and new_name.lower() != 'q':
+                            try:
+                                push_state("rename-legend")
+                                
+                                # Extract bracket content from original labels if present
+                                import re
+                                chg_bracket = ''
+                                dchg_bracket = ''
+                                eff_bracket = ''
+                                
+                                # Check for bracket patterns in original labels
+                                chg_match = re.search(r'\(([^)]+)\)', chg_label)
+                                if chg_match:
+                                    chg_bracket = chg_match.group(1)
+                                dchg_match = re.search(r'\(([^)]+)\)', dchg_label)
+                                if dchg_match:
+                                    dchg_bracket = dchg_match.group(1)
+                                    # Fix capitalization: Dchg -> DChg
+                                    if dchg_bracket.lower() == 'dchg':
+                                        dchg_bracket = 'DChg'
+                                eff_match = re.search(r'\(([^)]+)\)', eff_label)
+                                if eff_match:
+                                    eff_bracket = eff_match.group(1)
+                                
+                                # If no brackets found, extract from label suffix or use defaults
+                                if not chg_bracket:
+                                    # Try to extract from " charge" suffix
+                                    if chg_label.endswith(' charge'):
+                                        chg_bracket = 'Chg'
+                                    else:
+                                        chg_bracket = 'Chg'
+                                if not dchg_bracket:
+                                    # Try to extract from " discharge" suffix
+                                    if dchg_label.endswith(' discharge'):
+                                        dchg_bracket = 'DChg'
+                                    else:
+                                        dchg_bracket = 'DChg'
+                                if not eff_bracket:
+                                    # Try to extract from " efficiency" suffix
+                                    if eff_label.endswith(' efficiency'):
+                                        eff_bracket = 'Eff'
+                                    else:
+                                        eff_bracket = 'Eff'
+                                
+                                # Build new labels with brackets preserved
+                                new_chg_label = f"{new_name} ({chg_bracket})"
+                                new_dchg_label = f"{new_name} ({dchg_bracket})"
+                                new_eff_label = f"{new_name} ({eff_bracket})"
+                                
+                                # Update labels
+                                sc_chg.set_label(new_chg_label)
+                                sc_dchg.set_label(new_dchg_label)
+                                sc_eff.set_label(new_eff_label)
+                                
+                                # Update filename in file_data
+                                current_file['filename'] = new_name
+                                
+                                # Rebuild legend (preserve position)
+                                _rebuild_legend(ax, ax2, file_data, preserve_position=True)
+                                fig.canvas.draw_idle()
+                                print(f"Legend labels updated: '{new_chg_label}', '{new_dchg_label}', '{new_eff_label}'")
+                            except Exception as e:
+                                print(f"Error: {e}")
+                    else:
+                        # Multi-file mode: show file list and let user select
+                        print("\nAvailable files:")
+                        _print_file_list(file_data, current_file_idx)
+                        file_choice = _safe_input("Enter file number to rename (q=cancel): ").strip()
+                        if file_choice and file_choice.lower() != 'q':
+                            try:
+                                file_idx = int(file_choice) - 1
+                                if 0 <= file_idx < len(file_data):
+                                    current_file = file_data[file_idx]
+                                    sc_chg = current_file['sc_charge']
+                                    sc_dchg = current_file['sc_discharge']
+                                    sc_eff = current_file['sc_eff']
+                                    
+                                    # Get current labels
+                                    chg_label = sc_chg.get_label() or ''
+                                    dchg_label = sc_dchg.get_label() or ''
+                                    eff_label = sc_eff.get_label() or ''
+                                    
+                                    # Extract base filename
+                                    base_name = current_file.get('filename', 'Data')
+                                    import re
+                                    for label in [chg_label, dchg_label, eff_label]:
+                                        if label:
+                                            # First try to extract from bracket pattern: "filename (Chg)" -> "filename"
+                                            bracket_match = re.search(r'^(.+?)\s*\([^)]+\)\s*$', label)
+                                            if bracket_match:
+                                                potential_base = bracket_match.group(1).strip()
+                                                if potential_base:
+                                                    base_name = potential_base
+                                                    break
+                                            else:
+                                                # Try to extract from text suffix patterns
+                                                for suffix in [' charge', ' discharge', ' efficiency']:
+                                                    if label.endswith(suffix):
+                                                        potential_base = label[:-len(suffix)].strip()
+                                                        if potential_base:
+                                                            base_name = potential_base
+                                                            break
+                                                if base_name != current_file.get('filename', 'Data'):
+                                                    break
+                                    
+                                    print(f"Current file name in legend: '{base_name}'")
+                                    new_name = _safe_input("Enter new file name (q=cancel): ").strip()
+                                    if new_name and new_name.lower() != 'q':
+                                        try:
+                                            push_state("rename-legend")
+                                            
+                                            # Extract bracket content from original labels if present
+                                            import re
+                                            chg_bracket = ''
+                                            dchg_bracket = ''
+                                            eff_bracket = ''
+                                            
+                                            # Check for bracket patterns in original labels
+                                            chg_match = re.search(r'\(([^)]+)\)', chg_label)
+                                            if chg_match:
+                                                chg_bracket = chg_match.group(1)
+                                            dchg_match = re.search(r'\(([^)]+)\)', dchg_label)
+                                            if dchg_match:
+                                                dchg_bracket = dchg_match.group(1)
+                                                # Fix capitalization: Dchg -> DChg
+                                                if dchg_bracket.lower() == 'dchg':
+                                                    dchg_bracket = 'DChg'
+                                            eff_match = re.search(r'\(([^)]+)\)', eff_label)
+                                            if eff_match:
+                                                eff_bracket = eff_match.group(1)
+                                            
+                                            # If no brackets found, extract from label suffix or use defaults
+                                            if not chg_bracket:
+                                                # Try to extract from " charge" suffix
+                                                if chg_label.endswith(' charge'):
+                                                    chg_bracket = 'Chg'
+                                                else:
+                                                    chg_bracket = 'Chg'
+                                            if not dchg_bracket:
+                                                # Try to extract from " discharge" suffix
+                                                if dchg_label.endswith(' discharge'):
+                                                    dchg_bracket = 'DChg'
+                                                else:
+                                                    dchg_bracket = 'DChg'
+                                            if not eff_bracket:
+                                                # Try to extract from " efficiency" suffix
+                                                if eff_label.endswith(' efficiency'):
+                                                    eff_bracket = 'Eff'
+                                                else:
+                                                    eff_bracket = 'Eff'
+                                            
+                                            # Build new labels with brackets preserved
+                                            new_chg_label = f"{new_name} ({chg_bracket})"
+                                            new_dchg_label = f"{new_name} ({dchg_bracket})"
+                                            new_eff_label = f"{new_name} ({eff_bracket})"
+                                            
+                                            # Update labels
+                                            sc_chg.set_label(new_chg_label)
+                                            sc_dchg.set_label(new_dchg_label)
+                                            sc_eff.set_label(new_eff_label)
+                                            
+                                            # Update filename in file_data
+                                            current_file['filename'] = new_name
+                                            
+                                            # Rebuild legend (preserve position)
+                                            _rebuild_legend(ax, ax2, file_data, preserve_position=True)
+                                            fig.canvas.draw_idle()
+                                            print(f"Legend labels updated: '{new_chg_label}', '{new_dchg_label}', '{new_eff_label}'")
+                                        except Exception as e:
+                                            print(f"Error: {e}")
+                                else:
+                                    print("Invalid file number.")
+                            except (ValueError, KeyboardInterrupt):
+                                print("Invalid input.")
+                elif sub == 'x':
                     current = ax.get_xlabel()
                     print(f"Current x-axis title: '{current}'")
-                    new_title = input("Enter new x-axis title (q=cancel): ")
+                    new_title = _safe_input("Enter new x-axis title (q=cancel): ")
                     if new_title and new_title.lower() != 'q':
                         try:
                             push_state("rename-x")
@@ -3329,7 +3976,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 elif sub == 'ly':
                     current = ax.get_ylabel()
                     print(f"Current left y-axis title: '{current}'")
-                    new_title = input("Enter new left y-axis title (q=cancel): ")
+                    new_title = _safe_input("Enter new left y-axis title (q=cancel): ")
                     if new_title and new_title.lower() != 'q':
                         try:
                             push_state("rename-ly")
@@ -3343,7 +3990,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                 elif sub == 'ry':
                     current = ax2.get_ylabel()
                     print(f"Current right y-axis title: '{current}'")
-                    new_title = input("Enter new right y-axis title (q=cancel): ")
+                    new_title = _safe_input("Enter new right y-axis title (q=cancel): ")
                     if new_title and new_title.lower() != 'q':
                         try:
                             push_state("rename-ry")
@@ -3363,7 +4010,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
             while True:
                 current_xlim = ax.get_xlim()
                 print(f"Current X range: {current_xlim[0]:.6g} to {current_xlim[1]:.6g}")
-                rng = input("Enter x-range: min max, w=upper only, s=lower only, a=auto (restore original), q=back: ").strip()
+                rng = _safe_input("Enter x-range: min max, w=upper only, s=lower only, a=auto (restore original), q=back: ").strip()
                 if not rng or rng.lower() == 'q':
                     break
                 if rng.lower() == 'w':
@@ -3371,7 +4018,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     while True:
                         current_xlim = ax.get_xlim()
                         print(f"Current X range: {current_xlim[0]:.6g} to {current_xlim[1]:.6g}")
-                        val = input(f"Enter new upper X limit (current lower: {current_xlim[0]:.6g}, q=back): ").strip()
+                        val = _safe_input(f"Enter new upper X limit (current lower: {current_xlim[0]:.6g}, q=back): ").strip()
                         if not val or val.lower() == 'q':
                             break
                         try:
@@ -3398,7 +4045,7 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
                     while True:
                         current_xlim = ax.get_xlim()
                         print(f"Current X range: {current_xlim[0]:.6g} to {current_xlim[1]:.6g}")
-                        val = input(f"Enter new lower X limit (current upper: {current_xlim[1]:.6g}, q=back): ").strip()
+                        val = _safe_input(f"Enter new lower X limit (current upper: {current_xlim[1]:.6g}, q=back): ").strip()
                         if not val or val.lower() == 'q':
                             break
                         try:
@@ -3461,208 +4108,208 @@ def cpc_interactive_menu(fig, ax, ax2, sc_charge, sc_discharge, sc_eff, file_dat
         elif key == 'y':
             while True:
                 print("Y-ranges: ly=left axis, ry=right axis, q=back")
-                ycmd = input("Y> ").strip().lower()
+                ycmd = _safe_input("Y> ").strip().lower()
                 if not ycmd:
                     continue
                 if ycmd == 'q':
                     break
                 if ycmd == 'ly':
-                    current_ylim = ax.get_ylim()
-                    print(f"Current left Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
-                    rng = input("Enter left y-range: min max, w=upper only, s=lower only, a=auto (restore original), q=cancel: ").strip()
-                    if not rng or rng.lower() == 'q':
-                        continue
-                    if rng.lower() == 'w':
-                        # Upper only: change upper limit, fix lower - stay in loop
-                        while True:
-                            current_ylim = ax.get_ylim()
-                            print(f"Current left Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
-                            val = input(f"Enter new upper left Y limit (current lower: {current_ylim[0]:.6g}, q=back): ").strip()
-                            if not val or val.lower() == 'q':
-                                break
-                            try:
-                                new_upper = float(val)
-                            except (ValueError, KeyboardInterrupt):
-                                print("Invalid value, ignored.")
-                                continue
-                            push_state("y-left-range")
-                            ax.set_ylim(current_ylim[0], new_upper)
-                            ax.relim()
-                            ax.autoscale_view(scalex=False, scaley=True)
-                            # Reapply legend position after axis change to prevent movement
-                            try:
-                                leg = ax.get_legend()
-                                if leg is not None and leg.get_visible():
-                                    _apply_legend_position()
-                            except Exception:
-                                pass
-                            fig.canvas.draw_idle()
-                            print(f"Left Y range updated: {ax.get_ylim()[0]:.6g} to {ax.get_ylim()[1]:.6g}")
-                    if rng.lower() == 'w':
-                        continue
-                    if rng.lower() == 's':
-                        # Lower only: change lower limit, fix upper - stay in loop
-                        while True:
-                            current_ylim = ax.get_ylim()
-                            print(f"Current left Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
-                            val = input(f"Enter new lower left Y limit (current upper: {current_ylim[1]:.6g}, q=back): ").strip()
-                            if not val or val.lower() == 'q':
-                                break
-                            try:
-                                new_lower = float(val)
-                            except (ValueError, KeyboardInterrupt):
-                                print("Invalid value, ignored.")
-                                continue
-                            push_state("y-left-range")
-                            ax.set_ylim(new_lower, current_ylim[1])
-                            ax.relim()
-                            ax.autoscale_view(scalex=False, scaley=True)
-                            # Reapply legend position after axis change to prevent movement
-                            try:
-                                leg = ax.get_legend()
-                                if leg is not None and leg.get_visible():
-                                    _apply_legend_position()
-                            except Exception:
-                                pass
-                            fig.canvas.draw_idle()
-                            print(f"Left Y range updated: {ax.get_ylim()[0]:.6g} to {ax.get_ylim()[1]:.6g}")
-                        continue
-                    if rng.lower() == 'a':
-                        # Auto: restore original range from scatter plots
-                        push_state("y-left-range-auto")
-                        try:
-                            all_y = []
-                            for sc in [sc_charge, sc_discharge]:
-                                if sc is not None and hasattr(sc, 'get_offsets'):
-                                    offsets = sc.get_offsets()
-                                    if offsets.size > 0:
-                                        all_y.extend([offsets[:, 1].min(), offsets[:, 1].max()])
-                            if all_y:
-                                orig_min = min(all_y)
-                                orig_max = max(all_y)
-                                ax.set_ylim(orig_min, orig_max)
+                    while True:
+                        current_ylim = ax.get_ylim()
+                        print(f"Current left Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
+                        rng = _safe_input("Enter left y-range: min max, w=upper only, s=lower only, a=auto (restore original), q=back: ").strip()
+                        if not rng or rng.lower() == 'q':
+                            break
+                        if rng.lower() == 'w':
+                            # Upper only: change upper limit, fix lower - stay in loop
+                            while True:
+                                current_ylim = ax.get_ylim()
+                                print(f"Current left Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
+                                val = _safe_input(f"Enter new upper left Y limit (current lower: {current_ylim[0]:.6g}, q=back): ").strip()
+                                if not val or val.lower() == 'q':
+                                    break
+                                try:
+                                    new_upper = float(val)
+                                except (ValueError, KeyboardInterrupt):
+                                    print("Invalid value, ignored.")
+                                    continue
+                                push_state("y-left-range")
+                                ax.set_ylim(current_ylim[0], new_upper)
                                 ax.relim()
                                 ax.autoscale_view(scalex=False, scaley=True)
+                                # Reapply legend position after axis change to prevent movement
+                                try:
+                                    leg = ax.get_legend()
+                                    if leg is not None and leg.get_visible():
+                                        _apply_legend_position()
+                                except Exception:
+                                    pass
                                 fig.canvas.draw_idle()
-                                print(f"Left Y range restored to original: {ax.get_ylim()[0]:.6g} to {ax.get_ylim()[1]:.6g}")
-                            else:
-                                print("No original data available.")
-                        except Exception as e:
-                            print(f"Error restoring original left Y range: {e}")
-                        continue
-                    parts = rng.replace(',', ' ').split()
-                    if len(parts) != 2:
-                        print("Need two numbers."); continue
-                    try:
-                        lo = float(parts[0]); hi = float(parts[1])
-                        if lo == hi:
-                            print("Min and max cannot be equal."); continue
-                        push_state("y-left-range")
-                        ax.set_ylim(min(lo, hi), max(lo, hi))
-                        fig.canvas.draw_idle()
-                    except Exception:
-                        print("Invalid numbers.")
-                elif ycmd == 'ry':
-                    try:
-                        eff_on = bool(sc_eff.get_visible())
-                    except Exception:
-                        eff_on = True
-                    if not eff_on:
-                        print("Right Y is not shown; enable efficiency with 'ry' first.")
-                        continue
-                    current_ylim = ax2.get_ylim()
-                    print(f"Current right Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
-                    rng = input("Enter right y-range: min max, w=upper only, s=lower only, a=auto (restore original), q=cancel: ").strip()
-                    if not rng or rng.lower() == 'q':
-                        continue
-                    if rng.lower() == 'w':
-                        # Upper only: change upper limit, fix lower - stay in loop
-                        while True:
-                            current_ylim = ax2.get_ylim()
-                            print(f"Current right Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
-                            val = input(f"Enter new upper right Y limit (current lower: {current_ylim[0]:.6g}, q=back): ").strip()
-                            if not val or val.lower() == 'q':
-                                break
-                            try:
-                                new_upper = float(val)
-                            except (ValueError, KeyboardInterrupt):
-                                print("Invalid value, ignored.")
-                                continue
-                            push_state("y-right-range")
-                            ax2.set_ylim(current_ylim[0], new_upper)
-                            ax2.relim()
-                            ax2.autoscale_view(scalex=False, scaley=True)
-                            # Reapply legend position after axis change to prevent movement
-                            try:
-                                leg = ax.get_legend()
-                                if leg is not None and leg.get_visible():
-                                    _apply_legend_position()
-                            except Exception:
-                                pass
-                            fig.canvas.draw_idle()
-                            print(f"Right Y range updated: {ax2.get_ylim()[0]:.6g} to {ax2.get_ylim()[1]:.6g}")
-                    if rng.lower() == 'w':
-                        continue
-                    if rng.lower() == 's':
-                        # Lower only: change lower limit, fix upper - stay in loop
-                        while True:
-                            current_ylim = ax2.get_ylim()
-                            print(f"Current right Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
-                            val = input(f"Enter new lower right Y limit (current upper: {current_ylim[1]:.6g}, q=back): ").strip()
-                            if not val or val.lower() == 'q':
-                                break
-                            try:
-                                new_lower = float(val)
-                            except (ValueError, KeyboardInterrupt):
-                                print("Invalid value, ignored.")
-                                continue
-                            push_state("y-right-range")
-                            ax2.set_ylim(new_lower, current_ylim[1])
-                            ax2.relim()
-                            ax2.autoscale_view(scalex=False, scaley=True)
-                            # Reapply legend position after axis change to prevent movement
+                                print(f"Left Y range updated: {ax.get_ylim()[0]:.6g} to {ax.get_ylim()[1]:.6g}")
+                            continue
+                        if rng.lower() == 's':
+                            # Lower only: change lower limit, fix upper - stay in loop
+                            while True:
+                                current_ylim = ax.get_ylim()
+                                print(f"Current left Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
+                                val = _safe_input(f"Enter new lower left Y limit (current upper: {current_ylim[1]:.6g}, q=back): ").strip()
+                                if not val or val.lower() == 'q':
+                                    break
+                                try:
+                                    new_lower = float(val)
+                                except (ValueError, KeyboardInterrupt):
+                                    print("Invalid value, ignored.")
+                                    continue
+                                push_state("y-left-range")
+                                ax.set_ylim(new_lower, current_ylim[1])
+                                ax.relim()
+                                ax.autoscale_view(scalex=False, scaley=True)
+                                # Reapply legend position after axis change to prevent movement
+                                try:
+                                    leg = ax.get_legend()
+                                    if leg is not None and leg.get_visible():
+                                        _apply_legend_position()
+                                except Exception:
+                                    pass
+                                fig.canvas.draw_idle()
+                                print(f"Left Y range updated: {ax.get_ylim()[0]:.6g} to {ax.get_ylim()[1]:.6g}")
+                            continue
+                        if rng.lower() == 'a':
+                            # Auto: restore original range from scatter plots
+                            push_state("y-left-range-auto")
                             try:
-                                leg = ax.get_legend()
-                                if leg is not None and leg.get_visible():
-                                    _apply_legend_position()
-                            except Exception:
-                                pass
+                                all_y = []
+                                for sc in [sc_charge, sc_discharge]:
+                                    if sc is not None and hasattr(sc, 'get_offsets'):
+                                        offsets = sc.get_offsets()
+                                        if offsets.size > 0:
+                                            all_y.extend([offsets[:, 1].min(), offsets[:, 1].max()])
+                                if all_y:
+                                    orig_min = min(all_y)
+                                    orig_max = max(all_y)
+                                    ax.set_ylim(orig_min, orig_max)
+                                    ax.relim()
+                                    ax.autoscale_view(scalex=False, scaley=True)
+                                    fig.canvas.draw_idle()
+                                    print(f"Left Y range restored to original: {ax.get_ylim()[0]:.6g} to {ax.get_ylim()[1]:.6g}")
+                                else:
+                                    print("No original data available.")
+                            except Exception as e:
+                                print(f"Error restoring original left Y range: {e}")
+                            continue
+                        parts = rng.replace(',', ' ').split()
+                        if len(parts) != 2:
+                            print("Need two numbers."); continue
+                        try:
+                            lo = float(parts[0]); hi = float(parts[1])
+                            if lo == hi:
+                                print("Min and max cannot be equal."); continue
+                            push_state("y-left-range")
+                            ax.set_ylim(min(lo, hi), max(lo, hi))
                             fig.canvas.draw_idle()
-                            print(f"Right Y range updated: {ax2.get_ylim()[0]:.6g} to {ax2.get_ylim()[1]:.6g}")
-                        continue
-                    if rng.lower() == 'a':
-                        # Auto: restore original range from efficiency scatter plot
-                        push_state("y-right-range-auto")
+                        except Exception:
+                            print("Invalid numbers.")
+                elif ycmd == 'ry':
+                    while True:
                         try:
-                            if sc_eff is not None and hasattr(sc_eff, 'get_offsets'):
-                                offsets = sc_eff.get_offsets()
-                                if offsets.size > 0:
-                                    orig_min = float(offsets[:, 1].min())
-                                    orig_max = float(offsets[:, 1].max())
-                                    ax2.set_ylim(orig_min, orig_max)
-                                    ax2.relim()
-                                    ax2.autoscale_view(scalex=False, scaley=True)
-                                    fig.canvas.draw_idle()
-                                    print(f"Right Y range restored to original: {ax2.get_ylim()[0]:.6g} to {ax2.get_ylim()[1]:.6g}")
+                            eff_on = bool(sc_eff.get_visible())
+                        except Exception:
+                            eff_on = True
+                        if not eff_on:
+                            print("Right Y is not shown; enable efficiency with 'ry' first.")
+                            break
+                        current_ylim = ax2.get_ylim()
+                        print(f"Current right Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
+                        rng = _safe_input("Enter right y-range: min max, w=upper only, s=lower only, a=auto (restore original), q=back: ").strip()
+                        if not rng or rng.lower() == 'q':
+                            break
+                        if rng.lower() == 'w':
+                            # Upper only: change upper limit, fix lower - stay in loop
+                            while True:
+                                current_ylim = ax2.get_ylim()
+                                print(f"Current right Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
+                                val = _safe_input(f"Enter new upper right Y limit (current lower: {current_ylim[0]:.6g}, q=back): ").strip()
+                                if not val or val.lower() == 'q':
+                                    break
+                                try:
+                                    new_upper = float(val)
+                                except (ValueError, KeyboardInterrupt):
+                                    print("Invalid value, ignored.")
+                                    continue
+                                push_state("y-right-range")
+                                ax2.set_ylim(current_ylim[0], new_upper)
+                                ax2.relim()
+                                ax2.autoscale_view(scalex=False, scaley=True)
+                                # Reapply legend position after axis change to prevent movement
+                                try:
+                                    leg = ax.get_legend()
+                                    if leg is not None and leg.get_visible():
+                                        _apply_legend_position()
+                                except Exception:
+                                    pass
+                                fig.canvas.draw_idle()
+                                print(f"Right Y range updated: {ax2.get_ylim()[0]:.6g} to {ax2.get_ylim()[1]:.6g}")
+                            continue
+                        if rng.lower() == 's':
+                            # Lower only: change lower limit, fix upper - stay in loop
+                            while True:
+                                current_ylim = ax2.get_ylim()
+                                print(f"Current right Y range: {current_ylim[0]:.6g} to {current_ylim[1]:.6g}")
+                                val = _safe_input(f"Enter new lower right Y limit (current upper: {current_ylim[1]:.6g}, q=back): ").strip()
+                                if not val or val.lower() == 'q':
+                                    break
+                                try:
+                                    new_lower = float(val)
+                                except (ValueError, KeyboardInterrupt):
+                                    print("Invalid value, ignored.")
+                                    continue
+                                push_state("y-right-range")
+                                ax2.set_ylim(new_lower, current_ylim[1])
+                                ax2.relim()
+                                ax2.autoscale_view(scalex=False, scaley=True)
+                                # Reapply legend position after axis change to prevent movement
+                                try:
+                                    leg = ax.get_legend()
+                                    if leg is not None and leg.get_visible():
+                                        _apply_legend_position()
+                                except Exception:
+                                    pass
+                                fig.canvas.draw_idle()
+                                print(f"Right Y range updated: {ax2.get_ylim()[0]:.6g} to {ax2.get_ylim()[1]:.6g}")
+                            continue
+                        if rng.lower() == 'a':
+                            # Auto: restore original range from efficiency scatter plot
+                            push_state("y-right-range-auto")
+                            try:
+                                if sc_eff is not None and hasattr(sc_eff, 'get_offsets'):
+                                    offsets = sc_eff.get_offsets()
+                                    if offsets.size > 0:
+                                        orig_min = float(offsets[:, 1].min())
+                                        orig_max = float(offsets[:, 1].max())
+                                        ax2.set_ylim(orig_min, orig_max)
+                                        ax2.relim()
+                                        ax2.autoscale_view(scalex=False, scaley=True)
+                                        fig.canvas.draw_idle()
+                                        print(f"Right Y range restored to original: {ax2.get_ylim()[0]:.6g} to {ax2.get_ylim()[1]:.6g}")
+                                    else:
+                                        print("No original data available.")
                                 else:
                                     print("No original data available.")
-                            else:
-                                print("No original data available.")
-                        except Exception as e:
-                            print(f"Error restoring original right Y range: {e}")
-                        continue
-                    parts = rng.replace(',', ' ').split()
-                    if len(parts) != 2:
-                        print("Need two numbers."); continue
-                    try:
-                        lo = float(parts[0]); hi = float(parts[1])
-                        if lo == hi:
-                            print("Min and max cannot be equal."); continue
-                        push_state("y-right-range")
-                        ax2.set_ylim(min(lo, hi), max(lo, hi))
-                        fig.canvas.draw_idle()
-                    except Exception:
-                        print("Invalid numbers.")
+                            except Exception as e:
+                                print(f"Error restoring original right Y range: {e}")
+                            continue
+                        parts = rng.replace(',', ' ').split()
+                        if len(parts) != 2:
+                            print("Need two numbers."); continue
+                        try:
+                            lo = float(parts[0]); hi = float(parts[1])
+                            if lo == hi:
+                                print("Min and max cannot be equal."); continue
+                            push_state("y-right-range")
+                            ax2.set_ylim(min(lo, hi), max(lo, hi))
+                            fig.canvas.draw_idle()
+                        except Exception:
+                            print("Invalid numbers.")
             _print_menu(); continue
         else:
             print("Unknown key.")