supervertaler 1.9.153__py3-none-any.whl → 1.9.164__py3-none-any.whl

Supervertaler.py

@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.153"
+__version__ = "1.9.164"
 __phase__ = "0.9"
-__release_date__ = "2026-01-23"
+__release_date__ = "2026-01-26"
 __edition__ = "Qt"
 
 import sys
@@ -240,6 +240,7 @@ from modules.find_replace_qt import (
     HistoryComboBox,
 )  # F&R History and Sets
 from modules.shortcut_manager import ShortcutManager  # Keyboard shortcut management
+from modules.termview_widget import TermviewWidget  # Termview widget for glossary display
 
 
 STATUS_ORDER = [
@@ -1566,11 +1567,15 @@ class ReadOnlyGridTextEditor(QTextEdit):
         """
         from PyQt6.QtGui import QTextCursor, QTextCharFormat, QColor, QFont
         
+        print(f"[HIGHLIGHT DEBUG] highlight_termbase_matches called with {len(matches_dict) if matches_dict else 0} matches")
+        
         # Get the document and create a cursor
         doc = self.document()
         text = self.toPlainText()
         text_lower = text.lower()
         
+        print(f"[HIGHLIGHT DEBUG] Widget text length: {len(text)}, text preview: {text[:60]}...")
+        
         # IMPORTANT: Always clear all previous formatting first to prevent inconsistent highlighting
         cursor = QTextCursor(doc)
         cursor.select(QTextCursor.SelectionType.Document)
@@ -1579,6 +1584,7 @@ class ReadOnlyGridTextEditor(QTextEdit):
         
         # If no matches, we're done (highlighting has been cleared)
         if not matches_dict:
+            print(f"[HIGHLIGHT DEBUG] No matches, returning after clear")
             return
         
         # Get highlight style from main window settings
@@ -1597,6 +1603,8 @@ class ReadOnlyGridTextEditor(QTextEdit):
                 break
             parent = parent.parent() if hasattr(parent, 'parent') else None
         
+        print(f"[HIGHLIGHT DEBUG] Using style: {highlight_style}")
+        
         # Sort matches by source term length (longest first) to avoid partial matches
         # Since dict keys are now term_ids, we need to extract source terms first
         term_entries = []
@@ -1606,11 +1614,16 @@ class ReadOnlyGridTextEditor(QTextEdit):
                 if source_term:
                     term_entries.append((source_term, term_id, match_info))
         
+        print(f"[HIGHLIGHT DEBUG] Built {len(term_entries)} term entries from matches")
+        if term_entries:
+            print(f"[HIGHLIGHT DEBUG] First few terms to search: {[t[0] for t in term_entries[:3]]}")
+        
         # Sort by source term length (longest first)
         term_entries.sort(key=lambda x: len(x[0]), reverse=True)
         
         # Track positions we've already highlighted to avoid overlaps
         highlighted_ranges = []
+        found_count = 0
         
         for term, term_id, match_info in term_entries:
             # Get ranking, forbidden status, and termbase type
@@ -1723,11 +1736,14 @@ class ReadOnlyGridTextEditor(QTextEdit):
                     
                     # Apply format
                     cursor.setCharFormat(fmt)
+                    found_count += 1
                     
                     # Track this range as highlighted
                     highlighted_ranges.append((idx, end_idx))
                 
                 start = end_idx
+        
+        print(f"[HIGHLIGHT DEBUG] Applied formatting to {found_count} term occurrences in text")
     
     def highlight_non_translatables(self, nt_matches: list, highlighted_ranges: list = None):
         """
@@ -5751,12 +5767,19 @@ class SupervertalerQt(QMainWindow):
     # Signal for thread-safe logging (background threads emit, main thread handles)
     _log_signal = pyqtSignal(str)
     
+    # Signal for proactive highlighting - prefetch worker emits, main thread applies highlighting
+    # Args: segment_id (int), termbase_matches (dict as JSON string for thread safety)
+    _proactive_highlight_signal = pyqtSignal(int, str)
+    
     def __init__(self):
         super().__init__()
         
         # Connect thread-safe log signal (must be done first for logging to work from threads)
         self._log_signal.connect(self._log_to_ui)
         
+        # Connect proactive highlighting signal (prefetch worker emits, main thread highlights)
+        self._proactive_highlight_signal.connect(self._apply_proactive_highlighting)
+        
         # Application state
         self.current_project: Optional[Project] = None
         self.project_file_path: Optional[str] = None
@@ -5782,7 +5805,7 @@ class SupervertalerQt(QMainWindow):
         
         # Right panel visibility settings
         self.show_translation_results_pane = False  # Show Translation Results tab (hidden by default for new users)
-        self.show_compare_panel = True  # Show Compare Panel tab
+        # Note: Match Panel is always visible (no toggle needed)
         
         # TM and Termbase matching toggle (default: enabled)
         self.enable_tm_matching = True
@@ -5817,6 +5840,9 @@ class SupervertalerQt(QMainWindow):
         # Focus border settings for target cells
         self.focus_border_color = '#f1b79a'  # Peach/salmon
         self.focus_border_thickness = 2  # 2px
+        
+        # Sound effects settings
+        self.enable_sound_effects = False  # Sound effects disabled by default
 
         # Debug mode settings (for troubleshooting performance issues)
         self.debug_mode_enabled = False  # Enables verbose debug logging
@@ -5852,6 +5878,14 @@ class SupervertalerQt(QMainWindow):
         self.prefetch_stop_event = threading.Event()
         self.prefetch_queue = []  # List of segment IDs to prefetch
         
+        # Idle prefetch: prefetch next segments while user is thinking/typing
+        self.idle_prefetch_timer = None  # QTimer for triggering prefetch after typing pause
+        self.idle_prefetch_delay_ms = 1500  # Start prefetch 1.5s after user stops typing
+        
+        # 🧪 EXPERIMENTAL: Cache kill switch for performance testing
+        # When True, all caches are bypassed - direct lookups every time
+        self.disable_all_caches = False
+        
         # Undo/Redo stack for grid edits
         self.undo_stack = []  # List of (segment_id, old_target, new_target, old_status, new_status)
         self.redo_stack = []  # List of undone actions that can be redone
@@ -7388,22 +7422,22 @@ class SupervertalerQt(QMainWindow):
         results_note.setEnabled(False)
         results_zoom_menu.addAction(results_note)
         
-        # Compare Panel section
-        compare_zoom_menu = view_menu.addMenu("🔍 &Compare Panel")
+        # Match Panel zoom section
+        match_panel_zoom_menu = view_menu.addMenu("🔍 &Match Panel")
         
-        compare_zoom_in_action = QAction("Compare Panel Zoom &In", self)
-        compare_zoom_in_action.setShortcut("Ctrl+Alt+=")
-        compare_zoom_in_action.triggered.connect(self.compare_panel_zoom_in)
-        compare_zoom_menu.addAction(compare_zoom_in_action)
+        match_panel_zoom_in_action = QAction("Match Panel Zoom &In", self)
+        match_panel_zoom_in_action.setShortcut("Ctrl+Alt+=")
+        match_panel_zoom_in_action.triggered.connect(self.match_panel_zoom_in)
+        match_panel_zoom_menu.addAction(match_panel_zoom_in_action)
         
-        compare_zoom_out_action = QAction("Compare Panel Zoom &Out", self)
-        compare_zoom_out_action.setShortcut("Ctrl+Alt+-")
-        compare_zoom_out_action.triggered.connect(self.compare_panel_zoom_out)
-        compare_zoom_menu.addAction(compare_zoom_out_action)
+        match_panel_zoom_out_action = QAction("Match Panel Zoom &Out", self)
+        match_panel_zoom_out_action.setShortcut("Ctrl+Alt+-")
+        match_panel_zoom_out_action.triggered.connect(self.match_panel_zoom_out)
+        match_panel_zoom_menu.addAction(match_panel_zoom_out_action)
         
-        compare_zoom_reset_action = QAction("Compare Panel Zoom &Reset", self)
-        compare_zoom_reset_action.triggered.connect(self.compare_panel_zoom_reset)
-        compare_zoom_menu.addAction(compare_zoom_reset_action)
+        match_panel_zoom_reset_action = QAction("Match Panel Zoom &Reset", self)
+        match_panel_zoom_reset_action.triggered.connect(self.match_panel_zoom_reset)
+        match_panel_zoom_menu.addAction(match_panel_zoom_reset_action)
 
         view_menu.addSeparator()
         
@@ -11509,7 +11543,12 @@ class SupervertalerQt(QMainWindow):
                 )
     
     def _update_both_termviews(self, source_text, termbase_list, nt_matches):
-        """Update both Termview instances (one under grid, one in right panel) with the same data."""
+        """Update all three Termview instances with the same data.
+        
+        Termview locations:
+        1. Under grid (collapsible via View menu)
+        2. Match Panel tab (top section)
+        """
         # Update left Termview (under grid)
         if hasattr(self, 'termview_widget') and self.termview_widget:
             try:
@@ -11517,12 +11556,12 @@ class SupervertalerQt(QMainWindow):
             except Exception as e:
                 self.log(f"Error updating left termview: {e}")
         
-        # Update right Termview (in right panel)
-        if hasattr(self, 'termview_widget_right') and self.termview_widget_right:
+        # Update Match Panel Termview
+        if hasattr(self, 'termview_widget_match') and self.termview_widget_match:
             try:
-                self.termview_widget_right.update_with_matches(source_text, termbase_list, nt_matches)
+                self.termview_widget_match.update_with_matches(source_text, termbase_list, nt_matches)
             except Exception as e:
-                self.log(f"Error updating right termview: {e}")
+                self.log(f"Error updating Match Panel termview: {e}")
     
     def _refresh_termbase_display_for_current_segment(self):
         """Refresh only termbase/glossary display for the current segment.
@@ -16214,6 +16253,36 @@ class SupervertalerQt(QMainWindow):
         self.precision_spin = precision_spin
         self.auto_center_cb = auto_center_cb
         
+        # 🧪 Experimental Performance group
+        experimental_group = QGroupBox("🧪 Experimental Performance")
+        experimental_layout = QVBoxLayout()
+        
+        exp_info = QLabel(
+            "⚠️ These options are for testing and debugging performance.\n"
+            "Use with caution - they may affect application behavior."
+        )
+        exp_info.setWordWrap(True)
+        exp_info.setStyleSheet("color: #d97706; font-size: 9pt; padding: 5px;")
+        experimental_layout.addWidget(exp_info)
+        
+        # Cache kill switch
+        disable_cache_cb = CheckmarkCheckBox("Disable ALL caches (direct lookups every time)")
+        disable_cache_cb.setChecked(general_settings.get('disable_all_caches', False))
+        disable_cache_cb.setToolTip(
+            "When enabled, ALL caching is bypassed:\n"
+            "• Termbase cache\n"
+            "• Translation matches cache\n"
+            "• Prefetch system\n\n"
+            "Every segment navigation will perform fresh database lookups.\n"
+            "Use this to test if caching is causing issues or to measure\n"
+            "baseline performance without any caching."
+        )
+        experimental_layout.addWidget(disable_cache_cb)
+        self.disable_cache_checkbox = disable_cache_cb
+        
+        experimental_group.setLayout(experimental_layout)
+        layout.addWidget(experimental_group)
+        
         # Translation Results Match Limits group
         match_limits_group = QGroupBox("📊 Translation Results - Match Limits")
         match_limits_layout = QVBoxLayout()
@@ -16299,7 +16368,8 @@ class SupervertalerQt(QMainWindow):
             auto_confirm_100_cb=auto_confirm_100_cb,
             auto_confirm_overwrite_cb=auto_confirm_overwrite_cb,
             sound_effects_cb=sound_effects_cb,
-            sound_event_combos=sound_event_combos
+            sound_event_combos=sound_event_combos,
+            disable_cache_cb=disable_cache_cb
         ))
         layout.addWidget(save_btn)
         
@@ -16917,6 +16987,22 @@ class SupervertalerQt(QMainWindow):
         termview_font_spin.setValue(font_settings.get('termview_font_size', 10))
         termview_font_spin.setSuffix(" pt")
         termview_font_spin.setToolTip("Termview font size (6-16 pt)")
+        termview_font_spin.setMinimumHeight(28)
+        termview_font_spin.setMinimumWidth(80)
+        # Fix spinbox arrow buttons - ensure both up and down work correctly
+        termview_font_spin.setStyleSheet("""
+            QSpinBox {
+                padding-right: 20px;
+            }
+            QSpinBox::up-button {
+                width: 20px;
+                height: 14px;
+            }
+            QSpinBox::down-button {
+                width: 20px;
+                height: 14px;
+            }
+        """)
         termview_size_layout.addWidget(termview_font_spin)
         termview_size_layout.addStretch()
         termview_layout.addLayout(termview_size_layout)
@@ -16933,49 +17019,6 @@ class SupervertalerQt(QMainWindow):
         termview_group.setLayout(termview_layout)
         layout.addWidget(termview_group)
         
-        # Panel Visibility section (NEW)
-        panel_visibility_group = QGroupBox("👁️ Right Panel Visibility")
-        panel_visibility_layout = QVBoxLayout()
-        
-        panel_visibility_info = QLabel(
-            "Choose which panels to show on the right side of the editor. "
-            "The first visible panel will be selected by default."
-        )
-        panel_visibility_info.setStyleSheet("font-size: 8pt; padding: 8px; border-radius: 2px;")
-        panel_visibility_info.setWordWrap(True)
-        panel_visibility_layout.addWidget(panel_visibility_info)
-        
-        # Translation Results pane checkbox
-        show_results_check = CheckmarkCheckBox("Show Translation Results pane")
-        show_results_check.setChecked(font_settings.get('show_translation_results_pane', False))
-        show_results_check.setToolTip("Show TM matches, MT results, and segment notes in a tabbed panel")
-        panel_visibility_layout.addWidget(show_results_check)
-        
-        # Compare Panel checkbox
-        show_compare_check = CheckmarkCheckBox("Show Compare Panel")
-        show_compare_check.setChecked(font_settings.get('show_compare_panel', True))
-        show_compare_check.setToolTip("Show side-by-side comparison of source, TM match, and MT result")
-        panel_visibility_layout.addWidget(show_compare_check)
-        
-        # Warning label (shown when both are unchecked)
-        panel_warning_label = QLabel("⚠️ At least one panel must remain visible. Preview is always available.")
-        panel_warning_label.setStyleSheet("font-size: 8pt; color: #cc6600; padding: 4px;")
-        panel_warning_label.setVisible(False)
-        panel_visibility_layout.addWidget(panel_warning_label)
-        
-        # Connect checkbox signals to show warning if both unchecked
-        def update_panel_warning():
-            if not show_results_check.isChecked() and not show_compare_check.isChecked():
-                panel_warning_label.setVisible(True)
-            else:
-                panel_warning_label.setVisible(False)
-        
-        show_results_check.stateChanged.connect(lambda: update_panel_warning())
-        show_compare_check.stateChanged.connect(lambda: update_panel_warning())
-        
-        panel_visibility_group.setLayout(panel_visibility_layout)
-        layout.addWidget(panel_visibility_group)
-        
         # Quick Reference section
         reference_group = QGroupBox("⌨️ Font Size Quick Reference")
         reference_layout = QVBoxLayout()
@@ -17004,8 +17047,7 @@ class SupervertalerQt(QMainWindow):
             grid_font_spin, match_font_spin, compare_font_spin, show_tags_check, tag_color_btn,
             alt_colors_check, even_color_btn, odd_color_btn, invisible_char_color_btn, grid_font_family_combo,
             termview_font_family_combo, termview_font_spin, termview_bold_check,
-            border_color_btn, border_thickness_spin, badge_text_color_btn, tabs_above_check,
-            show_results_check, show_compare_check
+            border_color_btn, border_thickness_spin, badge_text_color_btn, tabs_above_check
         ))
         layout.addWidget(save_btn)
         
@@ -18745,7 +18787,8 @@ class SupervertalerQt(QMainWindow):
                                        enable_backup_cb=None, backup_interval_spin=None,
                                        tb_order_combo=None, tb_hide_shorter_cb=None, smart_selection_cb=None,
                                        ahk_path_edit=None, auto_center_cb=None, auto_confirm_100_cb=None,
-                                       auto_confirm_overwrite_cb=None, sound_effects_cb=None, sound_event_combos=None):
+                                       auto_confirm_overwrite_cb=None, sound_effects_cb=None, sound_event_combos=None,
+                                       disable_cache_cb=None):
         """Save general settings from UI (non-AI settings only)"""
         self.allow_replace_in_source = allow_replace_cb.isChecked()
         self.update_warning_banner()
@@ -18806,11 +18849,25 @@ class SupervertalerQt(QMainWindow):
             'results_match_font_size': 9,
             'results_compare_font_size': 9,
             'autohotkey_path': ahk_path_edit.text().strip() if ahk_path_edit is not None else existing_settings.get('autohotkey_path', ''),
-            'enable_sound_effects': sound_effects_cb.isChecked() if sound_effects_cb is not None else existing_settings.get('enable_sound_effects', False)
+            'enable_sound_effects': sound_effects_cb.isChecked() if sound_effects_cb is not None else existing_settings.get('enable_sound_effects', False),
+            'disable_all_caches': disable_cache_cb.isChecked() if disable_cache_cb is not None else existing_settings.get('disable_all_caches', False)
         }
 
         # Keep a fast-access instance value
         self.enable_sound_effects = general_settings.get('enable_sound_effects', False)
+        
+        # Update cache kill switch
+        if disable_cache_cb is not None:
+            self.disable_all_caches = disable_cache_cb.isChecked()
+            if self.disable_all_caches:
+                self.log("🧪 EXPERIMENTAL: All caches DISABLED - direct lookups enabled")
+                # Stop any running background workers that use the database
+                if hasattr(self, 'termbase_batch_stop_event'):
+                    self.termbase_batch_stop_event.set()
+                if hasattr(self, 'prefetch_stop_event'):
+                    self.prefetch_stop_event.set()
+            else:
+                self.log("✓ Caches enabled (normal mode)")
 
         # Persist per-event sound mapping
         existing_map = existing_settings.get('sound_effects_map', {}) if isinstance(existing_settings, dict) else {}
@@ -18875,6 +18932,8 @@ class SupervertalerQt(QMainWindow):
                 'termbase_display_order': self.termbase_display_order,
                 'termbase_hide_shorter_matches': self.termbase_hide_shorter_matches,
                 'enable_smart_word_selection': self.enable_smart_word_selection,
+                'enable_sound_effects': self.enable_sound_effects,
+                'sound_effects_map': getattr(self, 'sound_effects_map', {}),
             }
             self.log("💾 Settings also saved to active project")
             self.project_modified = True  # Mark project as modified
@@ -18889,8 +18948,7 @@ class SupervertalerQt(QMainWindow):
     def _save_view_settings_from_ui(self, grid_spin, match_spin, compare_spin, show_tags_check=None, tag_color_btn=None,
                                      alt_colors_check=None, even_color_btn=None, odd_color_btn=None, invisible_char_color_btn=None,
                                      grid_font_family_combo=None, termview_font_family_combo=None, termview_font_spin=None, termview_bold_check=None,
-                                     border_color_btn=None, border_thickness_spin=None, badge_text_color_btn=None, tabs_above_check=None,
-                                     show_results_check=None, show_compare_check=None):
+                                     border_color_btn=None, border_thickness_spin=None, badge_text_color_btn=None, tabs_above_check=None):
         """Save view settings from UI"""
         general_settings = {
             'restore_last_project': self.load_general_settings().get('restore_last_project', False),
@@ -18906,14 +18964,6 @@ class SupervertalerQt(QMainWindow):
             general_settings['tabs_above_grid'] = tabs_above_check.isChecked()
             self.tabs_above_grid = tabs_above_check.isChecked()
         
-        # Add panel visibility settings if provided
-        if show_results_check is not None:
-            general_settings['show_translation_results_pane'] = show_results_check.isChecked()
-            self.show_translation_results_pane = show_results_check.isChecked()
-        if show_compare_check is not None:
-            general_settings['show_compare_panel'] = show_compare_check.isChecked()
-            self.show_compare_panel = show_compare_check.isChecked()
-        
         # Add font family if provided
         if grid_font_family_combo is not None:
             general_settings['grid_font_family'] = grid_font_family_combo.currentText()
@@ -19001,13 +19051,20 @@ class SupervertalerQt(QMainWindow):
         
         self.save_general_settings(general_settings)
         
-        # Apply termview font settings immediately
+        # Apply termview font settings immediately to BOTH termview widgets
         if hasattr(self, 'termview_widget') and self.termview_widget is not None:
             termview_family = general_settings.get('termview_font_family', 'Segoe UI')
             termview_size = general_settings.get('termview_font_size', 10)
             termview_bold = general_settings.get('termview_font_bold', False)
             self.termview_widget.set_font_settings(termview_family, termview_size, termview_bold)
         
+        # Also apply to the Match Panel's Termview widget
+        if hasattr(self, 'termview_widget_match') and self.termview_widget_match is not None:
+            termview_family = general_settings.get('termview_font_family', 'Segoe UI')
+            termview_size = general_settings.get('termview_font_size', 10)
+            termview_bold = general_settings.get('termview_font_bold', False)
+            self.termview_widget_match.set_font_settings(termview_family, termview_size, termview_bold)
+        
         # Apply font family and size immediately
         font_changed = False
         if grid_font_family_combo is not None and self.default_font_family != grid_font_family_combo.currentText():
@@ -19101,27 +19158,14 @@ class SupervertalerQt(QMainWindow):
             # Also refresh row colors
             self.apply_alternating_row_colors()
         
-        # Check if panel visibility changed (requires restart)
-        panel_visibility_changed = False
-        if show_results_check is not None or show_compare_check is not None:
-            old_results = hasattr(self, 'right_tabs') and self.right_tabs.count() > 0
-            old_compare = hasattr(self, 'right_tabs') and self.right_tabs.count() > 1
-            new_results = show_results_check.isChecked() if show_results_check else old_results
-            new_compare = show_compare_check.isChecked() if show_compare_check else old_compare
-            if (new_results != old_results or new_compare != old_compare):
-                panel_visibility_changed = True
-        
         self.log("✓ View settings saved and applied")
-        
-        if panel_visibility_changed:
-            QMessageBox.information(
-                self, "Settings Saved", 
-                "View settings have been saved.\n\n"
-                "Note: Panel visibility changes will take effect when you restart Supervertaler "
-                "or open a new project."
-            )
-        else:
-            QMessageBox.information(self, "Settings Saved", "View settings have been saved and applied successfully.")
+        # Use explicit QMessageBox instance to ensure proper dialog closing
+        msg = QMessageBox(self)
+        msg.setIcon(QMessageBox.Icon.Information)
+        msg.setWindowTitle("Settings Saved")
+        msg.setText("View settings have been saved and applied successfully.")
+        msg.setStandardButtons(QMessageBox.StandardButton.Ok)
+        msg.exec()
     
     def create_grid_view_widget(self):
         """Create the Grid View widget (existing grid functionality)"""
@@ -19555,29 +19599,6 @@ class SupervertalerQt(QMainWindow):
         tab_seg_info.setStyleSheet("font-weight: bold;")
         toolbar_layout.addWidget(tab_seg_info)
         
-        # TM/Termbase toggle button
-        tm_toggle_btn = QPushButton("🔍 TM ON")
-        tm_toggle_btn.setCheckable(True)
-        tm_toggle_btn.setChecked(True)
-        tm_toggle_btn.setStyleSheet("""
-            QPushButton {
-                background-color: #4CAF50;
-                color: white;
-                font-weight: bold;
-                padding: 4px 8px;
-                border-radius: 3px;
-            }
-            QPushButton:checked {
-                background-color: #4CAF50;
-            }
-            QPushButton:!checked {
-                background-color: #757575;
-            }
-        """)
-        tm_toggle_btn.setToolTip("Toggle TM and Glossary lookups")
-        tm_toggle_btn.clicked.connect(lambda checked: self.toggle_tm_from_editor(checked, tm_toggle_btn))
-        toolbar_layout.addWidget(tm_toggle_btn)
-        
         # Tag View toggle button
         tag_view_btn = QPushButton("🏷️ Tags OFF")
         tag_view_btn.setCheckable(True)
@@ -19616,17 +19637,6 @@ class SupervertalerQt(QMainWindow):
         
         toolbar_layout.addWidget(QLabel("|"))  # Separator
         
-        # Action buttons
-        copy_btn = QPushButton("📋 Copy")
-        copy_btn.setToolTip("Copy Source → Target")
-        copy_btn.clicked.connect(self.copy_source_to_grid_target)
-        toolbar_layout.addWidget(copy_btn)
-        
-        clear_btn = QPushButton("🗑️ Clear")
-        clear_btn.setToolTip("Clear Target")
-        clear_btn.clicked.connect(self.clear_grid_target)
-        toolbar_layout.addWidget(clear_btn)
-        
         preview_prompt_btn = QPushButton("🧪 Preview Prompts")
         preview_prompt_btn.setToolTip("Preview the complete assembled prompt\n(System Prompt + Custom Prompts + current segment)")
         preview_prompt_btn.setStyleSheet("background-color: #9C27B0; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
@@ -19662,11 +19672,6 @@ class SupervertalerQt(QMainWindow):
         
         toolbar_layout.addStretch()
         
-        save_btn = QPushButton("💾 Save")
-        save_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
-        save_btn.clicked.connect(self.save_grid_segment)
-        toolbar_layout.addWidget(save_btn)
-        
         save_next_btn = QPushButton("✓ Confirm && Next")
         save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
         save_next_btn.clicked.connect(self.confirm_selected_or_next)
@@ -19808,53 +19813,29 @@ class SupervertalerQt(QMainWindow):
             # Hide the panel if not added as tab (it still exists as child widget)
             self.translation_results_panel.hide()
         
-        # Tab 2: Compare Panel (conditionally added)
-        self.compare_panel = self._create_compare_panel()
-        if self.show_compare_panel:
-            right_tabs.addTab(self.compare_panel, "⚖️ Compare Panel")
-            compare_tab_index = tab_index
-            tab_index += 1
-        else:
-            # Hide the panel if not added as tab
-            self.compare_panel.hide()
+        # Tab 2: Match Panel (Termview + TM Source/Target) - shown first by default
+        match_panel_widget = self._create_match_panel()
+        right_tabs.addTab(match_panel_widget, "🎯 Match Panel")
+        match_panel_tab_index = tab_index
+        tab_index += 1
         
-        # Tab 3: Document Preview (always added)
+        # Tab 4: Document Preview (always added)
         preview_widget = self._create_preview_tab()
         right_tabs.addTab(preview_widget, "📄 Preview")
         preview_tab_index = tab_index
+        self._preview_tab_index = preview_tab_index  # Store for visibility checks
         tab_index += 1
         
-        # Tab 4: Segment Note (moved from bottom panel)
+        # Tab 5: Segment Note (moved from bottom panel)
         right_tabs.addTab(self._notes_widget_for_right_panel, "📝 Segment note")
         tab_index += 1
         
-        # Tab 5: Session Log (moved from bottom panel)
+        # Tab 6: Session Log (moved from bottom panel)
         right_tabs.addTab(self._session_log_widget_for_right_panel, "📋 Session Log")
         tab_index += 1
         
-        # Tab 6: Second Termview instance (duplicate of the one under grid)
-        self.termview_widget_right = TermviewWidget(self, db_manager=self.db_manager, log_callback=self.log, theme_manager=self.theme_manager)
-        self.termview_widget_right.term_insert_requested.connect(self.insert_termview_text)
-        self.termview_widget_right.edit_entry_requested.connect(self._on_termview_edit_entry)
-        self.termview_widget_right.delete_entry_requested.connect(self._on_termview_delete_entry)
-        
-        # Apply same font settings to right Termview
-        font_settings = self.load_general_settings()
-        termview_family = font_settings.get('termview_font_family', 'Segoe UI')
-        termview_size = font_settings.get('termview_font_size', 10)
-        termview_bold = font_settings.get('termview_font_bold', False)
-        self.termview_widget_right.set_font_settings(termview_family, termview_size, termview_bold)
-        
-        right_tabs.addTab(self.termview_widget_right, "🔍 Termview")
-        
-        # Set default selected tab based on visibility settings
-        # Priority: Compare Panel > Translation Results > Preview
-        if compare_tab_index >= 0:
-            right_tabs.setCurrentIndex(compare_tab_index)
-        elif results_tab_index >= 0:
-            right_tabs.setCurrentIndex(results_tab_index)
-        else:
-            right_tabs.setCurrentIndex(preview_tab_index)
+        # Set default selected tab to Match Panel (always show Match Panel first)
+        right_tabs.setCurrentIndex(match_panel_tab_index)
         
         # Store reference for later use
         self.right_tabs = right_tabs
@@ -20507,35 +20488,6 @@ class SupervertalerQt(QMainWindow):
         tab_seg_info.setStyleSheet("font-weight: bold; font-size: 11pt;")
         info_layout.addWidget(tab_seg_info, stretch=1)
 
-        # TM/Glossary toggle button
-        tm_toggle_btn = QPushButton("🔍 TM/Glossary ON")
-        tm_toggle_btn.setCheckable(True)
-        tm_toggle_btn.setChecked(True)  # Start enabled
-        tm_toggle_btn.setStyleSheet("""
-            QPushButton {
-                background-color: #4CAF50;
-                color: white;
-                font-weight: bold;
-                padding: 5px 10px;
-                border-radius: 3px;
-            }
-            QPushButton:checked {
-                background-color: #4CAF50;
-            }
-            QPushButton:!checked {
-                background-color: #757575;
-            }
-            QPushButton:hover {
-                opacity: 0.9;
-            }
-        """)
-        tm_toggle_btn.setToolTip("Toggle TM and Glossary lookups when clicking segments (speeds up editing)")
-        tm_toggle_btn.clicked.connect(lambda checked: self.toggle_tm_from_editor(checked, tm_toggle_btn))
-        info_layout.addWidget(tm_toggle_btn)
-
-        # Store reference to button for updates from Settings
-        editor_widget.tm_toggle_btn = tm_toggle_btn
-
         # Status selector
         from modules.statuses import STATUSES
         status_label = QLabel("Status:")
@@ -21328,6 +21280,14 @@ class SupervertalerQt(QMainWindow):
                 
                 if 'enable_smart_word_selection' in project_settings:
                     self.enable_smart_word_selection = project_settings['enable_smart_word_selection']
+                
+                if 'enable_sound_effects' in project_settings:
+                    self.enable_sound_effects = project_settings['enable_sound_effects']
+                    self.log(f"✓ Project override: sound effects = {self.enable_sound_effects}")
+                
+                if 'sound_effects_map' in project_settings:
+                    self.sound_effects_map = project_settings['sound_effects_map']
+                    self.log(f"✓ Project override: sound effects map loaded")
             
             self.log(f"✓ Loaded project: {self.current_project.name} ({len(self.current_project.segments)} segments)")
 
@@ -21363,6 +21323,11 @@ class SupervertalerQt(QMainWindow):
         if not self.current_project or len(self.current_project.segments) == 0:
             return
         
+        # 🧪 EXPERIMENTAL: Skip batch worker if cache kill switch is enabled
+        if getattr(self, 'disable_all_caches', False):
+            self.log("🧪 Termbase batch worker SKIPPED (caches disabled)")
+            return
+        
         # Stop any existing worker thread
         self.termbase_batch_stop_event.set()
         if self.termbase_batch_worker_thread and self.termbase_batch_worker_thread.is_alive():
@@ -21426,11 +21391,14 @@ class SupervertalerQt(QMainWindow):
                 # Search termbase for this segment using thread-local database connection
                 try:
                     # Manually query the database using thread-local connection
+                    # Pass project_id to filter by activated termbases only
+                    current_project_id = self.current_project.id if (self.current_project and hasattr(self.current_project, 'id')) else None
                     matches = self._search_termbases_thread_safe(
                         segment.source,
                         thread_db_cursor,
                         source_lang=self.current_project.source_lang if self.current_project else None,
-                        target_lang=self.current_project.target_lang if self.current_project else None
+                        target_lang=self.current_project.target_lang if self.current_project else None,
+                        project_id=current_project_id
                     )
                     
                     if matches:
@@ -21475,7 +21443,7 @@ class SupervertalerQt(QMainWindow):
             except:
                 pass
     
-    def _search_termbases_thread_safe(self, source_text: str, cursor, source_lang: str = None, target_lang: str = None) -> Dict[str, str]:
+    def _search_termbases_thread_safe(self, source_text: str, cursor, source_lang: str = None, target_lang: str = None, project_id: int = None) -> Dict[str, str]:
         """
         Search termbases using a provided cursor (thread-safe for background threads).
         This method allows background workers to query the database without SQLite threading errors.
@@ -21485,6 +21453,7 @@ class SupervertalerQt(QMainWindow):
             cursor: A database cursor from a thread-local connection
             source_lang: Source language code
             target_lang: Target language code
+            project_id: Current project ID (required to filter by activated termbases)
         
         Returns:
             Dictionary of {term: translation} matches
@@ -21509,17 +21478,21 @@ class SupervertalerQt(QMainWindow):
                     continue
 
                 try:
-                    # JOIN termbases to get is_project_termbase, name, and ranking
+                    # JOIN termbases AND termbase_activation to filter by activated termbases
+                    # This matches the logic in database_manager.py search_termbases()
                     query = """
                         SELECT 
                             t.id, t.source_term, t.target_term, t.termbase_id, t.priority,
                             t.domain, t.notes, t.project, t.client, t.forbidden,
-                            tb.is_project_termbase, tb.name as termbase_name, tb.ranking
+                            tb.is_project_termbase, tb.name as termbase_name, 
+                            COALESCE(ta.priority, tb.ranking) as ranking
                         FROM termbase_terms t
                         LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
+                        LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
                         WHERE LOWER(t.source_term) LIKE ?
+                        AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
                     """
-                    params = [f"%{clean_word.lower()}%"]
+                    params = [project_id if project_id else 0, f"%{clean_word.lower()}%"]
 
                     if source_lang_code:
                         query += " AND (t.source_lang = ? OR (t.source_lang IS NULL AND tb.source_lang = ?) OR (t.source_lang IS NULL AND tb.source_lang IS NULL))"
@@ -21610,6 +21583,62 @@ class SupervertalerQt(QMainWindow):
         except Exception:
             return {}
     
+    def _trigger_idle_prefetch(self, current_row: int):
+        """
+        Trigger prefetch for the next few segments while user is idle.
+        Called after user stops typing (debounced) - uses their thinking time productively.
+        
+        This makes Ctrl+Enter feel INSTANT because matches are already cached.
+        Also triggers PROACTIVE HIGHLIGHTING for upcoming segments with glossary matches.
+        """
+        import json
+        
+        print(f"[PROACTIVE DEBUG] _trigger_idle_prefetch called for row {current_row}")
+        
+        if not self.current_project or current_row < 0:
+            print(f"[PROACTIVE DEBUG] Early exit: no project or invalid row")
+            return
+        
+        try:
+            # Prefetch next 5 segments (enough for fast workflow, not too many to waste resources)
+            next_segment_ids = []
+            already_cached_ids = []
+            start_idx = current_row + 1
+            end_idx = min(start_idx + 5, len(self.current_project.segments))
+            
+            print(f"[PROACTIVE DEBUG] Checking segments {start_idx} to {end_idx}")
+            
+            for seg in self.current_project.segments[start_idx:end_idx]:
+                # Check if already cached
+                with self.translation_matches_cache_lock:
+                    if seg.id not in self.translation_matches_cache:
+                        next_segment_ids.append(seg.id)
+                    else:
+                        already_cached_ids.append(seg.id)
+            
+            print(f"[PROACTIVE DEBUG] Already cached IDs: {already_cached_ids}, Need prefetch: {next_segment_ids}")
+            
+            # For already-cached segments, trigger proactive highlighting immediately
+            # This handles the case where segments were cached earlier but not highlighted
+            for seg_id in already_cached_ids:
+                try:
+                    with self.termbase_cache_lock:
+                        termbase_raw = self.termbase_cache.get(seg_id, {})
+                    print(f"[PROACTIVE DEBUG] Segment {seg_id} termbase cache: {len(termbase_raw) if termbase_raw else 0} matches")
+                    if termbase_raw:
+                        termbase_json = json.dumps(termbase_raw)
+                        # Apply highlighting on main thread (we're already on main thread here)
+                        print(f"[PROACTIVE DEBUG] Calling _apply_proactive_highlighting for seg {seg_id}")
+                        self._apply_proactive_highlighting(seg_id, termbase_json)
+                except Exception as e:
+                    print(f"[PROACTIVE DEBUG] Error for seg {seg_id}: {e}")
+            
+            if next_segment_ids:
+                # Start prefetch in background (silent, no logging)
+                self._start_prefetch_worker(next_segment_ids)
+        except Exception:
+            pass  # Silent failure - prefetch is optimization, not critical
+    
     def _start_prefetch_worker(self, segment_ids):
         """
         Start background thread to prefetch TM/MT/LLM matches for given segments.
@@ -21618,6 +21647,10 @@ class SupervertalerQt(QMainWindow):
         if not segment_ids:
             return
         
+        # 🧪 EXPERIMENTAL: Skip prefetch if cache kill switch is enabled
+        if getattr(self, 'disable_all_caches', False):
+            return
+        
         # Stop any existing worker thread
         self.prefetch_stop_event.set()
         if self.prefetch_worker_thread and self.prefetch_worker_thread.is_alive():
@@ -21638,7 +21671,24 @@ class SupervertalerQt(QMainWindow):
         """
         Background worker: prefetch TM/MT/LLM matches for given segments.
         Runs in separate thread to avoid blocking UI.
+        
+        Creates its own database connection for thread-safe termbase lookups.
+        Also emits signal to apply proactive highlighting on the main thread.
         """
+        import sqlite3
+        import json
+        
+        # Create thread-local database connection for termbase searches
+        thread_db_cursor = None
+        thread_db_connection = None
+        try:
+            if hasattr(self, 'db_manager') and self.db_manager and hasattr(self.db_manager, 'db_path'):
+                thread_db_connection = sqlite3.connect(self.db_manager.db_path)
+                thread_db_connection.row_factory = sqlite3.Row
+                thread_db_cursor = thread_db_connection.cursor()
+        except Exception:
+            pass  # Continue without thread-local connection - will use cache only
+        
         try:
             for idx, segment_id in enumerate(segment_ids):
                 # Check stop signal
@@ -21661,8 +21711,8 @@ class SupervertalerQt(QMainWindow):
                 if not segment:
                     continue
                 
-                # Fetch TM/MT/LLM matches (this is the expensive part)
-                matches = self._fetch_all_matches_for_segment(segment)
+                # Fetch TM/termbase matches (pass cursor for thread-safe termbase lookups)
+                matches = self._fetch_all_matches_for_segment(segment, thread_db_cursor)
                 
                 # Only cache if we got at least one match (don't cache empty results)
                 # This prevents "empty cache hits" when TM database is still empty
@@ -21672,19 +21722,60 @@ class SupervertalerQt(QMainWindow):
                 llm_count = len(matches.get("LLM", []))
                 total_matches = tm_count + tb_count + mt_count + llm_count
                 
+                print(f"[PREFETCH DEBUG] Segment {segment_id}: TM={tm_count}, TB={tb_count}, MT={mt_count}, LLM={llm_count}")
+                
                 if total_matches > 0:
                     # Store in cache only if we have results
                     with self.translation_matches_cache_lock:
                         self.translation_matches_cache[segment_id] = matches
+                    
+                    # PROACTIVE HIGHLIGHTING: Emit signal to apply highlighting on main thread
+                    # This makes upcoming segments show their glossary matches immediately
+                    if tb_count > 0:
+                        try:
+                            # Extract raw termbase matches from cache for highlighting
+                            with self.termbase_cache_lock:
+                                termbase_raw = self.termbase_cache.get(segment_id, {})
+                            
+                            print(f"[PREFETCH DEBUG] Segment {segment_id}: termbase_raw has {len(termbase_raw) if termbase_raw else 0} entries")
+                            
+                            if termbase_raw:
+                                # Convert to JSON for thread-safe signal transfer
+                                termbase_json = json.dumps(termbase_raw)
+                                # Emit signal - will be handled on main thread
+                                print(f"[PREFETCH DEBUG] Emitting proactive highlight signal for segment {segment_id}")
+                                self._proactive_highlight_signal.emit(segment_id, termbase_json)
+                            else:
+                                print(f"[PREFETCH DEBUG] WARNING: tb_count={tb_count} but termbase_raw is empty!")
+                        except Exception as e:
+                            print(f"[PREFETCH DEBUG] ERROR emitting signal: {e}")
                 # else: Don't cache empty results - let it fall through to slow lookup next time
             
         except Exception as e:
             self.log(f"Error in prefetch worker: {e}")
+        
+        finally:
+            # Close thread-local database connection
+            if thread_db_cursor:
+                try:
+                    thread_db_cursor.close()
+                except:
+                    pass
+            if thread_db_connection:
+                try:
+                    thread_db_connection.close()
+                except:
+                    pass
     
-    def _fetch_all_matches_for_segment(self, segment):
+    def _fetch_all_matches_for_segment(self, segment, thread_db_cursor=None):
         """
         Fetch TM, MT, and LLM matches for a single segment.
         Used by prefetch worker. Returns matches_dict with all match types.
+        
+        Args:
+            segment: The segment to fetch matches for
+            thread_db_cursor: Optional thread-local database cursor for termbase searches.
+                              If provided and segment not in termbase_cache, will do direct lookup.
         """
         from modules.translation_results_panel import TranslationMatch
         
@@ -21747,53 +21838,80 @@ class SupervertalerQt(QMainWindow):
             # LLM will still be fetched on-demand when user clicks
             pass
         
-        # 4. Termbase matches (from cache)
+        # 4. Termbase matches - try cache first, then direct lookup if cursor provided
+        termbase_matches_raw = None
+        
         with self.termbase_cache_lock:
             if segment.id in self.termbase_cache:
-                stored_matches = self.termbase_cache[segment.id]
-                for term_id, match_info in stored_matches.items():
-                    # Extract source term, translation, ranking, and other metadata from match_info
-                    if isinstance(match_info, dict):
-                        source_term = match_info.get('source', '')
-                        target_term = match_info.get('translation', '')
-                        priority = match_info.get('priority', 50)  # Keep for backward compatibility
-                        ranking = match_info.get('ranking', None)  # NEW: termbase ranking
-                        forbidden = match_info.get('forbidden', False)
-                        is_project_termbase = match_info.get('is_project_termbase', False)
-                        termbase_name = match_info.get('termbase_name', 'Default')
-                    else:
-                        # Backward compatibility: if just string (shouldn't happen with new code)
-                        source_term = str(term_id)
-                        target_term = match_info
-                        priority = 50
-                        ranking = None
-                        forbidden = False
-                        is_project_termbase = False
-                        termbase_name = 'Default'
-                    
-                    match_obj = TranslationMatch(
-                        source=source_term,
-                        target=target_term,
-                        relevance=95,
-                        metadata={
-                            'termbase_name': termbase_name,
-                            'priority': priority,  # Keep for backward compatibility
-                            'ranking': ranking,  # NEW: termbase-level ranking
-                            'forbidden': forbidden,
-                            'is_project_termbase': is_project_termbase,
-                            'term_id': match_info.get('term_id') if isinstance(match_info, dict) else None,
-                            'termbase_id': match_info.get('termbase_id') if isinstance(match_info, dict) else None,
-                            'domain': match_info.get('domain', '') if isinstance(match_info, dict) else '',
-                            'notes': match_info.get('notes', '') if isinstance(match_info, dict) else '',
-                            'project': match_info.get('project', '') if isinstance(match_info, dict) else '',
-                            'client': match_info.get('client', '') if isinstance(match_info, dict) else '',
-                            'target_synonyms': match_info.get('target_synonyms', []) if isinstance(match_info, dict) else []
-                        },
-                        match_type='Termbase',
-                        compare_source=source_term,
-                        provider_code='TB'
-                    )
-                    matches_dict["Termbases"].append(match_obj)
+                termbase_matches_raw = self.termbase_cache[segment.id]
+        
+        # If not in cache and we have a thread-local cursor, do direct lookup
+        if termbase_matches_raw is None and thread_db_cursor is not None:
+            try:
+                # Get project_id for activation filtering
+                current_project_id = None
+                if hasattr(self, 'current_project') and self.current_project and hasattr(self.current_project, 'id'):
+                    current_project_id = self.current_project.id
+                
+                termbase_matches_raw = self._search_termbases_thread_safe(
+                    segment.source,
+                    thread_db_cursor,
+                    source_lang=source_lang,
+                    target_lang=target_lang,
+                    project_id=current_project_id
+                )
+                # Also populate the termbase cache for future use
+                if termbase_matches_raw:
+                    with self.termbase_cache_lock:
+                        self.termbase_cache[segment.id] = termbase_matches_raw
+            except Exception:
+                pass  # Silently continue
+        
+        # Convert raw termbase matches to TranslationMatch objects
+        if termbase_matches_raw:
+            for term_id, match_info in termbase_matches_raw.items():
+                # Extract source term, translation, ranking, and other metadata from match_info
+                if isinstance(match_info, dict):
+                    source_term = match_info.get('source', '')
+                    target_term = match_info.get('translation', '')
+                    priority = match_info.get('priority', 50)  # Keep for backward compatibility
+                    ranking = match_info.get('ranking', None)  # NEW: termbase ranking
+                    forbidden = match_info.get('forbidden', False)
+                    is_project_termbase = match_info.get('is_project_termbase', False)
+                    termbase_name = match_info.get('termbase_name', 'Default')
+                else:
+                    # Backward compatibility: if just string (shouldn't happen with new code)
+                    source_term = str(term_id)
+                    target_term = match_info
+                    priority = 50
+                    ranking = None
+                    forbidden = False
+                    is_project_termbase = False
+                    termbase_name = 'Default'
+                
+                match_obj = TranslationMatch(
+                    source=source_term,
+                    target=target_term,
+                    relevance=95,
+                    metadata={
+                        'termbase_name': termbase_name,
+                        'priority': priority,  # Keep for backward compatibility
+                        'ranking': ranking,  # NEW: termbase-level ranking
+                        'forbidden': forbidden,
+                        'is_project_termbase': is_project_termbase,
+                        'term_id': match_info.get('term_id') if isinstance(match_info, dict) else None,
+                        'termbase_id': match_info.get('termbase_id') if isinstance(match_info, dict) else None,
+                        'domain': match_info.get('domain', '') if isinstance(match_info, dict) else '',
+                        'notes': match_info.get('notes', '') if isinstance(match_info, dict) else '',
+                        'project': match_info.get('project', '') if isinstance(match_info, dict) else '',
+                        'client': match_info.get('client', '') if isinstance(match_info, dict) else '',
+                        'target_synonyms': match_info.get('target_synonyms', []) if isinstance(match_info, dict) else []
+                    },
+                    match_type='Termbase',
+                    compare_source=source_term,
+                    provider_code='TB'
+                )
+                matches_dict["Termbases"].append(match_obj)
         
         return matches_dict
     
@@ -22051,6 +22169,8 @@ class SupervertalerQt(QMainWindow):
                 'termbase_display_order': self.termbase_display_order,
                 'termbase_hide_shorter_matches': self.termbase_hide_shorter_matches,
                 'enable_smart_word_selection': self.enable_smart_word_selection,
+                'enable_sound_effects': self.enable_sound_effects,
+                'sound_effects_map': getattr(self, 'sound_effects_map', {}),
             }
             
             # Save original DOCX path for structure-preserving export
@@ -28105,6 +28225,135 @@ class SupervertalerQt(QMainWindow):
         
         return widget
     
+    def _create_match_panel(self) -> QWidget:
+        """Create Match Panel with Termview + TM Source/Target boxes."""
+        widget = QWidget()
+        main_layout = QVBoxLayout(widget)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.setSpacing(0)
+        
+        # Initialize compare_panel_text_edits if not exists (needed for _create_compare_panel_box)
+        if not hasattr(self, 'compare_panel_text_edits'):
+            self.compare_panel_text_edits = []
+        
+        # Vertical splitter: Termview (top) | TM boxes (bottom)
+        splitter = QSplitter(Qt.Orientation.Vertical)
+        
+        # TOP: Container with header + Termview
+        termview_container = QWidget()
+        termview_layout = QVBoxLayout(termview_container)
+        termview_layout.setContentsMargins(4, 4, 4, 0)
+        termview_layout.setSpacing(2)
+        
+        # Termview header label
+        termview_header = QLabel("📖 Termview")
+        termview_header.setStyleSheet("font-weight: bold; font-size: 9px; color: #666;")
+        termview_layout.addWidget(termview_header)
+        
+        # Third Termview instance for Match Panel
+        self.termview_widget_match = TermviewWidget(self, db_manager=self.db_manager, log_callback=self.log, theme_manager=self.theme_manager)
+        # Connect Termview signals
+        self.termview_widget_match.term_insert_requested.connect(self.insert_termview_text)
+        self.termview_widget_match.edit_entry_requested.connect(self._on_termview_edit_entry)
+        self.termview_widget_match.delete_entry_requested.connect(self._on_termview_delete_entry)
+        # Apply font settings
+        font_settings = self.load_general_settings()
+        termview_family = font_settings.get('termview_font_family', 'Segoe UI')
+        termview_size = font_settings.get('termview_font_size', 10)
+        termview_bold = font_settings.get('termview_font_bold', False)
+        self.termview_widget_match.set_font_settings(termview_family, termview_size, termview_bold)
+        termview_layout.addWidget(self.termview_widget_match)
+        
+        splitter.addWidget(termview_container)
+        
+        # BOTTOM: Container for TM Source + TM Target boxes
+        tm_container = QWidget()
+        tm_layout = QHBoxLayout(tm_container)
+        tm_layout.setContentsMargins(0, 0, 0, 0)
+        tm_layout.setSpacing(0)
+        
+        # Hardcode the green color for TM boxes (same as TM Target in Compare Panel)
+        tm_box_bg = "#d4edda"    # Green (same as TM Target in Compare Panel)
+        text_color = "#333"
+        border_color = "#ddd"
+        
+        # TM Source box (GREEN, with navigation)
+        self.match_panel_tm_matches = []  # Separate match list
+        self.match_panel_tm_index = 0     # Separate navigation index
+        
+        tm_source_container, self.match_panel_tm_source, self.match_panel_tm_nav_label, tm_nav_btns = self._create_compare_panel_box(
+            "📚 TM Source", tm_box_bg, text_color, border_color, has_navigation=True)
+        if tm_nav_btns:
+            tm_nav_btns[0].clicked.connect(lambda: self._match_panel_nav_tm(-1))
+            tm_nav_btns[1].clicked.connect(lambda: self._match_panel_nav_tm(1))
+        tm_layout.addWidget(tm_source_container, 1)
+        
+        # TM Target box (GREEN, with metadata)
+        tm_target_container, self.match_panel_tm_target, self.match_panel_tm_target_label, _ = self._create_compare_panel_box(
+            "✅ TM Target", tm_box_bg, text_color, border_color, has_navigation=False, show_metadata_label=True)
+        tm_layout.addWidget(tm_target_container, 1)
+        
+        # Force stylesheet on the tm_container itself (the parent widget holding both boxes)
+        tm_container.setStyleSheet("background-color: transparent;")
+        
+        splitter.addWidget(tm_container)
+        
+        # Set initial splitter sizes (60% Termview, 40% TM boxes)
+        splitter.setSizes([600, 400])
+        
+        main_layout.addWidget(splitter)
+        
+        return widget
+    
+    def _match_panel_nav_tm(self, direction: int):
+        """Navigate TM matches in Match Panel (-1 = prev, 1 = next)"""
+        if not self.match_panel_tm_matches:
+            return
+        
+        new_index = self.match_panel_tm_index + direction
+        if 0 <= new_index < len(self.match_panel_tm_matches):
+            self.match_panel_tm_index = new_index
+            self._update_match_panel_tm_display()
+    
+    def _update_match_panel_tm_display(self):
+        """Update Match Panel TM Source and TM Target display with current match"""
+        if not self.match_panel_tm_matches:
+            self.match_panel_tm_source.setPlainText("(No TM match)")
+            self.match_panel_tm_target.setPlainText("(No TM match)")
+            if hasattr(self, 'match_panel_tm_nav_label') and self.match_panel_tm_nav_label:
+                self.match_panel_tm_nav_label.setText("(0/0)")
+            if hasattr(self, 'match_panel_tm_target_label') and self.match_panel_tm_target_label:
+                self.match_panel_tm_target_label.setText("")
+            return
+        
+        match = self.match_panel_tm_matches[self.match_panel_tm_index]
+        total = len(self.match_panel_tm_matches)
+        idx = self.match_panel_tm_index + 1
+        
+        # Update navigation label
+        if hasattr(self, 'match_panel_tm_nav_label') and self.match_panel_tm_nav_label:
+            nav_html = f"(<span style='font-size:8px'>{idx}/{total}</span>)"
+            self.match_panel_tm_nav_label.setText(nav_html)
+        
+        # Update TM Source text with diff highlighting
+        tm_source_text = match.get('source', '')
+        current_source = getattr(self, 'match_panel_current_source', '')
+        if tm_source_text and current_source:
+            self._set_compare_panel_text_with_diff(self.match_panel_tm_source, current_source, tm_source_text)
+        else:
+            self.match_panel_tm_source.setPlainText(tm_source_text or "(No TM match)")
+        
+        # Update TM Target text (no diff highlighting needed for target)
+        target_text = match.get('target', '')
+        self.match_panel_tm_target.setPlainText(target_text)
+        
+        # Update metadata label (TM name, percentage)
+        if hasattr(self, 'match_panel_tm_target_label') and self.match_panel_tm_target_label:
+            tm_name = match.get('tm_name', 'Unknown TM')
+            match_pct = match.get('match_pct', 0)
+            metadata_html = f"<span style='font-size:10px'>{tm_name}</span> (<span style='font-size:8px'>{match_pct}%</span>)"
+            self.match_panel_tm_target_label.setText(metadata_html)
+    
     def _create_compare_panel_box(self, label: str, bg_color: str, text_color: str, border_color: str,
                                    has_navigation: bool = False, show_metadata_label: bool = False,
                                    shortcut_badge_text: str = None, shortcut_badge_tooltip: str = None) -> tuple:
@@ -28356,7 +28605,7 @@ class SupervertalerQt(QMainWindow):
     
     def set_compare_panel_matches(self, segment_id: int, current_source: str, 
                                    tm_matches: list = None, mt_matches: list = None):
-        """Set all matches for the Compare Panel with navigation support
+        """Set all matches for Match Panel (and Compare Panel if it exists)
         
         Args:
             segment_id: Current segment ID
@@ -28364,38 +28613,40 @@ class SupervertalerQt(QMainWindow):
             tm_matches: List of dicts with keys: source, target, tm_name, match_pct
             mt_matches: List of dicts with keys: translation, provider
         """
-        if not hasattr(self, 'compare_panel_current_source'):
-            return
-        
-        # Update segment label
-        if hasattr(self, 'compare_panel_segment_label'):
-            self.compare_panel_segment_label.setText(f"Segment {segment_id + 1}")
-        
-        # Update Current Source
-        self.compare_panel_current_source.setPlainText(current_source)
-        
-        # Store matches and reset indices
-        self.compare_panel_tm_matches = tm_matches or []
-        self.compare_panel_mt_matches = mt_matches or []
-        self.compare_panel_tm_index = 0
-        self.compare_panel_mt_index = 0
-        
-        # Update displays
-        self._update_compare_panel_mt_display()
-        self._update_compare_panel_tm_display()
+        # Always update Match Panel with TM matches
+        self.match_panel_tm_matches = tm_matches or []
+        self.match_panel_tm_index = 0
+        self.match_panel_current_source = current_source  # Store for diff highlighting
+        self._update_match_panel_tm_display()
+        
+        # Update Compare Panel if it exists (legacy support)
+        if hasattr(self, 'compare_panel_current_source') and self.compare_panel_current_source:
+            # Update segment label
+            if hasattr(self, 'compare_panel_segment_label'):
+                self.compare_panel_segment_label.setText(f"Segment {segment_id + 1}")
+            
+            # Update Current Source
+            self.compare_panel_current_source.setPlainText(current_source)
+            
+            # Store matches and reset indices
+            self.compare_panel_tm_matches = tm_matches or []
+            self.compare_panel_mt_matches = mt_matches or []
+            self.compare_panel_tm_index = 0
+            self.compare_panel_mt_index = 0
+            
+            # Update displays
+            self._update_compare_panel_mt_display()
+            self._update_compare_panel_tm_display()
 
     def update_compare_panel(self, segment_id: int, current_source: str, 
                               tm_source: str = "", tm_target: str = "", 
                               mt_translation: str = "", tm_match_percent: int = 0,
                               tm_name: str = "TM", mt_provider: str = "MT"):
-        """Update the Compare Panel with new data for the current segment (legacy single-match method)
+        """Update the Match Panel with new data for the current segment (legacy single-match method)
         
         This is the legacy method that accepts single TM/MT matches. For multiple matches,
         use set_compare_panel_matches() instead.
         """
-        if not hasattr(self, 'compare_panel_current_source'):
-            return
-        
         # Convert to the new format and use set_compare_panel_matches
         tm_matches = []
         mt_matches = []
@@ -28480,7 +28731,7 @@ class SupervertalerQt(QMainWindow):
         text_edit.setTextCursor(cursor)
     
     def _refresh_compare_panel_theme(self):
-        """Refresh Compare Panel colors based on current theme"""
+        """Refresh Match Panel TM box colors based on current theme"""
         if not hasattr(self, 'compare_panel_text_edits'):
             return
         
@@ -28491,13 +28742,11 @@ class SupervertalerQt(QMainWindow):
             is_dark = getattr(theme, 'is_dark', 'dark' in theme.name.lower())
             border_color = theme.border
             text_color = theme.text
-            title_color = theme.text_disabled
-            # Use theme-appropriate colors for boxes
+            # Use theme-appropriate colors for Match Panel boxes (both green)
+            panel_success = theme.panel_success if hasattr(theme, 'panel_success') else ("#1e3a2f" if is_dark else "#d4edda")
             box_colors = [
-                theme.panel_info if hasattr(theme, 'panel_info') else ("#2d3748" if is_dark else "#e3f2fd"),
-                theme.panel_warning if hasattr(theme, 'panel_warning') else ("#3d3520" if is_dark else "#fff3cd"),
-                theme.panel_success if hasattr(theme, 'panel_success') else ("#1e3a2f" if is_dark else "#d4edda"),
-                theme.panel_neutral if hasattr(theme, 'panel_neutral') else ("#2d2d3d" if is_dark else "#e8e8f0"),
+                panel_success,  # 0: Match Panel - TM Source (green)
+                panel_success,  # 1: Match Panel - TM Target (green)
             ]
         else:
             return
@@ -28525,10 +28774,6 @@ class SupervertalerQt(QMainWindow):
                     color: {text_color};
                 }}
             """)
-        
-        # Update segment label
-        if hasattr(self, 'compare_panel_segment_label'):
-            self.compare_panel_segment_label.setStyleSheet(f"font-weight: bold; font-size: 11px; color: {title_color};")
 
     # =========================================================================
     # DOCUMENT PREVIEW TAB
@@ -28627,15 +28872,33 @@ class SupervertalerQt(QMainWindow):
                 try:
                     row_segment_id = int(id_item.text())
                     if row_segment_id == segment_id:
-                        # Switch to Grid tab if we're in Document view
-                        if hasattr(self, 'document_views_widget'):
-                            self.document_views_widget.setCurrentIndex(0)  # Grid tab
+                        # Switch to Grid tab first
+                        if hasattr(self, 'main_tabs'):
+                            self.main_tabs.setCurrentIndex(0)  # Grid tab
+                        
+                        # Handle pagination - switch to correct page if needed
+                        if hasattr(self, 'page_size_combo') and self.page_size_combo.currentText() != "All":
+                            try:
+                                page_size = int(self.page_size_combo.currentText())
+                                target_page = (row // page_size) + 1
+                                if hasattr(self, 'page_number_input'):
+                                    self.page_number_input.setText(str(target_page))
+                                    self.go_to_page()
+                            except ValueError:
+                                pass
 
                         # Select this row and focus the target cell
                         self.table.setCurrentCell(row, 3)  # Column 3 = Target
+                        self.table.scrollToItem(self.table.item(row, 0), QTableWidget.ScrollHint.PositionAtCenter)
+                        
                         target_widget = self.table.cellWidget(row, 3)
                         if target_widget:
                             target_widget.setFocus()
+                            # Place cursor at end of text
+                            if isinstance(target_widget, QTextEdit):
+                                cursor = target_widget.textCursor()
+                                cursor.movePosition(cursor.MoveOperation.End)
+                                target_widget.setTextCursor(cursor)
 
                         self.log(f"📄 Preview: Navigated to segment {segment_id}")
                         return
@@ -28660,6 +28923,111 @@ class SupervertalerQt(QMainWindow):
         
         return None
 
+    def _is_preview_tab_active(self) -> bool:
+        """Check if the Preview tab is currently selected in the right panel.
+        
+        Used to optimize performance by skipping heavy lookups when user is
+        navigating in Preview mode (they're likely just reading, not translating).
+        """
+        if not hasattr(self, 'right_tabs') or not self.right_tabs:
+            return False
+        if not hasattr(self, '_preview_tab_index'):
+            return False
+        return self.right_tabs.currentIndex() == self._preview_tab_index
+
+    def _scroll_preview_to_segment(self, segment_id: int):
+        """Scroll the preview to show the specified segment and highlight it.
+        
+        ⚡ PERFORMANCE: Only does work if Preview tab is actually visible.
+        This prevents expensive operations (looping through all segments,
+        updating char formatting) when user is working in the grid.
+        """
+        # ⚡ Skip entirely if Preview tab is not visible - major performance optimization
+        if not self._is_preview_tab_active():
+            return
+        
+        if not hasattr(self, 'preview_widgets') or not self.preview_widgets:
+            return
+        
+        for widget in self.preview_widgets:
+            if not hasattr(widget, 'segment_positions') or not hasattr(widget, 'preview_text'):
+                continue
+            
+            preview_text = widget.preview_text
+            
+            # Find the position of the target segment
+            target_start = None
+            target_end = None
+            for (start_pos, end_pos), seg_id in widget.segment_positions.items():
+                if seg_id == segment_id:
+                    target_start = start_pos
+                    target_end = end_pos
+                    break
+            
+            if target_start is None:
+                continue
+            
+            # Update highlighting - need to re-render to show new selection
+            # Store the new current segment ID and re-render
+            widget.current_highlighted_segment_id = segment_id
+            
+            # Clear existing formatting and re-apply with new highlight
+            cursor = preview_text.textCursor()
+            
+            # First, remove any existing yellow highlight from ALL segments
+            for (start_pos, end_pos), seg_id in widget.segment_positions.items():
+                cursor.setPosition(start_pos)
+                cursor.setPosition(end_pos, QTextCursor.MoveMode.KeepAnchor)
+                fmt = cursor.charFormat()
+                # Reset background - use white or status-based color
+                if seg_id == segment_id:
+                    fmt.setBackground(QColor('#fff9c4'))  # Yellow for current
+                else:
+                    # Find the segment to get its status
+                    seg = next((s for s in self.current_project.segments if s.id == seg_id), None)
+                    if seg:
+                        if seg.status == 'not_started':
+                            fmt.setBackground(QColor('#ffe6e6'))  # Light red
+                        elif seg.status in ('translated', 'pretranslated'):
+                            fmt.setBackground(QColor('#e6ffe6'))  # Light green
+                        elif seg.status in ('confirmed', 'approved', 'proofread'):
+                            fmt.setBackground(QColor('#e6f3ff'))  # Light blue
+                        else:
+                            fmt.setBackground(QColor('white'))
+                    else:
+                        fmt.setBackground(QColor('white'))
+                cursor.mergeCharFormat(fmt)
+            
+            # Now scroll to the target segment, centered in viewport
+            scroll_cursor = preview_text.textCursor()
+            scroll_cursor.setPosition(target_start)
+            preview_text.setTextCursor(scroll_cursor)
+            self._center_cursor_in_preview(preview_text)
+
+    def _center_cursor_in_preview(self, preview_text: QTextEdit):
+        """Center the current cursor position in the preview viewport"""
+        # Get the cursor rectangle (position in document coordinates)
+        cursor_rect = preview_text.cursorRect()
+        
+        # Get viewport height
+        viewport_height = preview_text.viewport().height()
+        
+        # Calculate scroll position to center the cursor
+        # cursor_rect.top() is relative to the viewport, we need document position
+        scrollbar = preview_text.verticalScrollBar()
+        current_scroll = scrollbar.value()
+        
+        # The cursor rect top is relative to viewport, so add current scroll to get document position
+        cursor_doc_y = current_scroll + cursor_rect.top()
+        
+        # Calculate target scroll to put cursor in center
+        target_scroll = cursor_doc_y - (viewport_height // 2)
+        
+        # Clamp to valid scroll range
+        target_scroll = max(0, min(target_scroll, scrollbar.maximum()))
+        
+        scrollbar.setValue(target_scroll)
+
     def refresh_preview(self):
         """Refresh all preview tabs with current document content"""
         if not self.current_project or not self.current_project.segments:
@@ -28716,15 +29084,91 @@ class SupervertalerQt(QMainWindow):
 
         # Render all segments
         current_segment_id = self._get_current_segment_id()
+        segments = self.current_project.segments
         
-        for seg in self.current_project.segments:
+        for idx, seg in enumerate(segments):
             style = getattr(seg, 'style', 'Normal') or 'Normal'
+            paragraph_id = getattr(seg, 'paragraph_id', 0)
+            seg_type = getattr(seg, 'type', 'para') or 'para'
+            
+            # Normalize type for comparison - grid shows symbols like "¶" for para, "Sub" for subtitle
+            # Type field values: "para", "heading", "list_item", "table_cell", "Sub", "¶", etc.
+            seg_type_lower = seg_type.lower() if seg_type else 'para'
+            
+            # Check if this is a heading/subtitle
+            is_heading = ('Heading' in style or 'Title' in style or 'Subtitle' in style 
+                          or seg_type_lower in ('heading', 'sub', 'subtitle', 'title'))
+            
+            # Check if this is a list item
+            source_text = seg.source.strip() if seg.source else ""
+            is_list_item = ('<li-o>' in source_text or '<li-b>' in source_text or 
+                           '<li>' in source_text or seg_type_lower == 'list_item')
+            
+            # Check if this is a new paragraph (¶ symbol or "para" type)
+            is_new_paragraph = seg_type == '¶' or seg_type_lower == 'para'
+            
+            # Determine spacing before this segment
+            need_double_break = False  # Empty line (for paragraph separation)
+            need_single_break = False  # Line break (for headings, list items)
+            need_space = False         # Just a space (running text in same paragraph)
+            
+            if idx > 0:
+                prev_seg = segments[idx - 1]
+                prev_style = getattr(prev_seg, 'style', 'Normal') or 'Normal'
+                prev_paragraph_id = getattr(prev_seg, 'paragraph_id', 0)
+                prev_type = getattr(prev_seg, 'type', 'para') or 'para'
+                prev_type_lower = prev_type.lower() if prev_type else 'para'
+                
+                prev_is_heading = ('Heading' in prev_style or 'Title' in prev_style or 
+                                   'Subtitle' in prev_style or 
+                                   prev_type_lower in ('heading', 'sub', 'subtitle', 'title'))
+                prev_is_paragraph = prev_type == '¶' or prev_type_lower == 'para'
+                prev_is_list = prev_type_lower == 'list_item' or '<li' in (prev_seg.source or '')
+                
+                # Rules for spacing:
+                # 1. After a heading: double break (empty line)
+                if prev_is_heading:
+                    need_double_break = True
+                # 2. Before a heading: double break
+                elif is_heading:
+                    need_double_break = True
+                # 3. New paragraph (different paragraph_id or new ¶ type): double break
+                elif is_new_paragraph and prev_is_paragraph:
+                    # If paragraph_id is being used and changed, it's a new paragraph
+                    if paragraph_id != prev_paragraph_id and (paragraph_id != 0 or prev_paragraph_id != 0):
+                        need_double_break = True
+                    # If both are ¶ type, they are separate paragraphs
+                    elif prev_type == '¶' and seg_type == '¶':
+                        need_double_break = True
+                    else:
+                        # Same paragraph, running text
+                        need_space = True
+                # 4. List items: single break (each on own line)
+                elif is_list_item or prev_is_list:
+                    need_single_break = True
+                # 5. Default: space (running text)
+                else:
+                    need_space = True
+            
+            # Insert spacing/breaks
+            if need_double_break:
+                cursor.insertText("\n\n")  # Empty line between paragraphs
+            elif need_single_break:
+                cursor.insertText("\n")    # Line break
+            elif need_space:
+                cursor.insertText(" ")     # Space between sentences
             
             # Set formatting based on style
             char_format = QTextCharFormat()
             char_format.setFontFamily("Georgia")
-
-            if 'Heading 1' in style or 'Heading1' in style or 'Title' in style:
+            
+            # Check type field for heading detection as well
+            if is_heading and seg_type_lower in ('sub', 'subtitle'):
+                # Subtitle style (like "TECHNISCH DOMEIN")
+                char_format.setFontPointSize(13)
+                char_format.setFontWeight(QFont.Weight.Bold)
+                char_format.setForeground(QColor('#1f4068'))
+            elif 'Heading 1' in style or 'Heading1' in style or 'Title' in style or seg_type_lower == 'title':
                 char_format.setFontPointSize(18)
                 char_format.setFontWeight(QFont.Weight.Bold)
                 char_format.setForeground(QColor('#1a1a2e'))
@@ -28732,7 +29176,7 @@ class SupervertalerQt(QMainWindow):
                 char_format.setFontPointSize(15)
                 char_format.setFontWeight(QFont.Weight.Bold)
                 char_format.setForeground(QColor('#16213e'))
-            elif 'Heading 3' in style or 'Heading3' in style:
+            elif 'Heading 3' in style or 'Heading3' in style or seg_type_lower == 'heading':
                 char_format.setFontPointSize(13)
                 char_format.setFontWeight(QFont.Weight.Bold)
                 char_format.setForeground(QColor('#1f4068'))
@@ -28776,13 +29220,31 @@ class SupervertalerQt(QMainWindow):
 
             end_pos = cursor.position()
             widget.segment_positions[(start_pos, end_pos)] = seg.id
-
-            # Add line break after each segment
-            cursor.insertText("\n")
-
-        # Set cursor to beginning
-        cursor.movePosition(QTextCursor.MoveOperation.Start)
-        preview_text.setTextCursor(cursor)
+            
+            # Track position of current segment for scrolling
+            if seg.id == current_segment_id:
+                widget.current_segment_start_pos = start_pos
+
+            # Note: Line breaks are now handled at the START of each segment based on context
+            # This ensures running text flows naturally while paragraphs are separated
+
+        # Add final newline at end of document
+        cursor.insertText("\n")
+
+        # Scroll to current segment if we have one
+        if hasattr(widget, 'current_segment_start_pos') and widget.current_segment_start_pos is not None:
+            # Create cursor at the current segment position
+            scroll_cursor = preview_text.textCursor()
+            scroll_cursor.setPosition(widget.current_segment_start_pos)
+            preview_text.setTextCursor(scroll_cursor)
+            # Center the segment in the viewport
+            # Use QTimer to delay centering until after layout is complete
+            from PyQt6.QtCore import QTimer
+            QTimer.singleShot(0, lambda pt=preview_text: self._center_cursor_in_preview(pt))
+        else:
+            # Set cursor to beginning if no current segment
+            cursor.movePosition(QTextCursor.MoveOperation.Start)
+            preview_text.setTextCursor(cursor)
 
     def _render_formatted_text(self, cursor, text: str, base_format: QTextCharFormat,
                                 list_number: Optional[int] = None):
@@ -29300,39 +29762,39 @@ class SupervertalerQt(QMainWindow):
             self.save_current_font_sizes()
     
     # =========================================================================
-    # COMPARE PANEL ZOOM METHODS
+    # MATCH PANEL ZOOM METHODS
     # =========================================================================
     
-    # Class variable for Compare Panel font size
-    compare_panel_font_size = 10  # Default font size
+    # Class variable for Match Panel font size (TM Source/Target boxes)
+    match_panel_font_size = 10  # Default font size
     
-    def compare_panel_zoom_in(self):
-        """Increase font size in Compare Panel"""
-        SupervertalerQt.compare_panel_font_size = min(18, SupervertalerQt.compare_panel_font_size + 1)
-        self._apply_compare_panel_font_size()
+    def match_panel_zoom_in(self):
+        """Increase font size in Match Panel TM boxes"""
+        SupervertalerQt.match_panel_font_size = min(18, SupervertalerQt.match_panel_font_size + 1)
+        self._apply_match_panel_font_size()
         self.save_current_font_sizes()
-        self.log(f"Compare Panel font size: {SupervertalerQt.compare_panel_font_size}pt")
+        self.log(f"Match Panel font size: {SupervertalerQt.match_panel_font_size}pt")
     
-    def compare_panel_zoom_out(self):
-        """Decrease font size in Compare Panel"""
-        SupervertalerQt.compare_panel_font_size = max(7, SupervertalerQt.compare_panel_font_size - 1)
-        self._apply_compare_panel_font_size()
+    def match_panel_zoom_out(self):
+        """Decrease font size in Match Panel TM boxes"""
+        SupervertalerQt.match_panel_font_size = max(7, SupervertalerQt.match_panel_font_size - 1)
+        self._apply_match_panel_font_size()
         self.save_current_font_sizes()
-        self.log(f"Compare Panel font size: {SupervertalerQt.compare_panel_font_size}pt")
+        self.log(f"Match Panel font size: {SupervertalerQt.match_panel_font_size}pt")
     
-    def compare_panel_zoom_reset(self):
-        """Reset font size in Compare Panel to default"""
-        SupervertalerQt.compare_panel_font_size = 10
-        self._apply_compare_panel_font_size()
+    def match_panel_zoom_reset(self):
+        """Reset font size in Match Panel TM boxes to default"""
+        SupervertalerQt.match_panel_font_size = 10
+        self._apply_match_panel_font_size()
         self.save_current_font_sizes()
-        self.log("Compare Panel font size reset to 10pt")
+        self.log("Match Panel font size reset to 10pt")
     
-    def _apply_compare_panel_font_size(self):
-        """Apply current font size to all Compare Panel text edits"""
+    def _apply_match_panel_font_size(self):
+        """Apply current font size to Match Panel TM Source/Target text edits"""
         if not hasattr(self, 'compare_panel_text_edits'):
             return
         
-        font_size = SupervertalerQt.compare_panel_font_size
+        font_size = SupervertalerQt.match_panel_font_size
         
         for item in self.compare_panel_text_edits:
             text_edit = item[0]  # First element is the QTextEdit
@@ -29361,8 +29823,8 @@ class SupervertalerQt(QMainWindow):
                 general_settings['results_show_tags'] = CompactMatchItem.show_tags
             if hasattr(EditableGridTextEditor, 'tag_highlight_color'):
                 general_settings['tag_highlight_color'] = EditableGridTextEditor.tag_highlight_color
-            # Save Compare Panel font size
-            general_settings['compare_panel_font_size'] = SupervertalerQt.compare_panel_font_size
+            # Save Match Panel font size
+            general_settings['match_panel_font_size'] = SupervertalerQt.match_panel_font_size
             # Preserve other settings
             if 'restore_last_project' not in general_settings:
                 general_settings['restore_last_project'] = False
@@ -29403,7 +29865,6 @@ class SupervertalerQt(QMainWindow):
         self.precision_scroll_divisor = settings.get('precision_scroll_divisor', 3)
         # Load auto-center active segment setting (default True, like memoQ/Trados)
         self.auto_center_active_segment = settings.get('auto_center_active_segment', True)
-        self.log(f"🔄 Loaded auto-center setting: {self.auto_center_active_segment}")
         # Load termbase display settings
         self.termbase_display_order = settings.get('termbase_display_order', 'appearance')
         self.termbase_hide_shorter_matches = settings.get('termbase_hide_shorter_matches', False)
@@ -29428,6 +29889,9 @@ class SupervertalerQt(QMainWindow):
         self.show_translation_results_pane = settings.get('show_translation_results_pane', False)
         self.show_compare_panel = settings.get('show_compare_panel', True)
 
+        # 🧪 EXPERIMENTAL: Load cache kill switch setting (default: False = caches enabled)
+        self.disable_all_caches = settings.get('disable_all_caches', False)
+
         # Load LLM provider settings for AI Assistant
         llm_settings = self.load_llm_settings()
         self.current_provider = llm_settings.get('provider', 'openai')
@@ -29706,11 +30170,11 @@ class SupervertalerQt(QMainWindow):
                 EditableGridTextEditor.focus_border_color = focus_border_color
                 EditableGridTextEditor.focus_border_thickness = focus_border_thickness
                 
-            # Load and apply Compare Panel font size
-            compare_panel_size = general_settings.get('compare_panel_font_size', 10)
-            if 7 <= compare_panel_size <= 18:
-                SupervertalerQt.compare_panel_font_size = compare_panel_size
-                self._apply_compare_panel_font_size()
+            # Load and apply Match Panel font size
+            match_panel_size = general_settings.get('match_panel_font_size', 10)
+            if 7 <= match_panel_size <= 18:
+                SupervertalerQt.match_panel_font_size = match_panel_size
+                self._apply_match_panel_font_size()
                 
             if hasattr(self, 'results_panels'):
                 # Load and apply match limits
@@ -29798,6 +30262,10 @@ class SupervertalerQt(QMainWindow):
             
             # Update status bar progress stats (debounced - only after user stops typing)
             self.update_progress_stats()
+            
+            # 🚀 IDLE PREFETCH: User stopped typing, prefetch next segments for instant Ctrl+Enter
+            self._trigger_idle_prefetch(row)
+            
         except Exception as e:
             self.log(f"Error in debounced target handler: {e}")
     
@@ -29844,11 +30312,15 @@ class SupervertalerQt(QMainWindow):
             return
         self._last_selected_row = current_row
         
-        # ⚡ FAST PATH: For arrow key navigation, defer heavy lookups
-        # This makes segment navigation feel instant
+        # ⚡ FAST PATH: For arrow key OR Ctrl+Enter navigation, defer heavy lookups
+        # This makes segment navigation feel INSTANT - cursor moves first, lookups happen after
         is_arrow_nav = getattr(self, '_arrow_key_navigation', False)
-        if is_arrow_nav:
-            self._arrow_key_navigation = False  # Reset flag
+        is_ctrl_enter_nav = getattr(self, '_ctrl_enter_navigation', False)
+        
+        if is_arrow_nav or is_ctrl_enter_nav:
+            self._arrow_key_navigation = False  # Reset flags
+            self._ctrl_enter_navigation = False
+            
             # Schedule deferred lookup with short delay (150ms) for rapid navigation
             if hasattr(self, '_deferred_lookup_timer') and self._deferred_lookup_timer:
                 self._deferred_lookup_timer.stop()
@@ -29974,6 +30446,9 @@ class SupervertalerQt(QMainWindow):
                     self.log(f"⚠️ Could not find segment with ID {segment_id} in project")
                     return
                 
+                # Update Preview panel - scroll to and highlight this segment
+                self._scroll_preview_to_segment(segment_id)
+                
                 # Update Translation Results panel header with segment info
                 if hasattr(self, 'results_panels'):
                     for panel in self.results_panels:
@@ -30025,103 +30500,104 @@ class SupervertalerQt(QMainWindow):
                         notes=segment.notes
                     )
                 
+                # ⚡ PERFORMANCE: Skip heavy lookups if Preview tab is open
+                # User is likely just reading/reviewing, not actively translating
+                if self._is_preview_tab_active():
+                    if self.debug_mode_enabled:
+                        self.log(f"⏭️ Preview tab active - skipping TM/Termbase lookups for segment {segment.id}")
+                    return
+                
                 # Get termbase matches (from cache or search on-demand) - ONLY if enabled
                 matches_dict = None  # Initialize at the top level
+                cached_matches = None  # Initialize for cache skip path
 
-                # 🚀 CHECK PREFETCH CACHE FIRST for instant display (like memoQ)
-                segment_id = segment.id
-                with self.translation_matches_cache_lock:
-                    if segment_id in self.translation_matches_cache:
-                        cached_matches = self.translation_matches_cache[segment_id]
-                        
-                        # Count matches in each category
-                        tm_count = len(cached_matches.get("TM", []))
-                        tb_count = len(cached_matches.get("Termbases", []))
-                        mt_count = len(cached_matches.get("MT", []))
-                        llm_count = len(cached_matches.get("LLM", []))
-                        
-                        self.log(f"⚡ CACHE HIT for segment {segment_id}: TM={tm_count}, TB={tb_count}, MT={mt_count}, LLM={llm_count}")
-                        
-                        # Use cached results even if empty (to avoid re-searching)
-                        if True:  # Always use cache if it exists
-                            # Display cached matches immediately
-                            if hasattr(self, 'results_panels'):
-                                for panel in self.results_panels:
-                                    try:
-                                        panel.clear()
-                                        panel.set_matches(cached_matches)
-                                    except Exception as e:
-                                        self.log(f"Error displaying cached matches: {e}")
-                            
-                            # 🔄 Update TermView with cached termbase matches (always update, even if empty)
-                            if hasattr(self, 'termview_widget') and self.current_project:
-                                try:
-                                    # Convert TranslationMatch objects to dict format for termview
-                                    termbase_matches = [
-                                        {
-                                            'source_term': match.source,
-                                            'target_term': match.target,
-                                            'termbase_name': match.metadata.get('termbase_name', '') if match.metadata else '',
-                                            'ranking': match.metadata.get('ranking', 99) if match.metadata else 99,
-                                            'is_project_termbase': match.metadata.get('is_project_termbase', False) if match.metadata else False,
-                                            'term_id': match.metadata.get('term_id') if match.metadata else None,
-                                            'termbase_id': match.metadata.get('termbase_id') if match.metadata else None,
-                                            'notes': match.metadata.get('notes', '') if match.metadata else ''
-                                        }
-                                        for match in cached_matches.get("Termbases", [])
-                                    ]
-                                    # Also get NT matches (fresh, not cached - they may have changed)
-                                    nt_matches = self.find_nt_matches_in_source(segment.source)
-                                    
-                                    # Update both Termview widgets (left and right)
-                                    self._update_both_termviews(segment.source, termbase_matches, nt_matches)
-                                except Exception as e:
-                                    self.log(f"Error updating termview from cache: {e}")
+                # 🧪 EXPERIMENTAL: Skip ALL cache checks if cache kill switch is enabled
+                if not getattr(self, 'disable_all_caches', False):
+                    # 🚀 CHECK PREFETCH CACHE FIRST for instant display (like memoQ)
+                    segment_id = segment.id
+                    with self.translation_matches_cache_lock:
+                        if segment_id in self.translation_matches_cache:
+                            cached_matches = self.translation_matches_cache[segment_id]
                             
-                            # 🎯 AUTO-INSERT 100% TM MATCH from cache (if enabled in settings)
-                            self.log(f"🎯 CACHE: Auto-insert setting: {self.auto_insert_100_percent_matches}, TM count: {tm_count}")
-                            self.log(f"🎯 CACHE: Segment target: '{segment.target}' (length={len(segment.target)}, stripped='{segment.target.strip()}')")
+                            # Count matches in each category
+                            tm_count = len(cached_matches.get("TM", []))
+                            tb_count = len(cached_matches.get("Termbases", []))
+                            mt_count = len(cached_matches.get("MT", []))
+                            llm_count = len(cached_matches.get("LLM", []))
                             
-                            if self.auto_insert_100_percent_matches and tm_count > 0:
-                                # Check if segment target is empty (don't overwrite existing translations)
-                                target_empty = not segment.target or len(segment.target.strip()) == 0
-                                self.log(f"🎯 CACHE: Target empty check: {target_empty}")
-                                
-                                if target_empty:
-                                    # Find first 100% match in cached TM results
-                                    best_match = None
-                                    for tm_match in cached_matches.get("TM", []):
-                                        self.log(f"🔍 CACHE: Checking TM match: relevance={tm_match.relevance} (type={type(tm_match.relevance).__name__})")
-                                        # Use >= 99.5 to handle potential floating point issues
-                                        if float(tm_match.relevance) >= 99.5:
-                                            best_match = tm_match
-                                            self.log(f"✅ CACHE: Found 100% match with target: '{tm_match.target[:50]}...'")
-                                            break
-                                    
-                                    if best_match:
-                                        self.log(f"✨ CACHE: Auto-inserting 100% TM match into segment {segment.id} at row {current_row}")
-                                        self._auto_insert_tm_match(segment, best_match.target, current_row)
-                                        # Play 100% TM match alert sound
-                                        self._play_sound_effect('tm_100_percent_match')
-                                    else:
-                                        relevances = [(tm.relevance, type(tm.relevance).__name__) for tm in cached_matches.get("TM", [])]
-                                        self.log(f"⚠️ CACHE: No 100% match found. All relevances: {relevances}")
-                                else:
-                                    self.log(f"⚠️ CACHE: Target not empty ('{segment.target}') - skipping auto-insert")
+                            self.log(f"⚡ CACHE HIT for segment {segment_id}: TM={tm_count}, TB={tb_count}, MT={mt_count}, LLM={llm_count}")
+                else:
+                    if self.debug_mode_enabled:
+                        self.log(f"🧪 Cache DISABLED - forcing fresh lookup for segment {segment.id}")
+                
+                # Process cached matches if we have them
+                if cached_matches is not None:
+                    # Display cached matches immediately
+                    if hasattr(self, 'results_panels'):
+                        for panel in self.results_panels:
+                            try:
+                                panel.clear()
+                                panel.set_matches(cached_matches)
+                            except Exception as e:
+                                self.log(f"Error displaying cached matches: {e}")
+                    
+                    # 🔄 Update TermView with cached termbase matches (always update, even if empty)
+                    if hasattr(self, 'termview_widget') and self.current_project:
+                        try:
+                            # Convert TranslationMatch objects to dict format for termview
+                            termbase_matches = [
+                                {
+                                    'source_term': match.source,
+                                    'target_term': match.target,
+                                    'termbase_name': match.metadata.get('termbase_name', '') if match.metadata else '',
+                                    'ranking': match.metadata.get('ranking', 99) if match.metadata else 99,
+                                    'is_project_termbase': match.metadata.get('is_project_termbase', False) if match.metadata else False,
+                                    'term_id': match.metadata.get('term_id') if match.metadata else None,
+                                    'termbase_id': match.metadata.get('termbase_id') if match.metadata else None,
+                                    'notes': match.metadata.get('notes', '') if match.metadata else ''
+                                }
+                                for match in cached_matches.get("Termbases", [])
+                            ]
+                            # Also get NT matches (fresh, not cached - they may have changed)
+                            nt_matches = self.find_nt_matches_in_source(segment.source)
                             
-                            # 🔊 Play fuzzy match sound if fuzzy matches found from cache (but not 100%)
-                            if tm_count > 0:
-                                tm_matches = cached_matches.get("TM", [])
-                                has_100_match = any(float(tm.relevance) >= 99.5 for tm in tm_matches)
-                                has_fuzzy_match = any(float(tm.relevance) < 99.5 and float(tm.relevance) >= 50 for tm in tm_matches)
-                                if has_fuzzy_match and not has_100_match:
-                                    self._play_sound_effect('tm_fuzzy_match')
+                            # Update both Termview widgets (left and right)
+                            self._update_both_termviews(segment.source, termbase_matches, nt_matches)
+                        except Exception as e:
+                            self.log(f"Error updating termview from cache: {e}")
+                    
+                    # 🎯 AUTO-INSERT 100% TM MATCH from cache (if enabled in settings)
+                    tm_count = len(cached_matches.get("TM", []))
+                    if self.auto_insert_100_percent_matches and tm_count > 0:
+                        # Check if segment target is empty (don't overwrite existing translations)
+                        target_empty = not segment.target or len(segment.target.strip()) == 0
+                        
+                        if target_empty:
+                            # Find first 100% match in cached TM results
+                            best_match = None
+                            for tm_match in cached_matches.get("TM", []):
+                                # Use >= 99.5 to handle potential floating point issues
+                                if float(tm_match.relevance) >= 99.5:
+                                    best_match = tm_match
+                                    break
                             
-                            # Skip the slow lookup below, we already have everything
-                            # Continue to prefetch trigger at the end
-                            matches_dict = cached_matches  # Set for later use
-                    else:
-                        cached_matches = None
+                            if best_match:
+                                self.log(f"✨ Auto-inserting 100% TM match into segment {segment.id}")
+                                self._auto_insert_tm_match(segment, best_match.target, current_row)
+                                # Play 100% TM match alert sound
+                                self._play_sound_effect('tm_100_percent_match')
+                    
+                    # 🔊 Play fuzzy match sound if fuzzy matches found from cache (but not 100%)
+                    if tm_count > 0:
+                        tm_matches = cached_matches.get("TM", [])
+                        has_100_match = any(float(tm.relevance) >= 99.5 for tm in tm_matches)
+                        has_fuzzy_match = any(float(tm.relevance) < 99.5 and float(tm.relevance) >= 50 for tm in tm_matches)
+                        if has_fuzzy_match and not has_100_match:
+                            self._play_sound_effect('tm_fuzzy_match')
+                    
+                    # Skip the slow lookup below, we already have everything
+                    # Continue to prefetch trigger at the end
+                    matches_dict = cached_matches  # Set for later use
                 
                 # Check if TM/Termbase matching is enabled
                 if not matches_dict and (not self.enable_tm_matching and not self.enable_termbase_matching):
@@ -30133,19 +30609,23 @@ class SupervertalerQt(QMainWindow):
                         # Termbase lookup (if enabled)
                         stored_matches = {}
                         if self.enable_termbase_matching:
-                            # Check cache first (thread-safe) - uses `in` check to properly handle empty caches
+                            # 🧪 EXPERIMENTAL: Skip termbase cache if cache kill switch is enabled
                             cache_checked = False
-                            with self.termbase_cache_lock:
-                                if segment_id in self.termbase_cache:
-                                    stored_matches = self.termbase_cache[segment_id]
-                                    cache_checked = True
+                            if not getattr(self, 'disable_all_caches', False):
+                                # Check cache first (thread-safe) - uses `in` check to properly handle empty caches
+                                with self.termbase_cache_lock:
+                                    if segment_id in self.termbase_cache:
+                                        stored_matches = self.termbase_cache[segment_id]
+                                        cache_checked = True
                             
                             if not cache_checked and source_widget:
                                 stored_matches = self.find_termbase_matches_in_source(segment.source)
 
                                 # Store in cache for future access (thread-safe) - EVEN IF EMPTY
-                                with self.termbase_cache_lock:
-                                    self.termbase_cache[segment_id] = stored_matches
+                                # BUT skip cache storage if cache kill switch is enabled
+                                if not getattr(self, 'disable_all_caches', False):
+                                    with self.termbase_cache_lock:
+                                        self.termbase_cache[segment_id] = stored_matches
                             
                             # CRITICAL FIX: Always update Termview (even with empty results) - show "No matches" state
                             if hasattr(self, 'termview_widget') and self.current_project:
@@ -30349,17 +30829,37 @@ class SupervertalerQt(QMainWindow):
                         self._schedule_mt_and_llm_matches(segment, termbase_matches)
                 
                 # Trigger prefetch for next 20 segments (adaptive background caching)
+                # Also trigger PROACTIVE HIGHLIGHTING for already-cached segments
                 if self.current_project and current_row >= 0:
+                    import json
                     next_segment_ids = []
                     start_idx = current_row + 1
                     end_idx = min(start_idx + 20, len(self.current_project.segments))
                     
+                    print(f"[PROACTIVE NAV DEBUG] Navigation to row {current_row}, checking segments {start_idx} to {end_idx}")
+                    
                     for seg in self.current_project.segments[start_idx:end_idx]:
-                        # Only prefetch if not already cached
+                        # Check if already cached
                         with self.translation_matches_cache_lock:
-                            if seg.id not in self.translation_matches_cache:
-                                next_segment_ids.append(seg.id)
+                            is_cached = seg.id in self.translation_matches_cache
+                        
+                        if not is_cached:
+                            next_segment_ids.append(seg.id)
+                        else:
+                            # PROACTIVE HIGHLIGHTING: Apply highlighting for cached segments
+                            # that haven't been highlighted yet
+                            try:
+                                with self.termbase_cache_lock:
+                                    termbase_raw = self.termbase_cache.get(seg.id, {})
+                                print(f"[PROACTIVE NAV DEBUG] Seg {seg.id}: cached, termbase_raw has {len(termbase_raw) if termbase_raw else 0} matches")
+                                if termbase_raw:
+                                    termbase_json = json.dumps(termbase_raw)
+                                    print(f"[PROACTIVE NAV DEBUG] Calling _apply_proactive_highlighting for seg {seg.id}")
+                                    self._apply_proactive_highlighting(seg.id, termbase_json)
+                            except Exception as e:
+                                print(f"[PROACTIVE NAV DEBUG] Error for seg {seg.id}: {e}")
                     
+                    print(f"[PROACTIVE NAV DEBUG] Need to prefetch: {len(next_segment_ids)} segments")
                     if next_segment_ids:
                         self._start_prefetch_worker(next_segment_ids)
                         
@@ -32879,6 +33379,87 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             import traceback
             self.log(f"Traceback: {traceback.format_exc()}")
     
+    def _apply_proactive_highlighting(self, segment_id: int, termbase_matches_json: str):
+        """
+        Apply termbase highlighting proactively to a segment that was prefetched.
+        Called on main thread via signal from prefetch worker.
+        
+        This enables "see-ahead" highlighting: while you're working on segment N,
+        segments N+1, N+2, N+3 already show their glossary matches highlighted.
+        
+        Args:
+            segment_id: The segment ID to highlight
+            termbase_matches_json: JSON-encoded termbase matches dict (thread-safe transfer)
+        """
+        import json
+        
+        print(f"[PROACTIVE DEBUG] _apply_proactive_highlighting called for segment {segment_id}")
+        
+        if not self.current_project or not self.table:
+            print(f"[PROACTIVE DEBUG] Early exit: no project or table")
+            return
+        
+        try:
+            # Decode the matches from JSON
+            termbase_matches = json.loads(termbase_matches_json) if termbase_matches_json else {}
+            
+            print(f"[PROACTIVE DEBUG] Decoded {len(termbase_matches)} termbase matches")
+            
+            if not termbase_matches:
+                print(f"[PROACTIVE DEBUG] No matches to highlight, returning")
+                return  # Nothing to highlight
+            
+            # Find the row for this segment ID
+            row = -1
+            for r in range(self.table.rowCount()):
+                id_item = self.table.item(r, 0)
+                if id_item:
+                    try:
+                        row_seg_id = int(id_item.text())
+                        if row_seg_id == segment_id:
+                            row = r
+                            break
+                    except ValueError:
+                        continue
+            
+            print(f"[PROACTIVE DEBUG] Found row {row} for segment {segment_id}")
+            
+            if row < 0:
+                print(f"[PROACTIVE DEBUG] Segment not visible in current page")
+                return  # Segment not visible in current page
+            
+            # Get segment source text
+            segment = None
+            for seg in self.current_project.segments:
+                if seg.id == segment_id:
+                    segment = seg
+                    break
+            
+            if not segment:
+                print(f"[PROACTIVE DEBUG] Segment object not found")
+                return
+            
+            print(f"[PROACTIVE DEBUG] Applying highlight_source_with_termbase to row {row}")
+            print(f"[PROACTIVE DEBUG] Source text: {segment.source[:80]}...")
+            print(f"[PROACTIVE DEBUG] Matches keys: {list(termbase_matches.keys())[:5]}")
+            if termbase_matches:
+                first_key = list(termbase_matches.keys())[0]
+                print(f"[PROACTIVE DEBUG] Sample match: {first_key} => {termbase_matches[first_key]}")
+            
+            # Check if the source widget exists and is the right type
+            source_widget = self.table.cellWidget(row, 2)
+            print(f"[PROACTIVE DEBUG] Source widget type: {type(source_widget).__name__ if source_widget else 'None'}")
+            print(f"[PROACTIVE DEBUG] Has highlight method: {hasattr(source_widget, 'highlight_termbase_matches') if source_widget else 'N/A'}")
+            
+            # Apply highlighting (this updates the source cell widget)
+            self.highlight_source_with_termbase(row, segment.source, termbase_matches)
+            print(f"[PROACTIVE DEBUG] ✅ Highlighting applied successfully")
+            
+        except Exception as e:
+            print(f"[PROACTIVE DEBUG] ERROR: {e}")
+            import traceback
+            print(f"[PROACTIVE DEBUG] Traceback: {traceback.format_exc()}")
+    
     def insert_term_translation(self, row: int, translation: str):
         """
         Double-click handler: insert termbase translation into target cell
@@ -33920,6 +34501,18 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     self.log(f"   ⚠️ Panel update error: {e}")
             self.log("   ✓ Translation Results panel updated")
         
+        # 7b. Update Match Panel with TM matches
+        tm_matches_for_panel = []
+        for tm_match in tm_matches:
+            tm_matches_for_panel.append({
+                'source': tm_match.get('source', ''),
+                'target': tm_match.get('target', ''),
+                'tm_name': tm_match.get('tm_name', 'TM'),
+                'match_pct': int(tm_match.get('similarity', 0) * 100)
+            })
+        self.set_compare_panel_matches(segment_id, segment.source, tm_matches_for_panel, [])
+        self.log("   ✓ Match Panel updated")
+        
         # 8. Re-apply termbase highlighting in the grid source cell
         try:
             source_widget = self.table.cellWidget(current_row, 2)
@@ -36261,6 +36854,10 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             current_row = self.table.currentRow()
             if current_row < self.table.rowCount() - 1:
                 next_row = current_row + 1
+                
+                # ⚡ INSTANT NAVIGATION
+                self._ctrl_enter_navigation = True
+                
                 self.table.setCurrentCell(next_row, 3)  # Column 3 = Target (widget column)
                 # Get the target cell widget and set focus to it
                 target_widget = self.table.cellWidget(next_row, 3)
@@ -36427,7 +37024,6 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """Return active shortcut context for match shortcuts.
 
         Returns:
-            'compare' if Compare Panel tab is active,
             'results' if Translation Results tab is active,
             '' otherwise.
         """
@@ -36437,8 +37033,6 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             except Exception:
                 current = None
             if current is not None:
-                if hasattr(self, 'compare_panel') and self.compare_panel and current is self.compare_panel:
-                    return 'compare'
                 if hasattr(self, 'translation_results_panel') and self.translation_results_panel and current is self.translation_results_panel:
                     return 'results'
         return ''
@@ -36979,6 +37573,10 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                                 self._update_pagination_ui()
                                 self._apply_pagination_to_grid()
                     
+                    # ⚡ INSTANT NAVIGATION: Set flag so on_cell_selected uses fast path
+                    # This makes Ctrl+Enter feel instant - cursor moves first, lookups happen after
+                    self._ctrl_enter_navigation = True
+                    
                     self.table.clearSelection()
                     self.table.setCurrentCell(row, 3)  # Column 3 = Target (widget column)
                     self.log(f"⏭️ Moved to next unconfirmed segment {seg.id}")
@@ -37043,6 +37641,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                                                         self._update_pagination_ui()
                                                         self._apply_pagination_to_grid()
                                             
+                                            # ⚡ INSTANT NAVIGATION
+                                            self._ctrl_enter_navigation = True
+                                            
                                             self.table.clearSelection()
                                             self.table.setCurrentCell(next_row, 3)
                                             self.log(f"⏭️ Auto-skipped to next unconfirmed segment {next_seg.id}")
@@ -37083,6 +37684,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         self._update_pagination_ui()
                         self._apply_pagination_to_grid()
             
+            # ⚡ INSTANT NAVIGATION
+            self._ctrl_enter_navigation = True
+            
             self.table.clearSelection()
             self.table.setCurrentCell(next_row, 3)  # Column 3 = Target (widget column)
             self.log(f"⏭️ Moved to next segment (all remaining confirmed)")
@@ -37151,9 +37755,6 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             return None
 
         self.log(f"🔍 Ctrl+Enter: Row {current_row}, Segment ID {segment.id}")
-        self.log(f"🔍 Source: '{segment.source[:50]}...'")
-        self.log(f"🔍 Target before: '{segment.target[:50] if segment.target else '<empty>'}...'")
-        self.log(f"🔍 Segment object ID: {id(segment)}")
 
         old_target = segment.target
         old_status = segment.status
@@ -37162,22 +37763,15 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if target_widget:
             current_text = target_widget.toPlainText().strip()
             segment.target = current_text
-            self.log(f"🔍 Target from widget: '{current_text[:50]}...'")
-            self.log(f"🔍 After assignment: segment.target = '{segment.target[:50] if segment.target else '<empty>'}...'")
 
         segment.status = 'confirmed'
 
         # Record undo state for Ctrl+Enter confirmation
         self.record_undo_state(segment_id, old_target, segment.target, old_status, 'confirmed')
-        self.log(f"🔍 After status assignment: segment.status = '{segment.status}', segment.target = '{segment.target[:50] if segment.target else '<empty>'}...')")
         self.update_status_icon(current_row, 'confirmed')
         self.project_modified = True
         self.log(f"✅ Segment {segment.id} confirmed")
 
-        verification_seg = next((s for s in self.current_project.segments if s.id == segment.id), None)
-        if verification_seg:
-            self.log(f"✅ VERIFICATION: Segment {segment_id} - target still correct: '{verification_seg.target[:30] if verification_seg.target else 'EMPTY'}', object ID={id(verification_seg)}")
-
         self.update_progress_stats()
 
         # Play sound effect for segment confirmation
@@ -42173,9 +42767,8 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             self._compare_panel_tm_matches = []  # Reset TM matches list for navigation
             self._compare_panel_mt_matches = []  # Reset MT matches list for navigation
             
-            # Update Compare Panel with current source immediately (before TM/MT lookup)
-            if hasattr(self, 'compare_panel_current_source'):
-                self.set_compare_panel_matches(segment.id, segment.source, [], [])
+            # Update Match Panel with current source immediately (before TM/MT lookup)
+            self.set_compare_panel_matches(segment.id, segment.source, [], [])
             
             # Prepare matches dict - use the stored termbase matches from immediate display
             matches_dict = {
@@ -42189,9 +42782,6 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             # 🔥 DELAYED TM SEARCH: Search TM database using new TMDatabase with activated TMs
             if self.enable_tm_matching and hasattr(self, 'tm_database') and self.tm_database:
                 try:
-                    self.log(f"🚀 DELAYED TM SEARCH: Searching for '{segment.source[:50]}...'")
-                    self.log(f"🚀 DELAYED TM SEARCH: Project languages: {source_lang_code} → {target_lang_code}")
-                    
                     # Get activated TM IDs for current project
                     tm_ids = None
                     if hasattr(self, 'tm_metadata_mgr') and self.tm_metadata_mgr and self.current_project:
@@ -42199,18 +42789,16 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         if project_id:
                             tm_ids = self.tm_metadata_mgr.get_active_tm_ids(project_id)
                     
-                    self.log(f"🚀 DELAYED TM SEARCH: Using TM IDs: {tm_ids}")
-                    
                     # Skip TM search if no TMs are activated
                     if tm_ids is not None and isinstance(tm_ids, list) and len(tm_ids) == 0:
-                        self.log(f"🚀 DELAYED TM SEARCH: Skipping (no TMs activated)")
                         all_tm_matches = []
                     else:
                         # Search using TMDatabase (includes bidirectional + base language matching)
-                        # Pass enabled_only=False to bypass the hardcoded tm_metadata filter
                         all_tm_matches = self.tm_database.search_all(segment.source, tm_ids=tm_ids, enabled_only=False, max_matches=10)
                     
-                    self.log(f"🚀 DELAYED TM SEARCH: Found {len(all_tm_matches)} matches")
+                    # Single consolidated log message for TM search results
+                    if all_tm_matches:
+                        self.log(f"🔍 TM: Found {len(all_tm_matches)} matches for segment {segment.id}")
                     
                     for match in all_tm_matches:
                         match_obj = TranslationMatch(
@@ -42239,27 +42827,26 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                                 except Exception as e:
                                     self.log(f"Error adding TM matches: {e}")
                         
-                        # 🔄 Update Compare Panel with all TM matches (for navigation)
-                        if hasattr(self, 'compare_panel_current_source'):
-                            # Convert TranslationMatch objects to dict format for Compare Panel
-                            tm_matches_for_panel = []
-                            for tm in matches_dict["TM"]:
-                                tm_name = tm.metadata.get('tm_name', 'TM') if tm.metadata else 'TM'
-                                tm_matches_for_panel.append({
-                                    'source': tm.compare_source or tm.source,
-                                    'target': tm.target,
-                                    'tm_name': tm_name,
-                                    'match_pct': int(tm.relevance)
-                                })
-                            # Store for later (MT will be added when available)
-                            self._compare_panel_tm_matches = tm_matches_for_panel
-                            # Update panel with TM data only (MT empty for now)
-                            self.set_compare_panel_matches(
-                                segment.id,
-                                segment.source,
-                                tm_matches=tm_matches_for_panel,
-                                mt_matches=getattr(self, '_compare_panel_mt_matches', [])
-                            )
+                        # 🔄 Update Match Panel with all TM matches (for navigation)
+                        # Convert TranslationMatch objects to dict format for Match Panel
+                        tm_matches_for_panel = []
+                        for tm in matches_dict["TM"]:
+                            tm_name = tm.metadata.get('tm_name', 'TM') if tm.metadata else 'TM'
+                            tm_matches_for_panel.append({
+                                'source': tm.compare_source or tm.source,
+                                'target': tm.target,
+                                'tm_name': tm_name,
+                                'match_pct': int(tm.relevance)
+                            })
+                        # Store for later (MT will be added when available)
+                        self._compare_panel_tm_matches = tm_matches_for_panel
+                        # Update panel with TM data only (MT empty for now)
+                        self.set_compare_panel_matches(
+                            segment.id,
+                            segment.source,
+                            tm_matches=tm_matches_for_panel,
+                            mt_matches=getattr(self, '_compare_panel_mt_matches', [])
+                        )
                         
                         # 🎯 AUTO-INSERT 100% TM MATCH (if enabled in settings)
                         if self.auto_insert_100_percent_matches:
@@ -47086,7 +47673,12 @@ class AutoFingersWidget(QWidget):
     
     def setup_shortcuts(self):
         """Setup GLOBAL keyboard shortcuts for AutoFingers actions"""
-        import keyboard
+        # keyboard module is Windows-only
+        try:
+            import keyboard
+        except ImportError:
+            self.log("ℹ️ Global hotkeys not available on this platform (Windows only)")
+            return
         
         try:
             # Store hotkey references for later removal
@@ -47145,8 +47737,13 @@ class AutoFingersWidget(QWidget):
     def cleanup_hotkeys(self):
         """Cleanup AutoFingers hotkeys when widget is closed/hidden"""
         # Unregister ONLY AutoFingers hotkeys
+        # keyboard module is Windows-only
         try:
             import keyboard
+        except ImportError:
+            return  # Not available on this platform
+        
+        try:
             if hasattr(self, 'hotkeys'):
                 for hotkey in self.hotkeys:
                     try: