supervertaler 1.9.180__py3-none-any.whl → 1.9.194__py3-none-any.whl

Supervertaler.py

@@ -32,9 +32,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.180"
+__version__ = "1.9.194"
 __phase__ = "0.9"
-__release_date__ = "2026-01-28"
+__release_date__ = "2026-02-01"
 __edition__ = "Qt"
 
 import sys
@@ -1401,10 +1401,15 @@ class ReadOnlyGridTextEditor(QTextEdit):
         self.setMouseTracking(True)
 
         # Add syntax highlighter for tags (no spellcheck for source cells)
-        # Get invisible char color from main window if available
+        # Get invisible char color and tag color from main window (theme-aware)
         main_window = self._get_main_window()
         invisible_char_color = main_window.invisible_char_color if main_window and hasattr(main_window, 'invisible_char_color') else '#999999'
-        self.highlighter = TagHighlighter(self.document(), self.tag_highlight_color, invisible_char_color, enable_spellcheck=False)
+
+        # Use theme-aware tag color (light pink in dark mode, dark red in light mode)
+        is_dark = main_window and hasattr(main_window, 'theme_manager') and main_window.theme_manager and main_window.theme_manager.current_theme.name == "Dark"
+        tag_color = '#FFB6C1' if is_dark else self.tag_highlight_color  # Light pink in dark mode
+
+        self.highlighter = TagHighlighter(self.document(), tag_color, invisible_char_color, enable_spellcheck=False)
 
         # Store raw text (with tags) for mode switching
         self._raw_text = text
@@ -1659,16 +1664,12 @@ class ReadOnlyGridTextEditor(QTextEdit):
             matches_dict: Dictionary of {term: {'translation': str, 'priority': int}} or {term: str}
         """
         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)
@@ -1677,7 +1678,6 @@ 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
@@ -1695,9 +1695,7 @@ class ReadOnlyGridTextEditor(QTextEdit):
                 dotted_color = settings.get('termbase_dotted_color', '#808080')
                 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 = []
@@ -1706,11 +1704,7 @@ class ReadOnlyGridTextEditor(QTextEdit):
                 source_term = match_info.get('source', '')
                 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)
         
@@ -1835,8 +1829,6 @@ class ReadOnlyGridTextEditor(QTextEdit):
                     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):
         """
@@ -2306,10 +2298,15 @@ class ReadOnlyGridTextEditor(QTextEdit):
         
         # Superlookup search action
         if self.textCursor().hasSelection():
-            superlookup_action = QAction("🔍 Search in Superlookup (Ctrl+K)", self)
+            superlookup_action = QAction("🔍 Search in SuperLookup (Ctrl+K)", self)
             superlookup_action.triggered.connect(self._handle_superlookup_search)
             menu.addAction(superlookup_action)
-            menu.addSeparator()
+
+        # MT Quick Lookup action
+        mt_lookup_action = QAction("⚡ QuickTrans (Ctrl+M)", self)
+        mt_lookup_action.triggered.connect(self._handle_mt_quick_lookup)
+        menu.addAction(mt_lookup_action)
+        menu.addSeparator()
 
         # QuickMenu (prompt-based actions)
         try:
@@ -2363,7 +2360,7 @@ class ReadOnlyGridTextEditor(QTextEdit):
         """Handle Ctrl+Alt+N: Add selected text to active non-translatable list(s)"""
         # Get selected text
         selected_text = self.textCursor().selectedText().strip()
-        
+
         if not selected_text:
             from PyQt6.QtWidgets import QMessageBox
             QMessageBox.warning(
@@ -2372,14 +2369,14 @@ class ReadOnlyGridTextEditor(QTextEdit):
                 "Please select text in the Source cell before adding to non-translatables."
             )
             return
-        
+
         # Find main window and call add_to_nt method
         table = self.table_ref if hasattr(self, 'table_ref') else self.parent()
         if table:
             main_window = table.parent()
             while main_window and not hasattr(main_window, 'add_text_to_non_translatables'):
                 main_window = main_window.parent()
-            
+
             if main_window and hasattr(main_window, 'add_text_to_non_translatables'):
                 main_window.add_text_to_non_translatables(selected_text)
             else:
@@ -2390,6 +2387,16 @@ class ReadOnlyGridTextEditor(QTextEdit):
                     "Non-translatables functionality not available."
                 )
 
+    def _handle_mt_quick_lookup(self):
+        """Handle right-click: Open MT Quick Lookup popup for selected text or full source"""
+        # Get selected text (if any)
+        selected_text = self.textCursor().selectedText().strip() if self.textCursor().hasSelection() else None
+
+        # Find main window and call show_mt_quick_popup
+        main_window = self._get_main_window()
+        if main_window and hasattr(main_window, 'show_mt_quick_popup'):
+            main_window.show_mt_quick_popup(text_override=selected_text)
+
     def set_background_color(self, color: str):
         """Set the background color for this text editor (for alternating row colors)"""
         self.setStyleSheet(f"""
@@ -2739,10 +2746,15 @@ class EditableGridTextEditor(QTextEdit):
         self.setPalette(palette)
 
         # Add syntax highlighter for tags (with spellcheck enabled for target cells)
-        # Get invisible char color from main window if available
+        # Get invisible char color and tag color from main window (theme-aware)
         main_window = self._get_main_window()
         invisible_char_color = main_window.invisible_char_color if main_window and hasattr(main_window, 'invisible_char_color') else '#999999'
-        self.highlighter = TagHighlighter(self.document(), self.tag_highlight_color, invisible_char_color, enable_spellcheck=True)
+
+        # Use theme-aware tag color (light pink in dark mode, dark red in light mode)
+        is_dark = main_window and hasattr(main_window, 'theme_manager') and main_window.theme_manager and main_window.theme_manager.current_theme.name == "Dark"
+        tag_color = '#FFB6C1' if is_dark else self.tag_highlight_color  # Light pink in dark mode
+
+        self.highlighter = TagHighlighter(self.document(), tag_color, invisible_char_color, enable_spellcheck=True)
 
         # Style to look like a normal cell with subtle selection
         # Background and text colors now managed by theme system
@@ -2994,10 +3006,15 @@ class EditableGridTextEditor(QTextEdit):
         
         # Superlookup search action
         if self.textCursor().hasSelection():
-            superlookup_action = QAction("🔍 Search in Superlookup (Ctrl+K)", self)
+            superlookup_action = QAction("🔍 Search in SuperLookup (Ctrl+K)", self)
             superlookup_action.triggered.connect(self._handle_superlookup_search)
             menu.addAction(superlookup_action)
-            menu.addSeparator()
+
+        # MT Quick Lookup action
+        mt_lookup_action = QAction("⚡ QuickTrans (Ctrl+M)", self)
+        mt_lookup_action.triggered.connect(self._handle_mt_quick_lookup)
+        menu.addAction(mt_lookup_action)
+        menu.addSeparator()
 
         # QuickMenu (prompt-based actions)
         try:
@@ -3510,6 +3527,24 @@ class EditableGridTextEditor(QTextEdit):
                     "Non-translatables functionality not available."
                 )
 
+    def _handle_mt_quick_lookup(self):
+        """Handle right-click: Open MT Quick Lookup popup for selected text or full source"""
+        # Get selected text (if any) - prefer from target, then try source
+        selected_text = self.textCursor().selectedText().strip() if self.textCursor().hasSelection() else None
+
+        if not selected_text and self.table and self.row >= 0:
+            # Try getting selected text from source cell
+            source_widget = self.table.cellWidget(self.row, 2)
+            if source_widget and hasattr(source_widget, 'textCursor'):
+                cursor = source_widget.textCursor()
+                if cursor.hasSelection():
+                    selected_text = cursor.selectedText().strip()
+
+        # Find main window and call show_mt_quick_popup
+        main_window = self._get_main_window()
+        if main_window and hasattr(main_window, 'show_mt_quick_popup'):
+            main_window.show_mt_quick_popup(text_override=selected_text)
+
     def _insert_next_tag_or_wrap_selection(self):
         """
         Insert the next memoQ tag, HTML tag, or CafeTran pipe symbol from source, or wrap selection.
@@ -6224,6 +6259,12 @@ class SupervertalerQt(QMainWindow):
         self.termbase_cache_lock = threading.Lock()  # Thread-safe cache access
         self.termbase_batch_worker_thread = None  # Background worker thread
         self.termbase_batch_stop_event = threading.Event()  # Signal to stop background worker
+
+        # In-memory termbase index for instant lookups (v1.9.182)
+        # Loaded once on project load, contains ALL terms from activated termbases
+        # Structure: list of term dicts with pre-compiled regex patterns
+        self.termbase_index = []
+        self.termbase_index_lock = threading.Lock()
         
         # TM/MT/LLM prefetch cache for instant segment switching (like memoQ)
         # Maps segment ID → {"TM": [...], "MT": [...], "LLM": [...]}
@@ -6237,9 +6278,9 @@ class SupervertalerQt(QMainWindow):
         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
+        # Cache kill switch for performance testing
         # When True, all caches are bypassed - direct lookups every time
-        self.disable_all_caches = True
+        self.disable_all_caches = False  # v1.9.183: Default to False (caches ENABLED)
         
         # Undo/Redo stack for grid edits
         self.undo_stack = []  # List of (segment_id, old_target, new_target, old_status, new_status)
@@ -6367,7 +6408,13 @@ class SupervertalerQt(QMainWindow):
             self.termview_widget.theme_manager = self.theme_manager
             if hasattr(self.termview_widget, 'apply_theme'):
                 self.termview_widget.apply_theme()
-        
+
+        # Also update the Match Panel TermView (right panel)
+        if hasattr(self, 'termview_widget_match') and self.termview_widget_match:
+            self.termview_widget_match.theme_manager = self.theme_manager
+            if hasattr(self.termview_widget_match, 'apply_theme'):
+                self.termview_widget_match.apply_theme()
+
         if hasattr(self, 'translation_results_panel') and self.translation_results_panel:
             self.translation_results_panel.theme_manager = self.theme_manager
             # Also update class-level theme_manager for CompactMatchItem
@@ -6426,7 +6473,7 @@ class SupervertalerQt(QMainWindow):
         
         # Restore Termview under grid visibility state
         if hasattr(self, 'bottom_tabs'):
-            termview_visible = general_settings.get('termview_under_grid_visible', True)
+            termview_visible = general_settings.get('termview_under_grid_visible', False)
             self.bottom_tabs.setVisible(termview_visible)
             if hasattr(self, 'termview_visible_action'):
                 self.termview_visible_action.setChecked(termview_visible)
@@ -7274,7 +7321,12 @@ class SupervertalerQt(QMainWindow):
         
         # Alt+K - Open QuickMenu directly
         create_shortcut("editor_open_quickmenu", "Alt+K", self.open_quickmenu)
-    
+
+        # Ctrl+Shift+Q - MT Quick Lookup (GT4T-style popup)
+        mt_quick_shortcut = create_shortcut("mt_quick_lookup", "Ctrl+Shift+Q", self.show_mt_quick_popup)
+        # Use ApplicationShortcut context so it works even when focus is in QTextEdit widgets
+        mt_quick_shortcut.setContext(Qt.ShortcutContext.ApplicationShortcut)
+
     def focus_segment_notes(self):
         """Switch to Segment Note tab and focus the notes editor so user can start typing immediately"""
         if not hasattr(self, 'right_tabs'):
@@ -7346,7 +7398,105 @@ class SupervertalerQt(QMainWindow):
             
         except Exception as e:
             self.log(f"❌ Error opening QuickMenu: {e}")
-    
+
+    def show_mt_quick_popup(self, text_override: str = None):
+        """Show GT4T-style MT Quick Lookup popup with translations from all enabled MT engines.
+
+        Triggered by Ctrl+Shift+Q or right-click menu. Shows machine translation
+        suggestions from all configured and enabled MT providers in a popup window.
+
+        Args:
+            text_override: Optional text to translate. If None, uses selected text
+                          in the current cell, or falls back to the full source text.
+
+        Features:
+        - Displays source text at top
+        - Shows numbered list of MT suggestions from each provider
+        - Press 1-9 to quickly insert a translation
+        - Arrow keys to navigate, Enter to insert selected
+        - Escape to dismiss
+        """
+        try:
+            # Get current segment
+            current_row = self.table.currentRow()
+            if current_row < 0:
+                self.log("⚠️ No segment selected")
+                return
+
+            # Determine what text to translate
+            text_to_translate = text_override
+
+            if not text_to_translate:
+                # Check for selected text in the currently focused widget
+                focus_widget = QApplication.focusWidget()
+                if focus_widget and hasattr(focus_widget, 'textCursor'):
+                    cursor = focus_widget.textCursor()
+                    if cursor.hasSelection():
+                        text_to_translate = cursor.selectedText().strip()
+
+            if not text_to_translate:
+                # Fall back to full source text
+                source_widget = self.table.cellWidget(current_row, 2)
+                if not source_widget or not hasattr(source_widget, 'toPlainText'):
+                    self.log("⚠️ Could not get source text")
+                    return
+                text_to_translate = source_widget.toPlainText().strip()
+
+            if not text_to_translate:
+                self.log("⚠️ No text to translate")
+                return
+
+            # Import and create the popup
+            from modules.mt_quick_popup import MTQuickPopup
+
+            # Create popup
+            popup = MTQuickPopup(
+                parent_app=self,
+                source_text=text_to_translate,
+                source_lang=getattr(self, 'source_language', 'en'),
+                target_lang=getattr(self, 'target_language', 'nl'),
+                parent=self
+            )
+
+            # Connect signal to insert translation into target cell
+            def insert_translation(translation: str):
+                # Get the target widget
+                target_widget = self.table.cellWidget(current_row, 3)
+                if not target_widget or not hasattr(target_widget, 'toPlainText'):
+                    return
+
+                # Check if there was a selection in the target - replace just that
+                focus_widget = QApplication.focusWidget()
+                if focus_widget == target_widget and hasattr(focus_widget, 'textCursor'):
+                    cursor = focus_widget.textCursor()
+                    if cursor.hasSelection():
+                        # Replace selection only
+                        cursor.insertText(translation)
+                        self.log(f"✅ Replaced selection with MT translation")
+                    else:
+                        # No selection in target, replace entire target
+                        target_widget.setPlainText(translation)
+                        self.log(f"✅ Inserted MT translation")
+                else:
+                    # Focus was elsewhere, replace entire target
+                    target_widget.setPlainText(translation)
+                    self.log(f"✅ Inserted MT translation")
+
+                # Mark segment as modified
+                if hasattr(self, 'segments') and current_row < len(self.segments):
+                    self.segments[current_row].target = target_widget.toPlainText()
+                    self.mark_segment_modified(current_row)
+
+            popup.translation_selected.connect(insert_translation)
+
+            # Show the popup (it positions itself near cursor)
+            popup.show()
+
+        except ImportError as e:
+            self.log(f"❌ MT Quick Popup module not found: {e}")
+        except Exception as e:
+            self.log(f"❌ Error showing MT Quick Popup: {e}")
+
     def refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
         
@@ -7982,7 +8132,7 @@ class SupervertalerQt(QMainWindow):
         edit_menu.addSeparator()
         
         # Superlookup
-        superlookup_action = QAction("🔍 &Superlookup...", self)
+        superlookup_action = QAction("🔍 &SuperLookup...", self)
         superlookup_action.setShortcut("Ctrl+Alt+L")
         # Tab indices: Grid=0, Project resources=1, Tools=2, Settings=3
         superlookup_action.triggered.connect(lambda: self._go_to_superlookup() if hasattr(self, 'main_tabs') else None)  # Navigate to Superlookup
@@ -8020,7 +8170,7 @@ class SupervertalerQt(QMainWindow):
         grid_zoom_menu = view_menu.addMenu("📊 &Grid Text Zoom")
         
         grid_zoom_in = QAction("Grid Zoom &In", self)
-        grid_zoom_in.setShortcut(QKeySequence.StandardKey.ZoomIn)
+        grid_zoom_in.setShortcut("Ctrl+=")
         grid_zoom_in.triggered.connect(self.zoom_in)
         grid_zoom_menu.addAction(grid_zoom_in)
         
@@ -8089,7 +8239,7 @@ class SupervertalerQt(QMainWindow):
         # Termview visibility toggle
         self.termview_visible_action = QAction("🔍 &Termview Under Grid", self)
         self.termview_visible_action.setCheckable(True)
-        self.termview_visible_action.setChecked(True)  # Default: visible
+        self.termview_visible_action.setChecked(False)  # Default: hidden (restored from settings if enabled)
         self.termview_visible_action.triggered.connect(self.toggle_termview_under_grid)
         self.termview_visible_action.setToolTip("Show/hide the Termview panel under the grid")
         view_menu.addAction(self.termview_visible_action)
@@ -10129,7 +10279,7 @@ class SupervertalerQt(QMainWindow):
             
             # Create detached window
             self.lookup_detached_window = QDialog(self)
-            self.lookup_detached_window.setWindowTitle("🔍 Superlookup - Supervertaler")
+            self.lookup_detached_window.setWindowTitle("🔍 SuperLookup - Supervertaler")
             self.lookup_detached_window.setMinimumSize(600, 700)
             self.lookup_detached_window.resize(700, 800)
             
@@ -10183,7 +10333,7 @@ class SupervertalerQt(QMainWindow):
             # Header with reattach button
             header_layout = QVBoxLayout()
             
-            header_title = QLabel("🔍 Superlookup")
+            header_title = QLabel("🔍 SuperLookup")
             header_title.setStyleSheet("font-size: 16px; font-weight: bold; color: #333;")
             header_layout.addWidget(header_title)
             
@@ -10335,12 +10485,9 @@ class SupervertalerQt(QMainWindow):
 
         # Superdocs removed (online GitBook will be used instead)
 
-        print("[DEBUG] About to create SuperlookupTab...")
         lookup_tab = SuperlookupTab(self, user_data_path=self.user_data_path)
-        print("[DEBUG] SuperlookupTab created successfully")
         self.lookup_tab = lookup_tab  # Store reference for later use
-        modules_tabs.addTab(lookup_tab, "🔍 Superlookup")
-        print("[DEBUG] Superlookup tab added to modules_tabs")
+        modules_tabs.addTab(lookup_tab, "🔍 SuperLookup")
 
         # Supervoice - Voice Commands & Dictation
         supervoice_tab = self._create_voice_dictation_settings_tab()
@@ -12202,27 +12349,130 @@ class SupervertalerQt(QMainWindow):
                     f"Error testing segmentation:\n\n{e}"
                 )
     
-    def _update_both_termviews(self, source_text, termbase_list, nt_matches):
+    def _update_both_termviews(self, source_text, termbase_list, nt_matches, status_hint=None):
         """Update all three Termview instances with the same data.
-        
+
         Termview locations:
         1. Under grid (collapsible via View menu)
         2. Match Panel tab (top section)
+
+        Args:
+            source_text: The source text for the current segment
+            termbase_list: List of termbase match dictionaries
+            nt_matches: List of NT (Never Translate) matches
+            status_hint: Optional hint for display when no matches:
+                         'no_termbases_activated' - no glossaries activated for project
+                         'wrong_language' - activated glossaries don't match project language
         """
         # Update left Termview (under grid)
         if hasattr(self, 'termview_widget') and self.termview_widget:
             try:
-                self.termview_widget.update_with_matches(source_text, termbase_list, nt_matches)
+                self.termview_widget.update_with_matches(source_text, termbase_list, nt_matches, status_hint)
             except Exception as e:
                 self.log(f"Error updating left termview: {e}")
-        
+
         # Update Match Panel Termview
         if hasattr(self, 'termview_widget_match') and self.termview_widget_match:
             try:
-                self.termview_widget_match.update_with_matches(source_text, termbase_list, nt_matches)
+                self.termview_widget_match.update_with_matches(source_text, termbase_list, nt_matches, status_hint)
             except Exception as e:
                 self.log(f"Error updating Match Panel termview: {e}")
-    
+
+    def _update_termview_for_segment(self, segment):
+        """Explicitly update termview for a segment (v1.9.182).
+
+        This is called directly from Ctrl+Enter navigation to ensure
+        the termview updates immediately, bypassing the deferred timer approach.
+        """
+        if not segment or not hasattr(self, 'termview_widget'):
+            return
+
+        try:
+            # Use in-memory index for fast lookup
+            stored_matches = self.find_termbase_matches_in_source(segment.source)
+
+            # Convert dict format to list format for termview
+            termbase_matches = [
+                {
+                    'source_term': match_data.get('source', ''),
+                    'target_term': match_data.get('translation', ''),
+                    'termbase_name': match_data.get('termbase_name', ''),
+                    'ranking': match_data.get('ranking', 99),
+                    'is_project_termbase': match_data.get('is_project_termbase', False),
+                    'term_id': match_data.get('term_id'),
+                    'termbase_id': match_data.get('termbase_id'),
+                    'notes': match_data.get('notes', '')
+                }
+                for match_data in stored_matches.values()
+            ] if stored_matches else []
+
+            # Get NT matches
+            nt_matches = self.find_nt_matches_in_source(segment.source)
+
+            # Get status hint
+            status_hint = self._get_termbase_status_hint()
+
+            # Update both Termview widgets
+            self._update_both_termviews(segment.source, termbase_matches, nt_matches, status_hint)
+
+        except Exception as e:
+            self.log(f"Error in _update_termview_for_segment: {e}")
+
+    def _get_termbase_status_hint(self) -> str:
+        """Check termbase activation status and return appropriate hint.
+
+        Returns:
+            'no_termbases_activated' - if no glossaries are activated for this project
+            'wrong_language' - if activated glossaries don't match project language pair
+            None - if everything is correctly configured
+        """
+        if not self.current_project:
+            return None
+
+        project_id = self.current_project.id if hasattr(self.current_project, 'id') else None
+        if not project_id:
+            return None
+
+        # Check if termbase manager is available
+        if not hasattr(self, 'termbase_mgr') or not self.termbase_mgr:
+            return None
+
+        try:
+            # Get active termbase IDs for this project
+            active_tb_ids = self.termbase_mgr.get_active_termbase_ids(project_id)
+
+            # Check if no termbases are activated
+            if not active_tb_ids or len(active_tb_ids) == 0:
+                return 'no_termbases_activated'
+
+            # Check if any activated termbases match the project's language pair
+            project_source = (self.current_project.source_lang or '').lower()
+            project_target = (self.current_project.target_lang or '').lower()
+
+            # Get all termbases and check language pairs
+            all_termbases = self.termbase_mgr.get_all_termbases()
+            has_matching_language = False
+
+            for tb in all_termbases:
+                if tb['id'] in active_tb_ids:
+                    tb_source = (tb.get('source_lang') or '').lower()
+                    tb_target = (tb.get('target_lang') or '').lower()
+                    # Match if: no language set, or languages match (bidirectional)
+                    if (not tb_source and not tb_target) or \
+                       (tb_source == project_source and tb_target == project_target) or \
+                       (tb_source == project_target and tb_target == project_source):
+                        has_matching_language = True
+                        break
+
+            if not has_matching_language:
+                return 'wrong_language'
+
+            return None  # All good
+
+        except Exception as e:
+            self.log(f"Error checking termbase status: {e}")
+            return None
+
     def _refresh_termbase_display_for_current_segment(self):
         """Refresh only termbase/glossary display for the current segment.
         
@@ -12282,9 +12532,12 @@ class SupervertalerQt(QMainWindow):
                 
                 # Get NT matches
                 nt_matches = self.find_nt_matches_in_source(segment.source)
-                
+
+                # Get status hint for termbase activation
+                status_hint = self._get_termbase_status_hint()
+
                 # Update both Termview widgets (left and right)
-                self._update_both_termviews(segment.source, termbase_list, nt_matches)
+                self._update_both_termviews(segment.source, termbase_list, nt_matches, status_hint)
             except Exception as e:
                 self.log(f"Error updating termview: {e}")
         
@@ -12752,6 +13005,39 @@ class SupervertalerQt(QMainWindow):
                                     # Use term_id as key to avoid duplicates
                                     self.termbase_cache[segment_id][term_id] = new_match
                                     self.log(f"⚡ Added term directly to cache (instant update)")
+
+                                # v1.9.182: Also add to in-memory termbase index for future lookups
+                                import re
+                                source_lower = source_text.lower().strip()
+                                try:
+                                    if any(c in source_lower for c in '.%,/-'):
+                                        pattern = re.compile(r'(?<!\w)' + re.escape(source_lower) + r'(?!\w)')
+                                    else:
+                                        pattern = re.compile(r'\b' + re.escape(source_lower) + r'\b')
+                                except re.error:
+                                    pattern = None
+
+                                index_entry = {
+                                    'term_id': term_id,
+                                    'source_term': source_text,
+                                    'source_term_lower': source_lower,
+                                    'target_term': target_text,
+                                    'termbase_id': target_termbase['id'],
+                                    'priority': 99,
+                                    'domain': '',
+                                    'notes': '',
+                                    'project': '',
+                                    'client': '',
+                                    'forbidden': False,
+                                    'is_project_termbase': False,
+                                    'termbase_name': target_termbase['name'],
+                                    'ranking': glossary_rank,
+                                    'pattern': pattern,
+                                }
+                                with self.termbase_index_lock:
+                                    self.termbase_index.append(index_entry)
+                                    # Re-sort by length (longest first) for proper phrase matching
+                                    self.termbase_index.sort(key=lambda x: len(x['source_term_lower']), reverse=True)
                                 
                                 # Update TermView widget with the new term
                                 if hasattr(self, 'termview_widget') and self.termview_widget:
@@ -12776,9 +13062,12 @@ class SupervertalerQt(QMainWindow):
                                     
                                     # Get NT matches
                                     nt_matches = self.find_nt_matches_in_source(segment.source)
-                                    
+
+                                    # Get status hint (although after adding a term, it should be fine)
+                                    status_hint = self._get_termbase_status_hint()
+
                                     # Update both Termview widgets (left and right)
-                                    self._update_both_termviews(segment.source, termbase_list, nt_matches)
+                                    self._update_both_termviews(segment.source, termbase_list, nt_matches, status_hint)
                                     self.log(f"✅ Both TermView widgets updated instantly with new term")
                                 
                                 # Update source cell highlighting with updated cache
@@ -13634,15 +13923,16 @@ class SupervertalerQt(QMainWindow):
                     # Use 0 (global) when no project is loaded - allows Superlookup to work
                     curr_proj = self.current_project if hasattr(self, 'current_project') else None
                     curr_proj_id = curr_proj.id if (curr_proj and hasattr(curr_proj, 'id')) else 0  # 0 = global
-                    
+
                     if checked:
                         termbase_mgr.activate_termbase(tb_id, curr_proj_id)
                     else:
                         termbase_mgr.deactivate_termbase(tb_id, curr_proj_id)
-                    
-                    # Clear cache and refresh
+
+                    # Clear cache and rebuild in-memory index (v1.9.182)
                     with self.termbase_cache_lock:
                         self.termbase_cache.clear()
+                    self._build_termbase_index()  # Rebuild index with new activation state
                     refresh_termbase_list()
                 
                 read_checkbox.toggled.connect(on_read_toggle)
@@ -14846,7 +15136,7 @@ class SupervertalerQt(QMainWindow):
         
         # Delete selected term button
         delete_term_btn = QPushButton("🗑️ Delete Selected Term")
-        delete_term_btn.setStyleSheet("background-color: #f44336; color: white; font-weight: bold;")
+        delete_term_btn.setStyleSheet("background-color: #f44336; color: white; font-weight: bold; padding: 3px 5px;")
         def delete_selected_term():
             selected_row = terms_table.currentRow()
             if selected_row < 0:
@@ -15520,8 +15810,13 @@ class SupervertalerQt(QMainWindow):
         # ===== TAB 4: MT Settings =====
         mt_tab = self._create_mt_settings_tab()
         settings_tabs.addTab(scroll_area_wrapper(mt_tab), "🌐 MT Settings")
-        
-        # ===== TAB 5: View Settings =====
+
+        # ===== TAB 5: MT Quick Lookup Settings =====
+        mt_quick_tab = self._create_mt_quick_lookup_settings_tab()
+        settings_tabs.addTab(scroll_area_wrapper(mt_quick_tab), "⚡ QuickTrans")
+        self.mt_quick_lookup_tab_index = settings_tabs.count() - 1  # Store index for opening
+
+        # ===== TAB 6: View Settings =====
         view_tab = self._create_view_settings_tab()
         settings_tabs.addTab(scroll_area_wrapper(view_tab), "🔍 View Settings")
 
@@ -16329,9 +16624,199 @@ class SupervertalerQt(QMainWindow):
         layout.addWidget(save_btn)
         
         layout.addStretch()
-        
+
         return tab
-    
+
+    def _create_mt_quick_lookup_settings_tab(self):
+        """Create MT Quick Lookup settings tab content"""
+        from PyQt6.QtWidgets import QCheckBox, QGroupBox, QPushButton, QComboBox
+
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        layout.setContentsMargins(20, 20, 20, 20)
+        layout.setSpacing(15)
+
+        # Load current settings
+        general_settings = self.load_general_settings()
+        mt_quick_settings = general_settings.get('mt_quick_lookup', {})
+        api_keys = self.load_api_keys()
+        enabled_providers = self.load_provider_enabled_states()
+
+        # Header info
+        header_info = QLabel(
+            "⚡ <b>QuickTrans</b> - Configure which providers appear in the QuickTrans popup (Ctrl+M / Ctrl+Alt+M).<br>"
+            "Enable MT engines and/or LLMs to get instant translation suggestions."
+        )
+        header_info.setTextFormat(Qt.TextFormat.RichText)
+        header_info.setStyleSheet("font-size: 9pt; color: #444; padding: 10px; background-color: #E3F2FD; border-radius: 4px;")
+        header_info.setWordWrap(True)
+        layout.addWidget(header_info)
+
+        # ===== MT Providers Group =====
+        mt_group = QGroupBox("🌐 Machine Translation Providers")
+        mt_layout = QVBoxLayout()
+
+        mt_info = QLabel("Select which MT engines to query. Only enabled providers with valid API keys are shown.")
+        mt_info.setWordWrap(True)
+        mt_info.setStyleSheet("font-size: 8pt; color: #666; padding-bottom: 8px;")
+        mt_layout.addWidget(mt_info)
+
+        # MT provider checkboxes
+        self._mtql_checkboxes = {}
+
+        mt_providers = [
+            ("gt", "Google Translate", "mt_google_translate", "google_translate"),
+            ("dl", "DeepL", "mt_deepl", "deepl"),
+            ("ms", "Microsoft Translator", "mt_microsoft", "microsoft_translate"),
+            ("at", "Amazon Translate", "mt_amazon", "amazon_translate"),
+            ("mmt", "ModernMT", "mt_modernmt", "modernmt"),
+            ("mm", "MyMemory (Free)", "mt_mymemory", None),
+        ]
+
+        for code, name, enabled_key, api_key_name in mt_providers:
+            # Check if provider is available (has API key or doesn't need one)
+            has_key = api_key_name is None or bool(api_keys.get(api_key_name))
+            is_enabled_globally = enabled_providers.get(enabled_key, True)
+
+            checkbox = CheckmarkCheckBox(name)
+            # Default: use global MT enabled state
+            checkbox.setChecked(mt_quick_settings.get(f"mtql_{code}", is_enabled_globally and has_key))
+            checkbox.setEnabled(has_key)
+
+            if not has_key:
+                checkbox.setToolTip(f"API key not configured for {name}")
+                checkbox.setStyleSheet("color: #999;")
+            else:
+                checkbox.setToolTip(f"Include {name} in QuickTrans results")
+
+            self._mtql_checkboxes[f"mtql_{code}"] = checkbox
+            mt_layout.addWidget(checkbox)
+
+        mt_group.setLayout(mt_layout)
+        layout.addWidget(mt_group)
+
+        # ===== LLM Providers Group =====
+        llm_group = QGroupBox("🤖 AI/LLM Providers")
+        llm_layout = QVBoxLayout()
+
+        llm_info = QLabel(
+            "Enable AI models for translation suggestions. LLMs may provide more context-aware translations but are slower.<br>"
+            "<b>Note:</b> LLM calls cost more than MT APIs. Use sparingly for quick lookups."
+        )
+        llm_info.setTextFormat(Qt.TextFormat.RichText)
+        llm_info.setWordWrap(True)
+        llm_info.setStyleSheet("font-size: 8pt; color: #666; padding-bottom: 8px;")
+        llm_layout.addWidget(llm_info)
+
+        # LLM provider checkboxes with model selection
+        self._mtql_llm_combos = {}
+
+        llm_providers = [
+            ("claude", "Claude", "claude", [
+                ("claude-sonnet-4-5-20250929", "Claude Sonnet 4.5 (Recommended)"),
+                ("claude-haiku-4-5-20251001", "Claude Haiku 4.5 (Fast)"),
+                ("claude-opus-4-1-20250924", "Claude Opus 4.1 (Premium)"),
+            ]),
+            ("openai", "OpenAI", "openai", [
+                ("gpt-4o", "GPT-4o (Recommended)"),
+                ("gpt-4o-mini", "GPT-4o Mini (Fast)"),
+                ("gpt-4-turbo", "GPT-4 Turbo"),
+                ("o1", "o1 (Reasoning)"),
+            ]),
+            ("gemini", "Gemini", "gemini", [
+                ("gemini-2.5-flash", "Gemini 2.5 Flash (Recommended)"),
+                ("gemini-2.5-pro", "Gemini 2.5 Pro"),
+                ("gemini-2.0-flash", "Gemini 2.0 Flash"),
+            ]),
+        ]
+
+        for code, name, api_key_name, models in llm_providers:
+            has_key = bool(api_keys.get(api_key_name))
+
+            # Container for checkbox and model combo
+            llm_row = QHBoxLayout()
+
+            checkbox = CheckmarkCheckBox(name)
+            # Default: disabled (LLMs are opt-in)
+            checkbox.setChecked(mt_quick_settings.get(f"mtql_{code}", False))
+            checkbox.setEnabled(has_key)
+
+            if not has_key:
+                checkbox.setToolTip(f"API key not configured for {name}. Add it in AI Settings.")
+                checkbox.setStyleSheet("color: #999;")
+            else:
+                checkbox.setToolTip(f"Include {name} translations in QuickTrans")
+
+            self._mtql_checkboxes[f"mtql_{code}"] = checkbox
+            llm_row.addWidget(checkbox)
+
+            # Model selection combo
+            model_combo = QComboBox()
+            model_combo.setMinimumWidth(200)
+            for model_id, model_name in models:
+                model_combo.addItem(model_name, model_id)
+
+            # Restore saved model selection
+            saved_model = mt_quick_settings.get(f"mtql_{code}_model")
+            if saved_model:
+                idx = model_combo.findData(saved_model)
+                if idx >= 0:
+                    model_combo.setCurrentIndex(idx)
+
+            model_combo.setEnabled(has_key)
+            self._mtql_llm_combos[f"mtql_{code}_model"] = model_combo
+            llm_row.addWidget(model_combo)
+
+            llm_row.addStretch()
+            llm_layout.addLayout(llm_row)
+
+        llm_group.setLayout(llm_layout)
+        layout.addWidget(llm_group)
+
+        # Save button
+        save_btn = QPushButton("💾 Save QuickTrans Settings")
+        save_btn.setStyleSheet("font-weight: bold; padding: 8px;")
+        save_btn.clicked.connect(self._save_mt_quick_lookup_settings)
+        layout.addWidget(save_btn)
+
+        layout.addStretch()
+
+        return tab
+
+    def _save_mt_quick_lookup_settings(self):
+        """Save MT Quick Lookup settings"""
+        general_settings = self.load_general_settings()
+
+        mt_quick_settings = {}
+
+        # Save MT provider states
+        for key, checkbox in self._mtql_checkboxes.items():
+            mt_quick_settings[key] = checkbox.isChecked()
+
+        # Save LLM model selections
+        for key, combo in self._mtql_llm_combos.items():
+            mt_quick_settings[key] = combo.currentData()
+
+        general_settings['mt_quick_lookup'] = mt_quick_settings
+        self.save_general_settings(general_settings)
+
+        self.log("✓ QuickTrans settings saved")
+        QMessageBox.information(self, "Settings Saved", "QuickTrans settings have been saved.")
+
+    def open_mt_quick_lookup_settings(self):
+        """Open Settings and navigate to MT Quick Lookup tab"""
+        # Switch to Settings tab
+        if hasattr(self, 'main_tabs'):
+            # Find Settings tab index
+            for i in range(self.main_tabs.count()):
+                if "Settings" in self.main_tabs.tabText(i):
+                    self.main_tabs.setCurrentIndex(i)
+                    break
+
+            # Navigate to MT Quick Lookup sub-tab
+            if hasattr(self, 'settings_tabs') and hasattr(self, 'mt_quick_lookup_tab_index'):
+                self.settings_tabs.setCurrentIndex(self.mt_quick_lookup_tab_index)
+
     def _find_autohotkey_for_settings(self):
         """Find AutoHotkey executable for settings display (doesn't modify state)"""
         # Standard installation paths
@@ -16971,7 +17456,7 @@ class SupervertalerQt(QMainWindow):
         
         # Cache kill switch
         disable_cache_cb = CheckmarkCheckBox("Disable ALL caches (direct lookups every time)")
-        disable_cache_cb.setChecked(general_settings.get('disable_all_caches', True))
+        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"
@@ -18338,7 +18823,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #2E7D32;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -18352,7 +18837,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #C62828;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -18366,7 +18851,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #F57C00;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -18381,7 +18866,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #757575;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -19615,7 +20100,7 @@ class SupervertalerQt(QMainWindow):
             '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),
-            'disable_all_caches': disable_cache_cb.isChecked() if disable_cache_cb is not None else existing_settings.get('disable_all_caches', True)
+            '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
@@ -19715,6 +20200,27 @@ class SupervertalerQt(QMainWindow):
                                      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):
         """Save view settings from UI"""
+        # CRITICAL: Suppress TM saves during view settings update
+        # Grid operations (setStyleSheet, rehighlight, etc.) can trigger textChanged events
+        # which would cause mass TM saves for all confirmed segments
+        previous_suppression = getattr(self, '_suppress_target_change_handlers', False)
+        self._suppress_target_change_handlers = True
+
+        try:
+            self._save_view_settings_from_ui_impl(
+                grid_spin, match_spin, compare_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
+            )
+        finally:
+            self._suppress_target_change_handlers = previous_suppression
+
+    def _save_view_settings_from_ui_impl(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):
+        """Implementation of save view settings (called with TM saves suppressed)"""
         general_settings = {
             'restore_last_project': self.load_general_settings().get('restore_last_project', False),
             'auto_propagate_exact_matches': self.auto_propagate_exact_matches,  # Keep existing value
@@ -19885,8 +20391,10 @@ class SupervertalerQt(QMainWindow):
         if invisible_char_color_btn and hasattr(self, 'table') and self.table is not None:
             invisible_char_color = invisible_char_color_btn.property('selected_color')
             if invisible_char_color:
-                # Update all cell highlighters
+                # Update all cell highlighters (with processEvents to keep UI responsive)
                 for row in range(self.table.rowCount()):
+                    if row % 50 == 0:
+                        QApplication.processEvents()
                     for col in [2, 3]:  # Source and target columns
                         widget = self.table.cellWidget(row, col)
                         if widget and hasattr(widget, 'highlighter'):
@@ -19898,8 +20406,10 @@ class SupervertalerQt(QMainWindow):
             border_color = EditableGridTextEditor.focus_border_color
             border_thickness = EditableGridTextEditor.focus_border_thickness
             self.log(f"Applying focus border: color={border_color}, thickness={border_thickness}px")
-            
+
             for row in range(self.table.rowCount()):
+                if row % 50 == 0:
+                    QApplication.processEvents()
                 widget = self.table.cellWidget(row, 3)  # Target column
                 if widget and isinstance(widget, EditableGridTextEditor):
                     # Update the stylesheet with new border settings
@@ -20005,7 +20515,7 @@ class SupervertalerQt(QMainWindow):
         filter_layout.setSpacing(10)
         
         # Source filter
-        source_filter_label = QLabel("Filter Source:")
+        source_filter_label = QLabel("Source:")
         self.source_filter = self._ensure_shared_filter(
             'source_filter',
             "Type to filter source segments...",
@@ -20014,7 +20524,7 @@ class SupervertalerQt(QMainWindow):
         )
         
         # Target filter
-        target_filter_label = QLabel("Filter Target:")
+        target_filter_label = QLabel("Target:")
         self.target_filter = self._ensure_shared_filter(
             'target_filter',
             "Type to filter target segments...",
@@ -20026,11 +20536,12 @@ class SupervertalerQt(QMainWindow):
         clear_filters_btn = QPushButton("Clear Filters")
         clear_filters_btn.clicked.connect(self.clear_filters)
         clear_filters_btn.setMaximumWidth(100)
+        clear_filters_btn.setStyleSheet("padding: 3px 5px;")
 
         # Show Invisibles button with dropdown menu
         show_invisibles_btn = QPushButton("¶ Show Invisibles")
         show_invisibles_btn.setMaximumWidth(140)
-        show_invisibles_btn.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold;")
+        show_invisibles_btn.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold; padding: 3px 5px;")
         show_invisibles_menu = QMenu(show_invisibles_btn)
 
         # Create checkable actions for each invisible character type
@@ -20155,7 +20666,7 @@ class SupervertalerQt(QMainWindow):
         filter_layout.setSpacing(10)
         
         # Source filter
-        source_filter_label = QLabel("Filter Source:")
+        source_filter_label = QLabel("Source:")
         self.source_filter = self._ensure_shared_filter(
             'source_filter',
             "Type to filter source segments... (Press Enter or click Filter)",
@@ -20163,7 +20674,7 @@ class SupervertalerQt(QMainWindow):
         )
         
         # Target filter
-        target_filter_label = QLabel("Filter Target:")
+        target_filter_label = QLabel("Target:")
         self.target_filter = self._ensure_shared_filter(
             'target_filter',
             "Type to filter target segments... (Press Enter or click Filter)",
@@ -20174,17 +20685,18 @@ class SupervertalerQt(QMainWindow):
         apply_filter_btn = QPushButton("Filter")
         apply_filter_btn.clicked.connect(self.apply_filters)
         apply_filter_btn.setMaximumWidth(80)
-        apply_filter_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
+        apply_filter_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px;")
         
         # Clear filters button
         clear_filters_btn = QPushButton("Clear Filters")
         clear_filters_btn.clicked.connect(self.clear_filters)
         clear_filters_btn.setMaximumWidth(100)
+        clear_filters_btn.setStyleSheet("padding: 3px 5px;")
         
         # Quick Filters dropdown menu
         quick_filter_btn = QPushButton("⚡ Quick Filters")
         quick_filter_btn.setMaximumWidth(130)
-        quick_filter_btn.setStyleSheet("background-color: #D84315; color: white; font-weight: bold;")
+        quick_filter_btn.setStyleSheet("background-color: #D84315; color: white; font-weight: bold; padding: 3px 5px;")
         quick_filter_menu = QMenu(self)
         quick_filter_menu.addAction("🔍 Empty segments", lambda: self.apply_quick_filter("empty"))
         quick_filter_menu.addAction("❌ Not translated", lambda: self.apply_quick_filter("not_translated"))
@@ -20198,8 +20710,69 @@ class SupervertalerQt(QMainWindow):
         advanced_filter_btn = QPushButton("⚙️ Advanced Filters")
         advanced_filter_btn.clicked.connect(self.show_advanced_filters_dialog)
         advanced_filter_btn.setMaximumWidth(160)
-        advanced_filter_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold;")
-        
+        advanced_filter_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 3px 5px;")
+
+        # Sort dropdown button (similar to memoQ)
+        sort_btn = QPushButton("⇅ Sort")
+        sort_btn.setMaximumWidth(100)
+        sort_btn.setStyleSheet("background-color: #FF9800; color: white; font-weight: bold; padding: 3px 5px;")
+        sort_menu = QMenu(self)
+
+        # Initialize sort state if not exists
+        if not hasattr(self, 'current_sort'):
+            self.current_sort = None  # None = document order
+
+        # Sort by source text
+        sort_menu.addAction("📝 Source A → Z", lambda: self.apply_sort('source_asc'))
+        sort_menu.addAction("📝 Source Z → A", lambda: self.apply_sort('source_desc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by target text
+        sort_menu.addAction("📄 Target A → Z", lambda: self.apply_sort('target_asc'))
+        sort_menu.addAction("📄 Target Z → A", lambda: self.apply_sort('target_desc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by text length
+        sort_menu.addAction("📏 Source (longer first)", lambda: self.apply_sort('source_length_desc'))
+        sort_menu.addAction("📏 Source (shorter first)", lambda: self.apply_sort('source_length_asc'))
+        sort_menu.addAction("📏 Target (longer first)", lambda: self.apply_sort('target_length_desc'))
+        sort_menu.addAction("📏 Target (shorter first)", lambda: self.apply_sort('target_length_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by match rate
+        sort_menu.addAction("🎯 Match Rate (higher first)", lambda: self.apply_sort('match_desc'))
+        sort_menu.addAction("🎯 Match Rate (lower first)", lambda: self.apply_sort('match_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by frequency
+        sort_menu.addAction("📊 Source Frequency (higher first)", lambda: self.apply_sort('source_freq_desc'))
+        sort_menu.addAction("📊 Source Frequency (lower first)", lambda: self.apply_sort('source_freq_asc'))
+        sort_menu.addAction("📊 Target Frequency (higher first)", lambda: self.apply_sort('target_freq_desc'))
+        sort_menu.addAction("📊 Target Frequency (lower first)", lambda: self.apply_sort('target_freq_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by last changed
+        sort_menu.addAction("🕒 Last Changed (newest first)", lambda: self.apply_sort('modified_desc'))
+        sort_menu.addAction("🕒 Last Changed (oldest first)", lambda: self.apply_sort('modified_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by row status
+        sort_menu.addAction("🚦 Row Status", lambda: self.apply_sort('status'))
+
+        sort_menu.addSeparator()
+
+        # Reset to document order
+        sort_menu.addAction("↩️ Document Order (default)", lambda: self.apply_sort(None))
+
+        sort_btn.setMenu(sort_menu)
+        sort_btn.setToolTip("Sort segments by various criteria")
+
         # File filter dropdown (for multi-file projects)
         self.file_filter_combo = QComboBox()
         self.file_filter_combo.setMinimumWidth(150)
@@ -20212,7 +20785,7 @@ class SupervertalerQt(QMainWindow):
         # Show Invisibles button with dropdown menu
         show_invisibles_btn_home = QPushButton("¶ Show Invisibles")
         show_invisibles_btn_home.setMaximumWidth(140)
-        show_invisibles_btn_home.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold;")
+        show_invisibles_btn_home.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold; padding: 3px 5px;")
         show_invisibles_menu_home = QMenu(show_invisibles_btn_home)
 
         # Use the same actions (they're stored as instance variables)
@@ -20293,6 +20866,7 @@ class SupervertalerQt(QMainWindow):
         filter_layout.addWidget(clear_filters_btn)
         filter_layout.addWidget(quick_filter_btn)
         filter_layout.addWidget(advanced_filter_btn)
+        filter_layout.addWidget(sort_btn)  # Sort dropdown
         filter_layout.addWidget(self.file_filter_combo)  # File filter for multi-file projects
         filter_layout.addWidget(show_invisibles_btn_home)
         filter_layout.addWidget(self.spellcheck_btn)
@@ -20416,30 +20990,80 @@ class SupervertalerQt(QMainWindow):
         tab_seg_info.setStyleSheet("font-weight: bold;")
         toolbar_layout.addWidget(tab_seg_info)
         
-        # Tag View toggle button
-        tag_view_btn = QPushButton("🏷️ Tags OFF")
-        tag_view_btn.setCheckable(True)
-        tag_view_btn.setChecked(False)  # Default: WYSIWYG mode (tags hidden)
-        tag_view_btn.setStyleSheet("""
+        # View mode segmented control (WYSIWYG / Tags)
+        from PyQt6.QtWidgets import QButtonGroup
+
+        view_mode_container = QWidget()
+        view_mode_layout = QHBoxLayout(view_mode_container)
+        view_mode_layout.setContentsMargins(0, 0, 0, 0)
+        view_mode_layout.setSpacing(0)
+
+        # Create button group to ensure only one is checked
+        view_mode_group = QButtonGroup(self)
+        view_mode_group.setExclusive(True)
+
+        # WYSIWYG button (left)
+        wysiwyg_btn = QPushButton("WYSIWYG")
+        wysiwyg_btn.setCheckable(True)
+        wysiwyg_btn.setChecked(False)
+        wysiwyg_btn.setToolTip("WYSIWYG View (Ctrl+Alt+T)\nShows formatted text without raw tags")
+        wysiwyg_btn.setStyleSheet("""
             QPushButton {
                 background-color: #757575;
                 color: white;
                 font-weight: bold;
-                padding: 4px 8px;
-                border-radius: 3px;
+                padding: 4px 12px;
+                border: none;
+                border-top-left-radius: 3px;
+                border-bottom-left-radius: 3px;
             }
             QPushButton:checked {
                 background-color: #9C27B0;
             }
+            QPushButton:hover:!checked {
+                background-color: #858585;
+            }
         """)
-        tag_view_btn.setToolTip("Toggle Tag View (Ctrl+Alt+T)\n\nTags OFF: Shows formatted text (WYSIWYG)\nTags ON: Shows raw tags like <b>bold</b>")
-        tag_view_btn.clicked.connect(lambda checked: self.toggle_tag_view(checked, tag_view_btn))
-        toolbar_layout.addWidget(tag_view_btn)
-        self.tag_view_btn = tag_view_btn  # Store reference
+        wysiwyg_btn.clicked.connect(lambda: self.toggle_tag_view(False, None))
+        view_mode_group.addButton(wysiwyg_btn, 0)
+        view_mode_layout.addWidget(wysiwyg_btn)
+
+        # Tags button (right)
+        tags_btn = QPushButton("Tags")
+        tags_btn.setCheckable(True)
+        tags_btn.setChecked(True)  # Default: Tags mode
+        tags_btn.setToolTip("Tag View (Ctrl+Alt+T)\nShows raw tags like <b>bold</b>")
+        tags_btn.setStyleSheet("""
+            QPushButton {
+                background-color: #757575;
+                color: white;
+                font-weight: bold;
+                padding: 4px 12px;
+                border: none;
+                border-top-right-radius: 3px;
+                border-bottom-right-radius: 3px;
+            }
+            QPushButton:checked {
+                background-color: #9C27B0;
+            }
+            QPushButton:hover:!checked {
+                background-color: #858585;
+            }
+        """)
+        tags_btn.clicked.connect(lambda: self.toggle_tag_view(True, None))
+        view_mode_group.addButton(tags_btn, 1)
+        view_mode_layout.addWidget(tags_btn)
+
+        toolbar_layout.addWidget(view_mode_container)
+
+        # Store references for keyboard shortcut and programmatic access
+        self.wysiwyg_btn = wysiwyg_btn
+        self.tags_btn = tags_btn
+        self.view_mode_group = view_mode_group
         
         # Initialize tag view state
         if not hasattr(self, 'show_tags'):
-            self.show_tags = False
+            self.show_tags = True  # Default: show tags
         
         # Status selector
         from modules.statuses import get_status, STATUSES
@@ -20457,12 +21081,12 @@ class SupervertalerQt(QMainWindow):
         
         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;")
+        preview_prompt_btn.setStyleSheet("background-color: #9C27B0; color: white; font-weight: bold; padding: 3px 5px; border: none; outline: none;")
         preview_prompt_btn.clicked.connect(self._preview_combined_prompt_from_grid)
         toolbar_layout.addWidget(preview_prompt_btn)
         
         dictate_btn = QPushButton("🎤 Dictation")
-        dictate_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
+        dictate_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px; border: none; outline: none;")
         dictate_btn.clicked.connect(self.start_voice_dictation)
         dictate_btn.setToolTip("Start/stop voice dictation (F9)")
         toolbar_layout.addWidget(dictate_btn)
@@ -20476,7 +21100,7 @@ class SupervertalerQt(QMainWindow):
                 background-color: #757575;
                 color: white;
                 font-weight: bold;
-                padding: 4px 8px;
+                padding: 3px 5px;
                 border-radius: 3px;
             }
             QPushButton:checked {
@@ -20491,7 +21115,7 @@ class SupervertalerQt(QMainWindow):
         toolbar_layout.addStretch()
         
         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.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 3px 5px; border: none; outline: none;")
         save_next_btn.clicked.connect(self.confirm_selected_or_next)
         save_next_btn.setToolTip("Confirm current segment and go to next unconfirmed (Ctrl+Enter)")
         toolbar_layout.addWidget(save_next_btn)
@@ -21100,9 +21724,21 @@ class SupervertalerQt(QMainWindow):
         # Configure columns
         self.table.setColumnCount(5)
         self.table.setHorizontalHeaderLabels(["#", "Type", "Source", "Target", "Status"])
-        
-        # Column widths - Source and Target columns stretch to fill space, others are interactive
+
+        # Explicitly set header font to normal weight (not bold)
         header = self.table.horizontalHeader()
+        header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Normal)
+        header.setFont(header_font)
+
+        # Also set font on individual header items through the model (extra insurance)
+        model = self.table.model()
+        if model:
+            for col in range(5):
+                item = model.headerData(col, Qt.Orientation.Horizontal, Qt.ItemDataRole.DisplayRole)
+                model.setHeaderData(col, Qt.Orientation.Horizontal, item, Qt.ItemDataRole.DisplayRole)
+                model.setHeaderData(col, Qt.Orientation.Horizontal, header_font, Qt.ItemDataRole.FontRole)
+
+        # Column widths - Source and Target columns stretch to fill space, others are interactive
         header.setSectionResizeMode(0, QHeaderView.ResizeMode.Interactive)  # ID
         header.setSectionResizeMode(1, QHeaderView.ResizeMode.Interactive)  # Type
         header.setSectionResizeMode(2, QHeaderView.ResizeMode.Stretch)  # Source - stretch to fill space
@@ -21116,7 +21752,7 @@ class SupervertalerQt(QMainWindow):
         self.table.setColumnWidth(1, 40)   # Type - narrower
         self.table.setColumnWidth(2, 400)  # Source
         self.table.setColumnWidth(3, 400)  # Target
-        self.table.setColumnWidth(4, 60)   # Status - compact
+        self.table.setColumnWidth(4, 50)   # Status - compact width
         
         # Enable word wrap in cells (both display and edit mode)
         self.table.setWordWrap(True)
@@ -21146,6 +21782,51 @@ class SupervertalerQt(QMainWindow):
             QTableWidget::item:last-child {
                 border-right: none;
             }
+
+            /* Narrower scrollbar with visible arrow buttons */
+            QScrollBar:vertical {
+                border: none;
+                background: #F0F0F0;
+                width: 12px;
+                margin: 12px 0 12px 0;
+            }
+            QScrollBar::handle:vertical {
+                background: #C0C0C0;
+                min-height: 20px;
+                border-radius: 2px;
+            }
+            QScrollBar::handle:vertical:hover {
+                background: #A0A0A0;
+            }
+            QScrollBar::add-line:vertical {
+                height: 12px;
+                background: #E0E0E0;
+                subcontrol-position: bottom;
+                subcontrol-origin: margin;
+            }
+            QScrollBar::add-line:vertical:hover {
+                background: #2196F3;
+            }
+            QScrollBar::sub-line:vertical {
+                height: 12px;
+                background: #E0E0E0;
+                subcontrol-position: top;
+                subcontrol-origin: margin;
+            }
+            QScrollBar::sub-line:vertical:hover {
+                background: #2196F3;
+            }
+            /* Arrow images */
+            QScrollBar::up-arrow:vertical {
+                image: url(assets/scrollbar_up.png);
+                width: 8px;
+                height: 8px;
+            }
+            QScrollBar::down-arrow:vertical {
+                image: url(assets/scrollbar_down.png);
+                width: 8px;
+                height: 8px;
+            }
         """)
         
         # Simplified editing: Double-click only (no F2 key) - companion tool philosophy
@@ -21168,8 +21849,8 @@ class SupervertalerQt(QMainWindow):
         # Debug: Confirm signal connections
         self.log("🔌 Table signals connected: currentCellChanged, itemClicked, cellDoubleClicked, itemSelectionChanged")
         
-        # Add precision scroll buttons (memoQ-style)
-        self.add_precision_scroll_buttons()
+        # Precision scroll buttons removed (user preference)
+        # self.add_precision_scroll_buttons()
     
     def add_precision_scroll_buttons(self):
         """Add precision scroll buttons at top/bottom of scrollbar (memoQ-style)"""
@@ -21395,10 +22076,10 @@ class SupervertalerQt(QMainWindow):
         editor_widget.dictate_btn = dictate_btn
 
         save_btn = QPushButton("💾 Save")
-        save_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
+        save_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px;")
         save_btn.clicked.connect(self.save_tab_segment)
         save_next_btn = QPushButton("✓ Confirm && Next (Ctrl+Enter)")
-        save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold;")
+        save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 3px 5px;")
         save_next_btn.clicked.connect(self.confirm_selected_or_next)
 
         button_layout.addWidget(copy_btn)
@@ -21558,36 +22239,35 @@ class SupervertalerQt(QMainWindow):
         
         # Source language
         source_lang_combo = QComboBox()
-        common_langs = [
-            ("English", "en"),
-            ("Dutch", "nl"),
-            ("German", "de"),
-            ("French", "fr"),
-            ("Spanish", "es"),
-            ("Italian", "it"),
-            ("Portuguese", "pt"),
-            ("Russian", "ru"),
-            ("Chinese", "zh"),
-            ("Japanese", "ja"),
+        # Full language list matching Settings → Language Pair (with ISO 639-1 codes)
+        available_langs = [
+            ("Afrikaans", "af"), ("Albanian", "sq"), ("Arabic", "ar"), ("Armenian", "hy"),
+            ("Basque", "eu"), ("Bengali", "bn"), ("Bulgarian", "bg"), ("Catalan", "ca"),
+            ("Chinese (Simplified)", "zh-CN"), ("Chinese (Traditional)", "zh-TW"),
+            ("Croatian", "hr"), ("Czech", "cs"), ("Danish", "da"), ("Dutch", "nl"),
+            ("English", "en"), ("Estonian", "et"), ("Finnish", "fi"), ("French", "fr"),
+            ("Galician", "gl"), ("Georgian", "ka"), ("German", "de"), ("Greek", "el"),
+            ("Hebrew", "he"), ("Hindi", "hi"), ("Hungarian", "hu"), ("Icelandic", "is"),
+            ("Indonesian", "id"), ("Irish", "ga"), ("Italian", "it"), ("Japanese", "ja"),
+            ("Korean", "ko"), ("Latvian", "lv"), ("Lithuanian", "lt"), ("Macedonian", "mk"),
+            ("Malay", "ms"), ("Norwegian", "no"), ("Persian", "fa"), ("Polish", "pl"),
+            ("Portuguese", "pt"), ("Romanian", "ro"), ("Russian", "ru"), ("Serbian", "sr"),
+            ("Slovak", "sk"), ("Slovenian", "sl"), ("Spanish", "es"), ("Swahili", "sw"),
+            ("Swedish", "sv"), ("Thai", "th"), ("Turkish", "tr"), ("Ukrainian", "uk"),
+            ("Urdu", "ur"), ("Vietnamese", "vi"), ("Welsh", "cy"),
         ]
-        for lang_name, lang_code in common_langs:
+        for lang_name, lang_code in available_langs:
             source_lang_combo.addItem(lang_name, lang_code)
         settings_layout.addRow("Source Language:", source_lang_combo)
-        
+
         # Target language
         target_lang_combo = QComboBox()
-        for lang_name, lang_code in common_langs:
+        for lang_name, lang_code in available_langs:
             target_lang_combo.addItem(lang_name, lang_code)
-        
-        # Set defaults based on global language settings (if in common_langs)
-        try:
-            for lang_name, lang_code in common_langs:
-                if lang_name == self.source_language:
-                    source_lang_combo.setCurrentText(lang_name)
-                if lang_name == self.target_language:
-                    target_lang_combo.setCurrentText(lang_name)
-        except:
-            target_lang_combo.setCurrentIndex(1)  # Fallback to Dutch
+
+        # Set defaults based on global language settings
+        source_lang_combo.setCurrentText(self.source_language)
+        target_lang_combo.setCurrentText(self.target_language)
         
         settings_layout.addRow("Target Language:", target_lang_combo)
         
@@ -21709,7 +22389,11 @@ class SupervertalerQt(QMainWindow):
             target_lang=target_lang,
             segments=[]
         )
-        
+
+        # Sync global language settings with new project languages
+        self.source_language = source_lang
+        self.target_language = target_lang
+
         # Process source text if provided
         source_text = text_input.toPlainText().strip()
         if source_text:
@@ -21739,6 +22423,10 @@ class SupervertalerQt(QMainWindow):
         # Update UI
         self.project_file_path = None
         self.project_modified = True  # Mark as modified since it hasn't been saved
+
+        # Store original segment order for "Document Order" sort reset
+        self._original_segment_order = self.current_project.segments.copy()
+
         self.update_window_title()
         self.load_segments_to_grid()
         self.initialize_tm_database()  # Initialize TM for this project
@@ -21767,16 +22455,16 @@ class SupervertalerQt(QMainWindow):
                 if hasattr(self.lookup_tab, '_ahk') and self.lookup_tab._ahk:
                     try:
                         self.lookup_tab._ahk.stop_hotkeys()
-                        print("[Superlookup] ahk library hotkeys stopped")
+                        print("[SuperLookup] ahk library hotkeys stopped")
                     except Exception as e:
-                        print(f"[Superlookup] Error stopping ahk library: {e}")
+                        print(f"[SuperLookup] Error stopping ahk library: {e}")
             
             # Terminate external AutoHotkey process if running (fallback method)
             if hasattr(self, 'lookup_tab') and hasattr(self.lookup_tab, 'ahk_process') and self.lookup_tab.ahk_process:
                 try:
                     self.lookup_tab.ahk_process.terminate()
                     self.lookup_tab.ahk_process.wait(timeout=2)
-                    print("[Superlookup] AHK process terminated")
+                    print("[SuperLookup] AHK process terminated")
                 except:
                     # Force kill if terminate doesn't work
                     try:
@@ -21784,7 +22472,7 @@ class SupervertalerQt(QMainWindow):
                     except:
                         pass
         except Exception as e:
-            print(f"[Superlookup] Error terminating AHK: {e}")
+            print(f"[SuperLookup] Error terminating AHK: {e}")
         
         # Accept the close event
         event.accept()
@@ -21819,7 +22507,19 @@ class SupervertalerQt(QMainWindow):
             self.current_project = Project.from_dict(data)
             self.project_file_path = file_path
             self.project_modified = False
-            
+
+            # Store original segment order for "Document Order" sort reset
+            self._original_segment_order = self.current_project.segments.copy()
+
+            # Always reset sort state when loading - project should open in document order
+            self.current_sort = None
+
+            # Sync global language settings with project languages
+            if self.current_project.source_lang:
+                self.source_language = self.current_project.source_lang
+            if self.current_project.target_lang:
+                self.target_language = self.current_project.target_lang
+
             # Restore prompt settings if they exist (unified library)
             if hasattr(self.current_project, 'prompt_settings') and self.current_project.prompt_settings:
                 prompt_settings = self.current_project.prompt_settings
@@ -22174,7 +22874,154 @@ class SupervertalerQt(QMainWindow):
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Failed to load project:\n{str(e)}")
             self.log(f"✗ Error loading project: {e}")
-    
+
+    def _build_termbase_index(self):
+        """
+        Build in-memory index of ALL terms from activated termbases (v1.9.182).
+
+        This is called ONCE on project load and replaces thousands of per-word
+        database queries with a single bulk load + fast in-memory lookups.
+
+        Performance: Reduces 349-segment termbase search from 365 seconds to <1 second.
+        """
+        import re
+        import time
+        start_time = time.time()
+
+        if not self.current_project or not hasattr(self, 'db_manager') or not self.db_manager:
+            return
+
+        project_id = self.current_project.id if hasattr(self.current_project, 'id') else None
+
+        # Query ALL terms from activated termbases in ONE query
+        # This replaces ~17,500 individual queries (349 segments × 50 words each)
+        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,
+                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 (ta.is_active = 1 OR tb.is_project_termbase = 1)
+        """
+
+        new_index = []
+        try:
+            self.db_manager.cursor.execute(query, [project_id or 0])
+            rows = self.db_manager.cursor.fetchall()
+
+            for row in rows:
+                source_term = row[1]  # source_term
+                if not source_term:
+                    continue
+
+                source_term_lower = source_term.lower().strip()
+                if len(source_term_lower) < 2:
+                    continue
+
+                # Pre-compile regex pattern for word-boundary matching
+                # This avoids recompiling the same pattern thousands of times
+                try:
+                    # Handle terms with punctuation differently
+                    if any(c in source_term_lower for c in '.%,/-'):
+                        pattern = re.compile(r'(?<!\w)' + re.escape(source_term_lower) + r'(?!\w)')
+                    else:
+                        pattern = re.compile(r'\b' + re.escape(source_term_lower) + r'\b')
+                except re.error:
+                    # If regex fails, use simple substring matching
+                    pattern = None
+
+                new_index.append({
+                    'term_id': row[0],
+                    'source_term': source_term,
+                    'source_term_lower': source_term_lower,
+                    'target_term': row[2],
+                    'termbase_id': row[3],
+                    'priority': row[4],
+                    'domain': row[5],
+                    'notes': row[6],
+                    'project': row[7],
+                    'client': row[8],
+                    'forbidden': row[9],
+                    'is_project_termbase': row[10],
+                    'termbase_name': row[11],
+                    'ranking': row[12],
+                    'pattern': pattern,  # Pre-compiled regex
+                })
+
+            # Sort by term length (longest first) for better phrase matching
+            new_index.sort(key=lambda x: len(x['source_term_lower']), reverse=True)
+
+            # Thread-safe update of the index
+            with self.termbase_index_lock:
+                self.termbase_index = new_index
+
+            elapsed = time.time() - start_time
+            self.log(f"✅ Built termbase index: {len(new_index)} terms in {elapsed:.2f}s")
+
+        except Exception as e:
+            self.log(f"❌ Failed to build termbase index: {e}")
+            import traceback
+            self.log(traceback.format_exc())
+
+    def _search_termbase_in_memory(self, source_text: str) -> dict:
+        """
+        Search termbase using in-memory index (v1.9.182).
+
+        This replaces _search_termbases_thread_safe() for batch operations.
+        Instead of N database queries (one per word), we do:
+        - 1 pass through the index (typically ~1000 terms)
+        - Fast string 'in' check + pre-compiled regex validation
+
+        Performance: <1ms per segment vs 1+ second per segment.
+        """
+        if not source_text:
+            return {}
+
+        with self.termbase_index_lock:
+            if not self.termbase_index:
+                return {}
+            index = self.termbase_index  # Local reference for thread safety
+
+        source_lower = source_text.lower()
+        matches = {}
+
+        for term in index:
+            term_lower = term['source_term_lower']
+
+            # Quick substring check first (very fast, implemented in C)
+            if term_lower not in source_lower:
+                continue
+
+            # Word boundary validation using pre-compiled pattern
+            pattern = term.get('pattern')
+            if pattern:
+                if not pattern.search(source_lower):
+                    continue
+
+            # Term matches! Add to results
+            term_id = term['term_id']
+            matches[term_id] = {
+                'source': term['source_term'],
+                'translation': term['target_term'],
+                'term_id': term_id,
+                'termbase_id': term['termbase_id'],
+                'termbase_name': term['termbase_name'],
+                'priority': term['priority'],
+                'ranking': term['ranking'],
+                'is_project_termbase': term['is_project_termbase'],
+                'forbidden': term['forbidden'],
+                'domain': term['domain'],
+                'notes': term['notes'],
+                'project': term['project'],
+                'client': term['client'],
+            }
+
+        return matches
+
     def _start_termbase_batch_worker(self):
         """
         Start background thread to batch-process termbase matches for all segments.
@@ -22182,21 +23029,25 @@ class SupervertalerQt(QMainWindow):
         """
         if not self.current_project or len(self.current_project.segments) == 0:
             return
-        
+
+        # Build in-memory termbase index FIRST (v1.9.182)
+        # This is the key optimization: load all terms once, then do fast in-memory lookups
+        self._build_termbase_index()
+
         # 🧪 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():
             self.log("⏹️  Stopping existing termbase batch worker...")
             self.termbase_batch_worker_thread.join(timeout=2)
-        
+
         # Reset stop event for new worker
         self.termbase_batch_stop_event.clear()
-        
+
         # Start new background worker thread
         segment_count = len(self.current_project.segments)
         self.log(f"🔄 Starting background termbase batch processor for {segment_count} segments...")
@@ -22212,96 +23063,60 @@ class SupervertalerQt(QMainWindow):
         """
         Background worker thread: process all segments and populate termbase cache.
         Runs in separate thread to not block UI.
-        
-        IMPORTANT: Creates its own database connection to avoid SQLite threading errors.
+
+        v1.9.182: Now uses in-memory termbase index for 1000x faster lookups.
+        Old approach: 365 seconds for 349 segments (1 second/segment)
+        New approach: <1 second for 349 segments (<3ms/segment)
         """
         if not segments:
             return
-        
-        # Create a separate database connection for this thread
-        # SQLite connections are thread-local and cannot be shared across threads
-        import sqlite3
-        try:
-            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 as e:
-            self.log(f"❌ Failed to create database connection in batch worker: {e}")
-            return
-        
+
         try:
             processed = 0
             cached = 0
+            with_matches = 0
             start_time = time.time()
-            
+
             for segment in segments:
                 # Check if stop event was signaled (user closed project or started new one)
                 if self.termbase_batch_stop_event.is_set():
                     self.log(f"⏹️  Termbase batch worker stopped by user (processed {processed} segments)")
                     break
-                
+
                 segment_id = segment.id
-                
+
                 # Skip if already in cache (thread-safe check)
                 with self.termbase_cache_lock:
                     if segment_id in self.termbase_cache:
                         cached += 1
                         continue
-                
-                # Search termbase for this segment using thread-local database connection
+
+                # v1.9.182: Use in-memory index for instant lookup (no database queries!)
                 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,
-                        project_id=current_project_id
-                    )
-                    
+                    matches = self._search_termbase_in_memory(segment.source)
+
+                    # Store in cache (thread-safe) - even empty results to avoid re-lookup
+                    with self.termbase_cache_lock:
+                        self.termbase_cache[segment_id] = matches
+
+                    processed += 1
                     if matches:
-                        # Store in cache (thread-safe)
-                        with self.termbase_cache_lock:
-                            self.termbase_cache[segment_id] = matches
-                        
-                        processed += 1
-                        
-                        # Log progress every 100 segments
-                        if processed % 100 == 0:
-                            elapsed = time.time() - start_time
-                            rate = processed / elapsed if elapsed > 0 else 0
-                            remaining = len(segments) - processed
-                            eta_seconds = remaining / rate if rate > 0 else 0
-                            self.log(f"📊 Batch progress: {processed}/{len(segments)} cached " +
-                                   f"({rate:.1f} seg/sec, ETA: {int(eta_seconds)}s)")
-                
+                        with_matches += 1
+
                 except Exception as e:
                     self.log(f"❌ Error processing segment {segment_id} in batch worker: {e}")
                     continue
-                
-                # Small delay to prevent CPU saturation (let UI thread work)
-                time.sleep(0.001)  # 1ms delay between segments
-            
+
             elapsed = time.time() - start_time
             total_cached = len(self.termbase_cache)
-            self.log(f"✅ Termbase batch worker complete: {processed} new + {cached} existing = " +
-                   f"{total_cached} total cached in {elapsed:.1f}s")
-            
+            rate = processed / elapsed if elapsed > 0 else 0
+            self.log(f"✅ Termbase batch worker complete: {processed} segments in {elapsed:.2f}s " +
+                     f"({rate:.0f} seg/sec, {with_matches} with matches)")
+
         except Exception as e:
             self.log(f"❌ Termbase batch worker error: {e}")
             import traceback
             self.log(traceback.format_exc())
-        
-        finally:
-            # Close thread-local database connection
-            try:
-                thread_db_cursor.close()
-                thread_db_connection.close()
-                self.log("✓ Closed thread-local database connection in batch worker")
-            except:
-                pass
     
     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]:
         """
@@ -22501,11 +23316,8 @@ class SupervertalerQt(QMainWindow):
         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:
@@ -22514,9 +23326,7 @@ class SupervertalerQt(QMainWindow):
             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:
@@ -22524,23 +23334,19 @@ class SupervertalerQt(QMainWindow):
                         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}")
+                except Exception:
+                    pass  # Silent failure for proactive highlighting
             
             if next_segment_ids:
                 # Start prefetch in background (silent, no logging)
@@ -22622,43 +23428,35 @@ class SupervertalerQt(QMainWindow):
                 
                 # 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
+
+                # Count matches for logging and proactive highlighting
                 tm_count = len(matches.get("TM", []))
                 tb_count = len(matches.get("Termbases", []))
                 mt_count = len(matches.get("MT", []))
                 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}")
-                
+                # Only cache results if we found something
+                # Don't cache empty results - let main thread do fresh lookup
                 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
+
+                # 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, {})
+
+                        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
+                            self._proactive_highlight_signal.emit(segment_id, termbase_json)
+                    except Exception:
+                        pass  # Silent fail for proactive highlighting
             
         except Exception as e:
             self.log(f"Error in prefetch worker: {e}")
@@ -22708,31 +23506,9 @@ class SupervertalerQt(QMainWindow):
         source_lang_code = self._convert_language_to_code(source_lang)
         target_lang_code = self._convert_language_to_code(target_lang)
         
-        # 1. TM matches (if enabled) - thread-safe check
-        enable_tm = getattr(self, 'enable_tm_matching', True)  # Default to True if not set
-        if enable_tm and hasattr(self, 'db_manager') and self.db_manager:
-            try:
-                tm_results = self.db_manager.search_translation_memory(
-                    segment.source,
-                    source_lang,
-                    target_lang,
-                    limit=5
-                )
-                
-                if tm_results:  # Only add if we got results
-                    for tm_match in tm_results:
-                        match_obj = TranslationMatch(
-                            source=tm_match.get('source', ''),
-                            target=tm_match.get('target', ''),
-                            relevance=tm_match.get('similarity', 0),
-                            metadata={'tm_name': tm_match.get('tm_id', 'project')},
-                            match_type='TM',
-                            compare_source=tm_match.get('source', ''),
-                            provider_code='TM'
-                        )
-                        matches_dict["TM"].append(match_obj)
-            except Exception as e:
-                pass  # Silently continue
+        # 1. TM matches - SKIP in prefetch worker (TM search not thread-safe)
+        # TM will be fetched on-demand when user navigates to segment
+        pass
         
         # 2. MT matches (if enabled)
         if self.enable_mt_matching:
@@ -22907,8 +23683,9 @@ class SupervertalerQt(QMainWindow):
             mode_note = " (overwrite)" if overwrite_mode else ""
             msg = f"💾 Saved segment to {saved_count} TM(s){mode_note}"
             self._queue_tm_save_log(msg)
-            # Invalidate cache so prefetched segments get fresh TM matches
-            self.invalidate_translation_cache()
+            # NOTE: Removed cache invalidation here - it was destroying batch worker's cache
+            # on every Ctrl+Enter, making navigation extremely slow. The small chance of
+            # seeing stale TM matches is far less important than responsive navigation.
     
     def invalidate_translation_cache(self, smart_invalidation=True):
         """
@@ -23088,9 +23865,21 @@ class SupervertalerQt(QMainWindow):
             original_path = getattr(self, 'original_docx', None) or getattr(self, 'current_document_path', None)
             if original_path and os.path.exists(original_path):
                 self.current_project.original_docx_path = original_path
-            
+
+            # IMPORTANT: Always save segments in original document order, not sorted order
+            # Store current sort state and temporarily restore original order
+            current_sort_state = getattr(self, 'current_sort', None)
+            current_segments = self.current_project.segments.copy()  # Save current (possibly sorted) order
+
+            # Restore original order for saving
+            if hasattr(self, '_original_segment_order') and self._original_segment_order:
+                self.current_project.segments = self._original_segment_order.copy()
+
             with open(file_path, 'w', encoding='utf-8') as f:
                 json.dump(self.current_project.to_dict(), f, indent=2, ensure_ascii=False)
+
+            # Restore the current (sorted) order after saving
+            self.current_project.segments = current_segments
             
             self.project_modified = False
             self.update_window_title()
@@ -23734,9 +24523,9 @@ class SupervertalerQt(QMainWindow):
             # Initialize TM for this project
             self.initialize_tm_database()
             
-            # Deactivate all resources for new project (user explicitly activates what they need)
+            # Deactivate all resources for new project, then auto-activate language-matching ones
             self._deactivate_all_resources_for_new_project()
-            
+
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
 
@@ -26210,7 +26999,11 @@ class SupervertalerQt(QMainWindow):
             
             # Store memoQ source path in project for persistence across saves
             self.current_project.memoq_source_path = file_path
-            
+
+            # Sync global language settings with imported project languages
+            self.source_language = source_lang
+            self.target_language = target_lang
+
             # Create segments with simple sequential IDs
             for idx, source_text in enumerate(source_segments):
                 existing_target = target_segments[idx] if idx < len(target_segments) else ""
@@ -26234,15 +27027,15 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
-            # Deactivate all resources for new project (user explicitly activates what they need)
+            # Deactivate all resources for new project, then auto-activate language-matching ones
             self._deactivate_all_resources_for_new_project()
-            
+
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
-            
+
             # Initialize spellcheck for target language
             self._initialize_spellcheck_for_target_language(target_lang)
-            
+
             # If smart formatting was used, auto-enable Tags view so user sees the tags
             if self.memoq_smart_formatting:
                 self._enable_tag_view_after_import()
@@ -26731,7 +27524,11 @@ class SupervertalerQt(QMainWindow):
             
             # Store memoQ XLIFF source path in project for persistence across saves
             self.current_project.mqxliff_source_path = file_path
-            
+
+            # Sync global language settings with imported project languages
+            self.source_language = source_lang
+            self.target_language = target_lang
+
             # Update UI
             self.project_file_path = None
             self.project_modified = True
@@ -26739,15 +27536,15 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
-            # Deactivate all resources for new project (user explicitly activates what they need)
+            # Deactivate all resources for new project, then auto-activate language-matching ones
             self._deactivate_all_resources_for_new_project()
-            
+
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
-            
+
             # Initialize spellcheck for target language
             self._initialize_spellcheck_for_target_language(target_lang)
-            
+
             # Log success
             self.log(f"✓ Imported {len(segments)} segments from memoQ XLIFF: {Path(file_path).name}")
             self.log(f"  Source: {source_lang}, Target: {target_lang}")
@@ -27006,7 +27803,11 @@ class SupervertalerQt(QMainWindow):
             
             # Store CafeTran source path in project for persistence across saves
             self.current_project.cafetran_source_path = file_path
-            
+
+            # Sync global language settings with imported project languages
+            self.source_language = self.current_project.source_lang
+            self.target_language = self.current_project.target_lang
+
             # Update UI
             self.project_file_path = None
             self.project_modified = True
@@ -27014,16 +27815,16 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
-            # Deactivate all resources for new project (user explicitly activates what they need)
+            # Deactivate all resources for new project, then auto-activate language-matching ones
             self._deactivate_all_resources_for_new_project()
-            
+
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
-            
+
             # Initialize spellcheck for target language
             target_lang = self.current_project.target_lang if self.current_project else 'nl'
             self._initialize_spellcheck_for_target_language(target_lang)
-            
+
             # Log success
             self.log(f"✓ Imported {len(segments)} segments from CafeTran bilingual DOCX: {Path(file_path).name}")
             
@@ -27230,7 +28031,11 @@ class SupervertalerQt(QMainWindow):
             
             # Store Trados source path in project for persistence across saves
             self.current_project.trados_source_path = file_path
-            
+
+            # Sync global language settings with imported project languages
+            self.source_language = source_lang
+            self.target_language = target_lang
+
             # Update UI
             self.project_file_path = None
             self.project_modified = True
@@ -27238,15 +28043,15 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
-            # Deactivate all resources for new project (user explicitly activates what they need)
+            # Deactivate all resources for new project, then auto-activate language-matching ones
             self._deactivate_all_resources_for_new_project()
-            
+
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
-            
+
             # Initialize spellcheck for target language
             self._initialize_spellcheck_for_target_language(target_lang)
-            
+
             # Count segments with tags
             tagged_count = sum(1 for s in trados_segments if s.source_tags)
             
@@ -27590,7 +28395,11 @@ class SupervertalerQt(QMainWindow):
             self.sdlppx_handler = handler
             self.sdlppx_source_file = file_path
             self.current_project.sdlppx_source_path = file_path
-            
+
+            # Sync global language settings with imported project languages
+            self.source_language = source_lang
+            self.target_language = target_lang
+
             # Update UI
             self.project_file_path = None
             self.project_modified = True
@@ -27923,6 +28732,10 @@ class SupervertalerQt(QMainWindow):
             # Store Phrase source path in project for persistence across saves
             self.current_project.phrase_source_path = file_path
 
+            # Sync global language settings with imported project languages
+            self.source_language = source_lang
+            self.target_language = target_lang
+
             # Update UI
             self.project_file_path = None
             self.project_modified = True
@@ -28203,7 +29016,11 @@ class SupervertalerQt(QMainWindow):
             
             # Store Déjà Vu source path in project for persistence
             self.current_project.dejavu_source_path = file_path
-            
+
+            # Sync global language settings with imported project languages
+            self.source_language = source_lang
+            self.target_language = target_lang
+
             # Create segments
             for idx, seg_data in enumerate(segments_data):
                 segment = Segment(
@@ -28777,7 +29594,11 @@ class SupervertalerQt(QMainWindow):
     def load_segments_to_grid(self):
         """Load segments into the grid with termbase highlighting"""
         self.log(f"🔄🔄🔄 load_segments_to_grid CALLED - this will RELOAD grid from segment data!")
-        
+
+        # Ensure original segment order is stored (for Document Order sort)
+        if self.current_project and not hasattr(self, '_original_segment_order'):
+            self._original_segment_order = self.current_project.segments.copy()
+
         # Clear row color settings cache to ensure fresh settings are loaded
         if hasattr(self, '_row_color_settings_cached'):
             delattr(self, '_row_color_settings_cached')
@@ -28853,6 +29674,9 @@ class SupervertalerQt(QMainWindow):
                 segment_num_color = "black" if theme.name in ["Light (Default)", "Soft Gray", "Warm Cream", "Sepia", "High Contrast"] else theme.text
                 id_item.setForeground(QColor(segment_num_color))
                 id_item.setBackground(QColor())  # Default background from theme
+                # Smaller font for segment numbers
+                seg_num_font = QFont(self.default_font_family, max(9, self.default_font_size - 1))
+                id_item.setFont(seg_num_font)
                 self.table.setItem(row, 0, id_item)
                 
                 # Type - show segment type based on style and content
@@ -28935,13 +29759,17 @@ class SupervertalerQt(QMainWindow):
                 type_item = QTableWidgetItem(type_display)
                 type_item.setFlags(type_item.flags() & ~Qt.ItemFlag.ItemIsEditable)  # Read-only
                 type_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
-                
+
                 # Color-code by type for better visibility
                 if type_display in ("H1", "H2", "H3", "H4", "Title"):
                     type_item.setForeground(QColor("#1976D2"))  # Blue for headings (works in both themes)
                 elif type_display.startswith("#") or type_display in ("•", "li"):
                     type_item.setForeground(QColor("#388E3C"))  # Green for list items (works in both themes)
-                
+
+                # Smaller font for type symbols
+                type_font = QFont(self.default_font_family, max(9, self.default_font_size - 1))
+                type_item.setFont(type_font)
+
                 self.table.setItem(row, 1, type_item)
                 
                 # Source - Use read-only QTextEdit widget for easy text selection
@@ -29218,9 +30046,13 @@ class SupervertalerQt(QMainWindow):
         termview_layout.setContentsMargins(4, 4, 4, 0)
         termview_layout.setSpacing(2)
         
-        # Termview header label
+        # Termview header label (theme-aware)
         termview_header = QLabel("📖 Termview")
-        termview_header.setStyleSheet("font-weight: bold; font-size: 9px; color: #666;")
+        if hasattr(self, 'theme_manager') and self.theme_manager:
+            header_color = self.theme_manager.current_theme.text_disabled
+        else:
+            header_color = "#666"
+        termview_header.setStyleSheet(f"font-weight: bold; font-size: 9px; color: {header_color};")
         termview_layout.addWidget(termview_header)
         
         # Third Termview instance for Match Panel
@@ -29244,11 +30076,19 @@ class SupervertalerQt(QMainWindow):
         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"
+
+        # Get theme-aware colors for TM boxes (same as Compare Panel)
+        if hasattr(self, 'theme_manager') and self.theme_manager:
+            theme = self.theme_manager.current_theme
+            is_dark = getattr(theme, 'is_dark', 'dark' in theme.name.lower())
+            border_color = theme.border
+            text_color = theme.text
+            # Green background - theme-appropriate shade
+            tm_box_bg = theme.panel_success if hasattr(theme, 'panel_success') else ("#1e3a2f" if is_dark else "#d4edda")
+        else:
+            tm_box_bg = "#d4edda"    # Green (light mode)
+            text_color = "#333"
+            border_color = "#ddd"
         
         # TM Source box (GREEN, with navigation)
         self.match_panel_tm_matches = []  # Separate match list
@@ -29377,7 +30217,10 @@ class SupervertalerQt(QMainWindow):
             if shortcut_badge_tooltip:
                 badge_label.setToolTip(f"Press {shortcut_badge_tooltip} to insert")
             header_layout.addWidget(badge_label)
-        
+
+        # Add stretch to push navigation controls to the right (aligned with scrollbar)
+        header_layout.addStretch()
+
         nav_label = None
         nav_buttons = None
 
@@ -29390,45 +30233,60 @@ class SupervertalerQt(QMainWindow):
             header_layout.addWidget(nav_label)
 
         if has_navigation:
-            
-            # Prev button
-            prev_btn = QPushButton("◄")
-            prev_btn.setFixedSize(18, 16)
-            prev_btn.setStyleSheet(f"""
-                QPushButton {{
-                    font-size: 9px; 
-                    padding: 0px; 
-                    background: transparent; 
-                    border: 1px solid {border_color}; 
-                    border-radius: 2px;
-                    color: {text_color};
-                }}
-                QPushButton:hover {{
-                    background: rgba(128,128,128,0.2);
-                }}
-            """)
+            # Detect theme for arrow color
+            is_dark_theme = hasattr(self, 'theme_manager') and self.theme_manager and 'dark' in self.theme_manager.current_theme.name.lower()
+            arrow_color = "#FFFFFF" if is_dark_theme else "#333333"
+
+            # Create clickable label class with theme update capability
+            from PyQt6.QtCore import pyqtSignal
+
+            class ClickableArrow(QLabel):
+                clicked = pyqtSignal()
+
+                def __init__(self, arrow_symbol, parent=None):
+                    """arrow_symbol: '◀' or '▶'"""
+                    self.arrow_symbol = arrow_symbol
+                    super().__init__("", parent)
+                    self.setCursor(Qt.CursorShape.PointingHandCursor)
+
+                def set_color(self, color):
+                    """Update arrow color for current theme"""
+                    self.setStyleSheet(f"""
+                        QLabel {{
+                            color: {color};
+                            background: transparent;
+                            border: none;
+                            font-size: 11px;
+                            font-weight: bold;
+                        }}
+                    """)
+                    self.setText(self.arrow_symbol)
+
+                def mousePressEvent(self, event):
+                    self.clicked.emit()
+                    super().mousePressEvent(event)
+
+            # Prev arrow - using ◀
+            prev_btn = ClickableArrow("◀")
+            prev_btn.set_color(arrow_color)
+            prev_btn.setFixedSize(16, 16)
+            prev_btn.setAlignment(Qt.AlignmentFlag.AlignCenter)
             header_layout.addWidget(prev_btn)
-            
-            # Next button
-            next_btn = QPushButton("►")
-            next_btn.setFixedSize(18, 16)
-            next_btn.setStyleSheet(f"""
-                QPushButton {{
-                    font-size: 9px; 
-                    padding: 0px; 
-                    background: transparent; 
-                    border: 1px solid {border_color}; 
-                    border-radius: 2px;
-                    color: {text_color};
-                }}
-                QPushButton:hover {{
-                    background: rgba(128,128,128,0.2);
-                }}
-            """)
+
+            # Next arrow - using ▶
+            next_btn = ClickableArrow("▶")
+            next_btn.set_color(arrow_color)
+            next_btn.setFixedSize(16, 16)
+            next_btn.setAlignment(Qt.AlignmentFlag.AlignCenter)
             header_layout.addWidget(next_btn)
+
+            # Store reference for theme updates
+            if not hasattr(self, 'theme_aware_arrows'):
+                self.theme_aware_arrows = []
+            self.theme_aware_arrows.extend([prev_btn, next_btn])
+
             nav_buttons = [prev_btn, next_btn]
-        
-        header_layout.addStretch()
+
         main_layout.addLayout(header_layout)
         
         # Text area
@@ -30351,19 +31209,24 @@ class SupervertalerQt(QMainWindow):
             widget.setToolTip(f"Notes: {segment.notes.strip()}")
             
         status_def = get_status(segment.status)
-        status_label = QLabel(status_def.icon)
+
+        # Status icons: ✔ (green) and ❌ (naturally red emoji)
+        icon_text = status_def.icon
+        if segment.status == "confirmed":
+            icon_html = f'<font color="#2e7d32" size="2">{icon_text}</font>'  # Green checkmark
+        else:
+            icon_html = f'<font size="2">{icon_text}</font>'  # Other icons (including ❌ emoji)
+
+        status_label = QLabel(icon_html)
+        status_label.setTextFormat(Qt.TextFormat.RichText)  # Enable HTML rendering
         status_label.setAlignment(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft)
+        status_label.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Expanding)  # Expand vertically to match row height
         status_label.setToolTip(status_def.label)
-        # Slightly smaller X for "not_started" to match other icons better
-        font_size = "10px" if segment.status == "not_started" else "14px"
-        # Make confirmed checkmark green
-        color = "color: #2e7d32;" if segment.status == "confirmed" else ""
-        
-        # Apply orange background highlight to status icon if segment has notes
+
+        # Add orange background if segment has notes (using stylesheet for background only)
         if has_notes:
-            status_label.setStyleSheet(f"font-size: {font_size}; {color} padding: 2px 4px; background-color: rgba(255, 152, 0, 0.35); border-radius: 3px;")
-        else:
-            status_label.setStyleSheet(f"font-size: {font_size}; {color} padding-right: 4px;")
+            status_label.setStyleSheet("padding: 2px 4px; background-color: rgba(255, 152, 0, 0.35); border-radius: 3px;")
+        # Note: No stylesheet for non-notes case to avoid interfering with HTML color
         layout.addWidget(status_label)
 
         # Only add match label if there's a match percentage
@@ -30475,14 +31338,17 @@ class SupervertalerQt(QMainWindow):
         """Auto-resize all rows to fit content - Compact version"""
         if not hasattr(self, 'table') or not self.table:
             return
-        
+
         # Reduce width slightly to account for padding and prevent text cut-off
         width_reduction = 8
-        
+
         # Manually calculate and set row heights for compact display
         for row in range(self.table.rowCount()):
+            # Keep UI responsive during large grid updates
+            if row % 50 == 0:
+                QApplication.processEvents()
             self._auto_resize_single_row(row, width_reduction)
-        
+
         self.log("✓ Auto-resized rows to fit content (compact)")
         self._enforce_status_row_heights()
     
@@ -30529,26 +31395,30 @@ class SupervertalerQt(QMainWindow):
     def apply_font_to_grid(self):
         """Apply selected font to all grid cells"""
         font = QFont(self.default_font_family, self.default_font_size)
-        
+
         self.table.setFont(font)
-        
-        # Also update header font
-        header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Bold)
+
+        # Also update header font - same size as grid content, normal weight
+        header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Normal)
         self.table.horizontalHeader().setFont(header_font)
-        
+
         # Update fonts in QTextEdit widgets (source and target columns)
         if hasattr(self, 'table') and self.table:
             for row in range(self.table.rowCount()):
+                # Keep UI responsive during large grid updates
+                if row % 50 == 0:
+                    QApplication.processEvents()
+
                 # Source column (2) - ReadOnlyGridTextEditor
                 source_widget = self.table.cellWidget(row, 2)
                 if source_widget and isinstance(source_widget, ReadOnlyGridTextEditor):
                     source_widget.setFont(font)
-                
+
                 # Target column (3) - EditableGridTextEditor
                 target_widget = self.table.cellWidget(row, 3)
                 if target_widget and isinstance(target_widget, EditableGridTextEditor):
                     target_widget.setFont(font)
-        
+
         # Adjust segment number column width based on font size
         self._update_segment_column_width()
     
@@ -30572,12 +31442,12 @@ class SupervertalerQt(QMainWindow):
         # Measure the width of the largest number (as string)
         text_width = fm.horizontalAdvance(str(max_segment))
         
-        # Add padding (10px on each side = 20px total)
-        new_width = text_width + 20
-        
-        # Ensure minimum width for very small numbers
-        new_width = max(30, new_width)
-        
+        # Add padding (6px on each side = 12px total)
+        new_width = text_width + 12
+
+        # Ensure minimum width for very small numbers, cap at width for ~1000
+        new_width = max(30, min(new_width, 55))
+
         self.table.setColumnWidth(0, new_width)
     
     def set_font_family(self, family_name: str):
@@ -30609,14 +31479,18 @@ class SupervertalerQt(QMainWindow):
         """Refresh tag highlight colors in all grid cells"""
         if not hasattr(self, 'table') or not self.table:
             return
-        
+
         for row in range(self.table.rowCount()):
+            # Keep UI responsive during large grid updates
+            if row % 50 == 0:
+                QApplication.processEvents()
+
             # Source column (2) - ReadOnlyGridTextEditor
             source_widget = self.table.cellWidget(row, 2)
             if source_widget and isinstance(source_widget, ReadOnlyGridTextEditor):
                 if hasattr(source_widget, 'highlighter'):
                     source_widget.highlighter.set_tag_color(EditableGridTextEditor.tag_highlight_color)
-            
+
             # Target column (3) - EditableGridTextEditor
             target_widget = self.table.cellWidget(row, 3)
             if target_widget and isinstance(target_widget, EditableGridTextEditor):
@@ -30681,18 +31555,22 @@ class SupervertalerQt(QMainWindow):
         """Apply alternating row colors to all source and target cells in the grid"""
         if not hasattr(self, 'table') or not self.table:
             return
-        
+
         # Clear cached settings to force reload
         if hasattr(self, '_row_color_settings_cached'):
             delattr(self, '_row_color_settings_cached')
-        
+
         for row in range(self.table.rowCount()):
+            # Keep UI responsive during large grid updates
+            if row % 50 == 0:
+                QApplication.processEvents()
+
             source_widget = self.table.cellWidget(row, 2)
             target_widget = self.table.cellWidget(row, 3)
-            
+
             if source_widget and target_widget:
                 self._apply_row_color(row, source_widget, target_widget)
-        
+
         self.log("✓ Alternating row colors applied")
     
     def on_font_changed(self):
@@ -30864,8 +31742,8 @@ 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: True = caches disabled for stability)
-        self.disable_all_caches = settings.get('disable_all_caches', True)
+        # Load cache kill switch setting (default: False = caches ENABLED for performance)
+        self.disable_all_caches = settings.get('disable_all_caches', False)
 
         # Load LLM provider settings for AI Assistant
         llm_settings = self.load_llm_settings()
@@ -31278,7 +32156,7 @@ class SupervertalerQt(QMainWindow):
         """Handle cell selection change"""
         if self.debug_mode_enabled:
             self.log(f"🎯 on_cell_selected called: row {current_row}, col {current_col}")
-        
+
         # 🚫 GUARD: Don't re-run lookups if we're staying on the same row
         # This prevents lookups when user edits text (focus changes within same row)
         if hasattr(self, '_last_selected_row') and self._last_selected_row == current_row:
@@ -31286,34 +32164,35 @@ class SupervertalerQt(QMainWindow):
                 self.log(f"⏭️ Skipping lookup - already on row {current_row}")
             return
         self._last_selected_row = current_row
-        
-        # ⚡ 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)
-        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()
-            from PyQt6.QtCore import QTimer
-            self._deferred_lookup_timer = QTimer()
-            self._deferred_lookup_timer.setSingleShot(True)
-            self._deferred_lookup_timer.timeout.connect(
-                lambda r=current_row, c=current_col, pr=previous_row, pc=previous_col: 
-                self._on_cell_selected_full(r, c, pr, pc)
-            )
-            self._deferred_lookup_timer.start(150)  # 150ms debounce
-            
-            # Do minimal UI update immediately (orange highlight, scroll)
+
+        # ⚡ FILTER MODE: Skip ALL heavy lookups when text filters are active
+        # User is quickly navigating through filtered results - don't slow them down
+        is_filtering = getattr(self, 'filtering_active', False)
+        if is_filtering:
+            # Only do minimal UI update (orange highlight) - no TM/termbase lookups
             self._on_cell_selected_minimal(current_row, previous_row)
             return
-        
-        # Full processing for non-arrow-key navigation (click, etc.)
-        self._on_cell_selected_full(current_row, current_col, previous_row, previous_col)
+
+        # ⚡ FAST PATH: Defer heavy lookups for ALL navigation (arrow keys, Ctrl+Enter, AND mouse clicks)
+        # This makes segment navigation feel INSTANT - cursor moves first, lookups happen after
+        # Reset any navigation flags
+        self._arrow_key_navigation = False
+        self._ctrl_enter_navigation = False
+
+        # Schedule deferred lookup with short delay - debounce prevents hammering during rapid navigation
+        if hasattr(self, '_deferred_lookup_timer') and self._deferred_lookup_timer:
+            self._deferred_lookup_timer.stop()
+        from PyQt6.QtCore import QTimer
+        self._deferred_lookup_timer = QTimer()
+        self._deferred_lookup_timer.setSingleShot(True)
+        self._deferred_lookup_timer.timeout.connect(
+            lambda r=current_row, c=current_col, pr=previous_row, pc=previous_col:
+            self._on_cell_selected_full(r, c, pr, pc)
+        )
+        self._deferred_lookup_timer.start(10)  # 10ms - just enough to batch rapid arrow key holding
+
+        # Do minimal UI update immediately (orange highlight, scroll)
+        self._on_cell_selected_minimal(current_row, previous_row)
     
     def _center_row_in_viewport(self, row: int):
         """Center the given row vertically in the visible table viewport.
@@ -31535,9 +32414,12 @@ class SupervertalerQt(QMainWindow):
                             ]
                             # Also get NT matches (fresh, not cached - they may have changed)
                             nt_matches = self.find_nt_matches_in_source(segment.source)
-                            
+
+                            # Get status hint for termbase activation
+                            status_hint = self._get_termbase_status_hint()
+
                             # Update both Termview widgets (left and right)
-                            self._update_both_termviews(segment.source, termbase_matches, nt_matches)
+                            self._update_both_termviews(segment.source, termbase_matches, nt_matches, status_hint)
                         except Exception as e:
                             self.log(f"Error updating termview from cache: {e}")
                     
@@ -31570,9 +32452,25 @@ class SupervertalerQt(QMainWindow):
                         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
+                    # Skip the slow TERMBASE lookup below, we already have termbase matches cached
+                    # But TM lookup was skipped in prefetch (not thread-safe), so schedule it now
                     matches_dict = cached_matches  # Set for later use
+
+                    # v1.9.182: Schedule TM lookup even on cache hit (prefetch skips TM - not thread-safe)
+                    tm_count = len(cached_matches.get("TM", []))
+                    if tm_count == 0 and self.enable_tm_matching:
+                        find_replace_active = getattr(self, 'find_replace_active', False)
+                        if not find_replace_active:
+                            # Get termbase matches for the lookup
+                            termbase_matches_for_tm = [
+                                {
+                                    'source_term': match.source,
+                                    'target_term': match.target,
+                                    'termbase_name': match.metadata.get('termbase_name', '') if match.metadata else '',
+                                }
+                                for match in cached_matches.get("Termbases", [])
+                            ]
+                            self._schedule_mt_and_llm_matches(segment, termbase_matches_for_tm)
                 
                 # Check if TM/Termbase matching is enabled
                 if not matches_dict and (not self.enable_tm_matching and not self.enable_termbase_matching):
@@ -31621,9 +32519,12 @@ class SupervertalerQt(QMainWindow):
                                     ] if stored_matches else []
                                     # Also get NT matches
                                     nt_matches = self.find_nt_matches_in_source(segment.source)
-                                    
+
+                                    # Get status hint for termbase activation
+                                    status_hint = self._get_termbase_status_hint()
+
                                     # Update both Termview widgets (left and right)
-                                    self._update_both_termviews(segment.source, termbase_matches, nt_matches)
+                                    self._update_both_termviews(segment.source, termbase_matches, nt_matches, status_hint)
                                 except Exception as e:
                                     self.log(f"Error refreshing termview: {e}")
 
@@ -31790,15 +32691,19 @@ class SupervertalerQt(QMainWindow):
 
                     # Schedule expensive searches (TM, MT, LLM) with debouncing to prevent UI blocking
                     # ONLY schedule if:
-                    # 1. Cache miss (no prefetched matches)
+                    # 1. Cache miss OR cache hit with no TM matches (prefetch doesn't include TM - not thread-safe)
                     # 2. TM matching is enabled
                     # 3. Find/Replace is not active (to avoid slowdowns during navigation)
+                    needs_tm_lookup = True
                     with self.translation_matches_cache_lock:
-                        cache_hit = segment_id in self.translation_matches_cache
-                    
+                        if segment_id in self.translation_matches_cache:
+                            cached = self.translation_matches_cache[segment_id]
+                            # v1.9.182: Check if TM matches exist - prefetch worker skips TM lookups
+                            needs_tm_lookup = len(cached.get("TM", [])) == 0
+
                     find_replace_active = getattr(self, 'find_replace_active', False)
-                    
-                    if not cache_hit and self.enable_tm_matching and not find_replace_active:
+
+                    if needs_tm_lookup and self.enable_tm_matching and not find_replace_active:
                         # Get termbase matches if they exist (could be None or empty)
                         termbase_matches = matches_dict.get('Termbases', []) if matches_dict else []
                         self._schedule_mt_and_llm_matches(segment, termbase_matches)
@@ -31810,9 +32715,7 @@ class SupervertalerQt(QMainWindow):
                     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]:
                         # Check if already cached
                         with self.translation_matches_cache_lock:
@@ -31826,15 +32729,12 @@ class SupervertalerQt(QMainWindow):
                             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")
+                            except Exception:
+                                pass  # Silent failure for proactive highlighting
+
                     if next_segment_ids:
                         self._start_prefetch_worker(next_segment_ids)
                         
@@ -33765,7 +34665,8 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                 self.nt_manager.set_list_active(list_name, False)
         
         self.log("📋 New project: All TMs, glossaries, and NT lists deactivated (start clean)")
-    
+        self.log("💡 Tip: Go to Resources tab to activate TMs and glossaries for this project")
+
     def search_and_display_tm_matches(self, source_text: str):
         """Search TM and Termbases and display matches with visual diff for fuzzy matches"""
         self.log(f"🚨 search_and_display_tm_matches called with source_text: '{source_text[:50]}...'")
@@ -33788,11 +34689,34 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         try:
             # Get activated TM IDs for current project
             tm_ids = None
+            no_tms_activated = False
+            tms_wrong_language = False
             if hasattr(self, 'tm_metadata_mgr') and self.tm_metadata_mgr and self.current_project:
                 project_id = self.current_project.id if hasattr(self.current_project, 'id') else None
                 if project_id:
                     tm_ids = self.tm_metadata_mgr.get_active_tm_ids(project_id)
-            
+                    # Check if no TMs are activated for this project
+                    if tm_ids is not None and len(tm_ids) == 0:
+                        no_tms_activated = True
+                    elif tm_ids and len(tm_ids) > 0:
+                        # Check if any activated TMs match the project's language pair
+                        project_source = (self.current_project.source_lang or '').lower()
+                        project_target = (self.current_project.target_lang or '').lower()
+                        all_tms = self.tm_metadata_mgr.get_all_tms()
+                        has_matching_language = False
+                        for tm in all_tms:
+                            if tm['id'] in tm_ids:
+                                tm_source = (tm.get('source_lang') or '').lower()
+                                tm_target = (tm.get('target_lang') or '').lower()
+                                # Match if languages align (bidirectional) or TM has no language set
+                                if (not tm_source and not tm_target) or \
+                                   (tm_source == project_source and tm_target == project_target) or \
+                                   (tm_source == project_target and tm_target == project_source):
+                                    has_matching_language = True
+                                    break
+                        if not has_matching_language:
+                            tms_wrong_language = True
+
             # Search for matches (using activated TMs if available)
             matches = self.tm_database.search_all(source_text, tm_ids=tm_ids, max_matches=5)
             
@@ -33839,10 +34763,26 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             
             if not matches:
                 if hasattr(self, 'tm_display'):
-                    self.tm_display.setHtml(
-                        f"<p style='color: #666;'><b>Source:</b> {source_text}</p>"
-                        f"<p style='color: #999;'><i>No translation memory matches found</i></p>"
-                    )
+                    if no_tms_activated:
+                        # Show helpful message when no TMs are activated
+                        self.tm_display.setHtml(
+                            f"<p style='color: #666;'><b>Source:</b> {source_text}</p>"
+                            f"<p style='color: #E65100;'><i>No TMs activated for this project.</i></p>"
+                            f"<p style='color: #999; font-size: 9pt;'>Go to <b>Resources → TM</b> to activate translation memories.</p>"
+                        )
+                    elif tms_wrong_language:
+                        # Show message when TMs are activated but don't match project language pair
+                        project_lang_pair = f"{self.current_project.source_lang} → {self.current_project.target_lang}" if self.current_project else ""
+                        self.tm_display.setHtml(
+                            f"<p style='color: #666;'><b>Source:</b> {source_text}</p>"
+                            f"<p style='color: #E65100;'><i>Activated TMs don't match project language ({project_lang_pair}).</i></p>"
+                            f"<p style='color: #999; font-size: 9pt;'>Go to <b>Resources → TM</b> to activate TMs for this language pair.</p>"
+                        )
+                    else:
+                        self.tm_display.setHtml(
+                            f"<p style='color: #666;'><b>Source:</b> {source_text}</p>"
+                            f"<p style='color: #999;'><i>No translation memory matches found</i></p>"
+                        )
                 return
             
             # If using TranslationResultsPanel, populate it with TM and Termbase results
@@ -34197,18 +35137,32 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """
         Find all termbase matches in source text
         Returns dict of {term: translation} for all matches found
+
+        v1.9.182: Uses in-memory index for instant lookup when available.
+        Falls back to per-word database queries if index not built.
         """
         if not source_text or not hasattr(self, 'db_manager') or not self.db_manager:
             return {}
 
         try:
+            # v1.9.182: Use in-memory index for instant lookup (1000x faster)
+            # The index is built on project load by _build_termbase_index()
+            with self.termbase_index_lock:
+                has_index = bool(self.termbase_index)
+
+            if has_index:
+                # Fast path: use pre-built in-memory index
+                return self._search_termbase_in_memory(source_text)
+
+            # Fallback: original per-word database query approach
+            # (only used if index not yet built, e.g., during startup)
             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
-            
+
             # Convert language names to codes for termbase search
             source_lang_code = self._convert_language_to_code(source_lang) if source_lang else None
             target_lang_code = self._convert_language_to_code(target_lang) if target_lang else None
-            
+
             # Strip HTML/XML/CAT tool tags from source text before word splitting
             # This handles <b>, </b>, <i>, memoQ {1}, [2}, Trados <1>, Déjà Vu {00001}, etc.
             import re
@@ -34218,7 +35172,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             # memoQ content tags: [uicontrol id="..."}  or  {uicontrol]  or  [tagname ...}  or  {tagname]
             clean_source_text = re.sub(r'\[[^\[\]]*\}', '', clean_source_text)  # Opening: [anything}
             clean_source_text = re.sub(r'\{[^\{\}]*\]', '', clean_source_text)  # Closing: {anything]
-            
+
             # Search termbases for all terms that appear in the source text
             # Split source text into words and search for each one
             words = clean_source_text.split()
@@ -34440,23 +35394,17 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             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()):
@@ -34469,44 +35417,25 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                             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()}")
+
+        except Exception:
+            pass  # Silent failure for proactive highlighting
     
     def insert_term_translation(self, row: int, translation: str):
         """
@@ -35494,8 +36423,11 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         'termbase_id': match_info.get('termbase_id'),
                         'notes': match_info.get('notes', '')
                     })
+                # Get status hint for termbase activation
+                status_hint = self._get_termbase_status_hint()
+
                 # Update both Termview widgets
-                self._update_both_termviews(segment.source, tb_list, nt_matches)
+                self._update_both_termviews(segment.source, tb_list, nt_matches, status_hint)
                 self.log("   ✓ TermView updated")
             except Exception as e:
                 self.log(f"   ⚠️ TermView update error: {e}")
@@ -36512,9 +37444,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """Update spellcheck button style based on enabled state"""
         if hasattr(self, 'spellcheck_btn'):
             if self.spellcheck_enabled:
-                self.spellcheck_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
+                self.spellcheck_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px;")
             else:
-                self.spellcheck_btn.setStyleSheet("background-color: #9E9E9E; color: white; font-weight: bold;")
+                self.spellcheck_btn.setStyleSheet("background-color: #9E9E9E; color: white; font-weight: bold; padding: 3px 5px;")
 
     def _toggle_spellcheck(self, checked=None):
         """Toggle spellcheck on/off"""
@@ -37214,7 +38146,154 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             self.table.setUpdatesEnabled(True)
         
         self.log(f"🔍 Advanced filters: showing {visible_count} of {len(self.current_project.segments)} segments")
-    
+
+    def apply_sort(self, sort_type: str = None):
+        """Sort segments by various criteria (similar to memoQ)"""
+        if not self.current_project or not hasattr(self, 'table') or self.table is None:
+            return
+
+        if not self.current_project.segments:
+            return
+
+        # Show progress dialog during sorting
+        from PyQt6.QtWidgets import QProgressDialog
+        from PyQt6.QtCore import Qt
+
+        progress = QProgressDialog("Sorting segments, please wait...", None, 0, 0, self)
+        progress.setWindowTitle("Sorting")
+        progress.setWindowModality(Qt.WindowModality.WindowModal)
+        progress.setMinimumDuration(0)  # Show immediately
+        progress.show()
+        QApplication.processEvents()  # Force UI update
+
+        try:
+            # Store original document order if not already stored
+            if not hasattr(self, '_original_segment_order'):
+                self._original_segment_order = self.current_project.segments.copy()
+
+            # Update current sort state
+            self.current_sort = sort_type
+
+            # If sort_type is None, restore document order
+            if sort_type is None:
+                # Restore document order by sorting by segment ID (original position)
+                # This works even if the stored original order is wrong
+                self.current_project.segments.sort(key=lambda seg: int(seg.id))
+
+                # Update stored original order to this correct order
+                self._original_segment_order = self.current_project.segments.copy()
+
+                # Set pagination to "All" to show all segments
+                if hasattr(self, 'page_size_combo') and self._widget_is_alive(self.page_size_combo):
+                    self.page_size_combo.blockSignals(True)
+                    self.page_size_combo.setCurrentText("All")
+                    self.page_size_combo.blockSignals(False)
+                    # Update the internal page size variable
+                    if hasattr(self, 'grid_page_size'):
+                        self.grid_page_size = 999999
+
+                self.load_segments_to_grid()
+                self.log("↩️ Restored document order (showing all segments)")
+                return
+
+            # Helper function to get text without tags for more accurate sorting
+            def strip_tags(text: str) -> str:
+                """Remove HTML/XML tags from text for sorting"""
+                import re
+                return re.sub(r'<[^>]+>', '', text).strip()
+
+            # Calculate frequency maps if needed
+            frequency_cache = {}
+            if 'freq' in sort_type:
+                from collections import Counter
+                if 'source' in sort_type:
+                    counter = Counter(strip_tags(seg.source).lower() for seg in self.current_project.segments)
+                    frequency_cache = {strip_tags(seg.source).lower(): counter[strip_tags(seg.source).lower()]
+                                     for seg in self.current_project.segments}
+                else:  # target frequency
+                    counter = Counter(strip_tags(seg.target).lower() for seg in self.current_project.segments if seg.target)
+                    frequency_cache = {strip_tags(seg.target).lower(): counter[strip_tags(seg.target).lower()]
+                                     for seg in self.current_project.segments if seg.target}
+
+            # Sort based on selected criterion
+            if sort_type == 'source_asc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.source).lower())
+                sort_name = "Source A → Z"
+            elif sort_type == 'source_desc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.source).lower(), reverse=True)
+                sort_name = "Source Z → A"
+            elif sort_type == 'target_asc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.target).lower() if s.target else "")
+                sort_name = "Target A → Z"
+            elif sort_type == 'target_desc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.target).lower() if s.target else "", reverse=True)
+                sort_name = "Target Z → A"
+            elif sort_type == 'source_length_asc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.source)))
+                sort_name = "Source (shorter first)"
+            elif sort_type == 'source_length_desc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.source)), reverse=True)
+                sort_name = "Source (longer first)"
+            elif sort_type == 'target_length_asc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.target)) if s.target else 0)
+                sort_name = "Target (shorter first)"
+            elif sort_type == 'target_length_desc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.target)) if s.target else 0, reverse=True)
+                sort_name = "Target (longer first)"
+            elif sort_type == 'match_asc':
+                self.current_project.segments.sort(key=lambda s: getattr(s, 'match_percent', 0) or 0)
+                sort_name = "Match Rate (lower first)"
+            elif sort_type == 'match_desc':
+                self.current_project.segments.sort(key=lambda s: getattr(s, 'match_percent', 0) or 0, reverse=True)
+                sort_name = "Match Rate (higher first)"
+            elif sort_type == 'source_freq_asc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.source).lower(), 0))
+                sort_name = "Source Frequency (lower first)"
+            elif sort_type == 'source_freq_desc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.source).lower(), 0), reverse=True)
+                sort_name = "Source Frequency (higher first)"
+            elif sort_type == 'target_freq_asc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.target).lower(), 0) if s.target else 0)
+                sort_name = "Target Frequency (lower first)"
+            elif sort_type == 'target_freq_desc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.target).lower(), 0) if s.target else 0, reverse=True)
+                sort_name = "Target Frequency (higher first)"
+            elif sort_type == 'modified_asc':
+                self.current_project.segments.sort(key=lambda s: s.modified_at if s.modified_at else "")
+                sort_name = "Last Changed (oldest first)"
+            elif sort_type == 'modified_desc':
+                self.current_project.segments.sort(key=lambda s: s.modified_at if s.modified_at else "", reverse=True)
+                sort_name = "Last Changed (newest first)"
+            elif sort_type == 'status':
+                # Sort by status in a logical order: not_started, draft, translated, confirmed
+                status_order = {'not_started': 0, 'draft': 1, 'translated': 2, 'confirmed': 3}
+                self.current_project.segments.sort(key=lambda s: status_order.get(s.status, 99))
+                sort_name = "Row Status"
+            else:
+                self.log(f"⚠️ Unknown sort type: {sort_type}")
+                return
+
+            # Set pagination to "All" to show all sorted segments
+            if hasattr(self, 'page_size_combo') and self._widget_is_alive(self.page_size_combo):
+                self.page_size_combo.blockSignals(True)
+                self.page_size_combo.setCurrentText("All")
+                self.page_size_combo.blockSignals(False)
+                # Update the internal page size variable
+                if hasattr(self, 'grid_page_size'):
+                    self.grid_page_size = 999999
+
+            # Reload grid to reflect new order
+            self.load_segments_to_grid()
+            self.log(f"⇅ Sorted by: {sort_name} (showing all segments)")
+
+        except Exception as e:
+            self.log(f"❌ Error sorting segments: {e}")
+            import traceback
+            traceback.print_exc()
+        finally:
+            # Close progress dialog
+            progress.close()
+
     # ========================================================================
     # TABBED SEGMENT EDITOR METHODS (for Grid view)
     # ========================================================================
@@ -38673,95 +39752,32 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     
                     self.table.clearSelection()
                     self.table.setCurrentCell(row, 3)  # Column 3 = Target (widget column)
+                    self.table.selectRow(row)  # v1.9.182: Ensure row is visually selected
+                    # Ensure the row is visible by scrolling to it
+                    self.table.scrollToItem(self.table.item(row, 0), QTableWidget.ScrollHint.PositionAtCenter)
                     self.log(f"⏭️ Moved to next unconfirmed segment {seg.id}")
-                    
-                    # Auto-confirm 100% TM matches if setting is enabled
-                    if self.auto_confirm_100_percent_matches:
-                        # Get TM matches for this segment
-                        exact_match = None
-                        if self.enable_tm_matching and hasattr(self, 'db_manager') and self.db_manager:
-                            # Get activated TM IDs from project settings
-                            activated_tm_ids = []
-                            if hasattr(self.current_project, 'tm_settings') and self.current_project.tm_settings:
-                                activated_tm_ids = self.current_project.tm_settings.get('activated_tm_ids', [])
-                            
-                            if activated_tm_ids:
-                                # Use get_exact_match for 100% matches instead of fuzzy search
-                                source_lang = self.current_project.source_lang if hasattr(self.current_project, 'source_lang') else None
-                                target_lang = self.current_project.target_lang if hasattr(self.current_project, 'target_lang') else None
-                                exact_match = self.db_manager.get_exact_match(
-                                    seg.source, 
-                                    tm_ids=activated_tm_ids,
-                                    source_lang=source_lang,
-                                    target_lang=target_lang
-                                )
-                        
-                        # Check if there's a 100% match and (target is empty OR overwrite is enabled)
-                        target_is_empty = not seg.target.strip()
-                        can_auto_confirm = target_is_empty or self.auto_confirm_overwrite_existing
-                        
-                        if exact_match and can_auto_confirm:
-                            match_target = exact_match.get('target_text', '')
-                            overwrite_note = " (overwriting existing)" if not target_is_empty else " (empty target)"
-                            self.log(f"🎯 Auto-confirm: Found 100% TM match for segment {seg.id}{overwrite_note}")
-                            
-                            # Insert the match into the target cell
-                            target_widget = self.table.cellWidget(row, 3)
-                            if target_widget and match_target:
-                                target_widget.setPlainText(match_target)
-                                seg.target = match_target
-                                seg.status = 'confirmed'
-                                self.update_status_icon(row, 'confirmed')
-                                self.project_modified = True
-                                
-                                # Save to TM
-                                try:
-                                    self.save_segment_to_activated_tms(seg.source, seg.target)
-                                    self.log(f"💾 Auto-confirmed and saved segment {seg.id} to TM")
-                                except Exception as e:
-                                    self.log(f"⚠️ Error saving auto-confirmed segment to TM: {e}")
-                                
-                                # Continue to the NEXT unconfirmed segment (skip this one)
-                                for next_row in range(row + 1, self.table.rowCount()):
-                                    if next_row < len(self.current_project.segments):
-                                        next_seg = self.current_project.segments[next_row]
-                                        if next_seg.status not in ['confirmed', 'approved']:
-                                            # Check pagination
-                                            if self.table.isRowHidden(next_row):
-                                                if hasattr(self, 'grid_page_size') and hasattr(self, 'grid_current_page'):
-                                                    target_page = next_row // self.grid_page_size
-                                                    if target_page != self.grid_current_page:
-                                                        self.grid_current_page = target_page
-                                                        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}")
-                                            next_target_widget = self.table.cellWidget(next_row, 3)
-                                            if next_target_widget:
-                                                next_target_widget.setFocus()
-                                                next_target_widget.moveCursor(QTextCursor.MoveOperation.End)
-                                            
-                                            # Recursively check if this next segment also has a 100% match
-                                            self.confirm_and_next_unconfirmed()
-                                            return
-                                
-                                # No more unconfirmed segments after this one
-                                self.log("✅ No more unconfirmed segments after auto-confirm")
-                                # Update status bar after auto-confirming
-                                self.update_progress_stats()
-                                return
-                    
-                    # Get the target cell widget and set focus to it (normal behavior without auto-confirm)
+
+                    # v1.9.182: Explicitly update termview (don't rely on deferred signal)
+                    self._update_termview_for_segment(seg)
+
+                    # v1.9.182: Explicitly schedule TM lookup (don't rely on deferred signal)
+                    if self.enable_tm_matching:
+                        find_replace_active = getattr(self, 'find_replace_active', False)
+                        if not find_replace_active:
+                            self._schedule_mt_and_llm_matches(seg, [])
+
+                    # Get the target cell widget and set focus to it IMMEDIATELY
+                    # (moved BEFORE auto-confirm check for instant responsiveness)
                     target_widget = self.table.cellWidget(row, 3)
                     if target_widget:
                         target_widget.setFocus()
                         # Move cursor to end of text
                         target_widget.moveCursor(QTextCursor.MoveOperation.End)
+
+                    # v1.9.182: Defer auto-confirm check to not block navigation
+                    # The TM lookup is slow - do it asynchronously after navigation completes
+                    if self.auto_confirm_100_percent_matches:
+                        QTimer.singleShot(50, lambda r=row, s=seg: self._check_auto_confirm_100_percent(r, s))
                     return
         
         # No more unconfirmed segments, just go to next
@@ -38783,14 +39799,106 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             
             self.table.clearSelection()
             self.table.setCurrentCell(next_row, 3)  # Column 3 = Target (widget column)
+            self.table.selectRow(next_row)  # v1.9.182: Ensure row is visually selected
+            # Ensure the row is visible by scrolling to it
+            self.table.scrollToItem(self.table.item(next_row, 0), QTableWidget.ScrollHint.PositionAtCenter)
             self.log(f"⏭️ Moved to next segment (all remaining confirmed)")
+
+            # v1.9.182: Explicitly update termview (don't rely on deferred signal)
+            if next_row < len(self.current_project.segments):
+                next_seg = self.current_project.segments[next_row]
+                self._update_termview_for_segment(next_seg)
+
+                # v1.9.182: Explicitly schedule TM lookup (don't rely on deferred signal)
+                if self.enable_tm_matching:
+                    find_replace_active = getattr(self, 'find_replace_active', False)
+                    if not find_replace_active:
+                        self._schedule_mt_and_llm_matches(next_seg, [])
+
             # Get the target cell widget and set focus to it
             target_widget = self.table.cellWidget(next_row, 3)
             if target_widget:
                 target_widget.setFocus()
                 # Move cursor to end of text
                 target_widget.moveCursor(QTextCursor.MoveOperation.End)
-    
+
+    def _check_auto_confirm_100_percent(self, row: int, seg):
+        """
+        v1.9.182: Deferred auto-confirm check for 100% TM matches.
+
+        This is called asynchronously after Ctrl+Enter navigation to avoid blocking
+        the UI thread with slow TM database queries.
+        """
+        try:
+            # Verify we're still on the same segment (user may have navigated away)
+            current_row = self.table.currentRow() if hasattr(self, 'table') and self.table else -1
+            if current_row != row:
+                return  # User has moved - don't auto-confirm wrong segment
+
+            if not self.enable_tm_matching or not hasattr(self, 'db_manager') or not self.db_manager:
+                return
+
+            # Get activated TM IDs from project settings
+            activated_tm_ids = []
+            if hasattr(self.current_project, 'tm_settings') and self.current_project.tm_settings:
+                activated_tm_ids = self.current_project.tm_settings.get('activated_tm_ids', [])
+
+            if not activated_tm_ids:
+                return
+
+            # Use get_exact_match for 100% matches
+            source_lang = self.current_project.source_lang if hasattr(self.current_project, 'source_lang') else None
+            target_lang = self.current_project.target_lang if hasattr(self.current_project, 'target_lang') else None
+            exact_match = self.db_manager.get_exact_match(
+                seg.source,
+                tm_ids=activated_tm_ids,
+                source_lang=source_lang,
+                target_lang=target_lang
+            )
+
+            if not exact_match:
+                return
+
+            # Check if there's a 100% match and (target is empty OR overwrite is enabled)
+            target_is_empty = not seg.target.strip()
+            can_auto_confirm = target_is_empty or self.auto_confirm_overwrite_existing
+
+            if not can_auto_confirm:
+                return
+
+            # Verify AGAIN that we're still on the same segment (TM query may have taken time)
+            current_row = self.table.currentRow() if hasattr(self, 'table') and self.table else -1
+            if current_row != row:
+                return  # User has moved during TM lookup
+
+            match_target = exact_match.get('target_text', '')
+            if not match_target:
+                return
+
+            overwrite_note = " (overwriting existing)" if not target_is_empty else " (empty target)"
+            self.log(f"🎯 Auto-confirm: Found 100% TM match for segment {seg.id}{overwrite_note}")
+
+            # Insert the match into the target cell
+            target_widget = self.table.cellWidget(row, 3)
+            if target_widget:
+                target_widget.setPlainText(match_target)
+                seg.target = match_target
+                seg.status = 'confirmed'
+                self.update_status_icon(row, 'confirmed')
+                self.project_modified = True
+
+                # Save to TM
+                try:
+                    self.save_segment_to_activated_tms(seg.source, seg.target)
+                    self.log(f"💾 Auto-confirmed and saved segment {seg.id} to TM")
+                except Exception as e:
+                    self.log(f"⚠️ Error saving auto-confirmed segment to TM: {e}")
+
+                # Continue to the NEXT unconfirmed segment (skip this one)
+                self.confirm_and_next_unconfirmed()
+        except Exception as e:
+            self.log(f"⚠️ Error in auto-confirm check: {e}")
+
     def confirm_selected_or_next(self):
         """Smart confirm: if multiple segments selected, confirm all; otherwise confirm and go to next.
         
@@ -39179,32 +40287,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
 
     def _toggle_tag_view_via_shortcut(self):
         """Toggle tag view using keyboard shortcut (Ctrl+Alt+T)"""
-        if hasattr(self, 'tag_view_btn'):
-            # Toggle the button state (which triggers toggle_tag_view)
-            new_state = not self.tag_view_btn.isChecked()
-            self.tag_view_btn.setChecked(new_state)
-            self.toggle_tag_view(new_state, self.tag_view_btn)
+        if hasattr(self, 'wysiwyg_btn') and hasattr(self, 'tags_btn'):
+            # Toggle between the two modes
+            new_state = not self.show_tags
+            self.toggle_tag_view(new_state, None)
 
     def _enable_tag_view_after_import(self):
         """Auto-enable Tag View after importing a document with formatting tags"""
-        if hasattr(self, 'tag_view_btn'):
-            self.tag_view_btn.setChecked(True)
-            self.toggle_tag_view(True, self.tag_view_btn)
+        if hasattr(self, 'tags_btn'):
+            self.toggle_tag_view(True, None)
             self.log("🏷️ Tag View auto-enabled (formatting tags detected in import)")
 
     def toggle_tag_view(self, checked: bool, button: QPushButton = None):
         """Toggle between Tag View (showing raw tags) and WYSIWYG View (formatted display)"""
         self.show_tags = checked
-        
-        # Update button text
-        if button:
+
+        # Update segmented control buttons if they exist
+        if hasattr(self, 'wysiwyg_btn') and hasattr(self, 'tags_btn'):
             if checked:
-                button.setText("🏷️ Tags ON")
+                self.tags_btn.setChecked(True)
             else:
-                button.setText("🏷️ Tags OFF")
-        
+                self.wysiwyg_btn.setChecked(True)
+
         self.log(f"{'🏷️ Tag View ENABLED - showing raw tags' if checked else '✨ WYSIWYG View ENABLED - showing formatted text'}")
-        
+
         # Refresh the grid to update display
         if hasattr(self, 'table') and self.current_project:
             self._refresh_grid_display_mode()
@@ -40577,45 +41683,12 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             event.accept()
     
     def _cleanup_web_views(self):
-        """Clean up WebEngine views to prevent 'Release of profile requested' warning"""
-        try:
-            # Close any SuperBrowser tabs
-            if hasattr(self, 'superbrowser_tabs'):
-                for tab in self.superbrowser_tabs.values():
-                    try:
-                        if hasattr(tab, 'web_view'):
-                            # Stop any loading/rendering
-                            tab.web_view.stop()
-                            # Clear page to release resources
-                            tab.web_view.setPage(None)
-                            tab.web_view.setUrl(QUrl('about:blank'))
-                            tab.web_view.deleteLater()
-                    except:
-                        pass
-            
-            # Close Superlookup web views (from Web Resources tab)
-            if hasattr(self, 'web_views'):
-                for resource_id, web_view in list(self.web_views.items()):
-                    try:
-                        web_view.stop()
-                        web_view.setPage(None)
-                        web_view.setUrl(QUrl('about:blank'))
-                        web_view.deleteLater()
-                    except:
-                        pass
-                self.web_views.clear()
-            
-            # Process events multiple times to ensure cleanup completes
-            from PyQt6.QtWidgets import QApplication
-            from PyQt6.QtCore import QUrl
-            for _ in range(3):
-                QApplication.processEvents()
-                
-            # Small delay to allow Qt to finish cleanup
-            import time
-            time.sleep(0.1)
-        except:
-            pass
+        """Clean up WebEngine views - DISABLED to prevent crash"""
+        # WebEngine cleanup has been disabled because it was causing Python crashes
+        # on program exit. Qt will handle WebEngine cleanup automatically, though
+        # you may see a "Release of profile requested" warning which is harmless.
+        print("[WebEngine Cleanup] Skipping manual cleanup - letting Qt handle it")
+        pass
     
     def _close_detached_log_windows(self):
         """Close all detached log windows when main window closes"""
@@ -43160,23 +44233,58 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """Call DeepL API"""
         try:
             import deepl
-            
+
             if not api_key:
                 api_keys = self.load_api_keys()
                 api_key = api_keys.get("deepl")
-            
+
             if not api_key:
                 return "[DeepL requires API key]"
-            
+
             translator = deepl.Translator(api_key)
-            
-            # Convert language codes (DeepL uses uppercase)
+
+            # Convert source language code (DeepL uses uppercase, no variant needed for source)
             src_code = source_lang.split('-')[0].split('_')[0].upper()
-            tgt_code = target_lang.split('-')[0].split('_')[0].upper()
-            
+
+            # Convert target language code - DeepL requires variants for some languages
+            # Handle full codes like "en-US", "en-GB", "pt-BR", "pt-PT"
+            tgt_upper = target_lang.upper().replace('_', '-')
+
+            # DeepL target language mapping - some require specific variants
+            deepl_target_map = {
+                # English variants (EN alone is deprecated)
+                'EN': 'EN-US',      # Default to US English
+                'EN-US': 'EN-US',
+                'EN-GB': 'EN-GB',
+                'EN-AU': 'EN-GB',   # Map Australian to British
+                'EN-CA': 'EN-US',   # Map Canadian to US
+                # Portuguese variants
+                'PT': 'PT-PT',      # Default to European Portuguese
+                'PT-PT': 'PT-PT',
+                'PT-BR': 'PT-BR',
+                # Chinese variants
+                'ZH': 'ZH-HANS',    # Default to Simplified
+                'ZH-CN': 'ZH-HANS',
+                'ZH-TW': 'ZH-HANT',
+                'ZH-HANS': 'ZH-HANS',
+                'ZH-HANT': 'ZH-HANT',
+            }
+
+            # Check if full code matches first, then base code
+            if tgt_upper in deepl_target_map:
+                tgt_code = deepl_target_map[tgt_upper]
+            else:
+                # Extract base code and check
+                base_code = tgt_upper.split('-')[0]
+                if base_code in deepl_target_map:
+                    tgt_code = deepl_target_map[base_code]
+                else:
+                    # Use base code as-is for other languages
+                    tgt_code = base_code
+
             result = translator.translate_text(text, source_lang=src_code, target_lang=tgt_code)
             return result.text
-            
+
         except ImportError:
             return "[DeepL requires: pip install deepl]"
         except Exception as e:
@@ -43608,14 +44716,25 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         # Reapply alternating row colors with new theme
         if hasattr(self, 'apply_alternating_row_colors'):
             self.apply_alternating_row_colors()
-        
+
+        # Update navigation arrow colors based on theme
+        if hasattr(self, 'theme_aware_arrows'):
+            is_dark = theme.name == "Dark"
+            arrow_color = "#FFFFFF" if is_dark else "#333333"
+            for arrow in self.theme_aware_arrows:
+                if hasattr(arrow, 'set_color'):
+                    arrow.set_color(arrow_color)
+
         # Refresh segment numbers color
         if hasattr(self, 'table') and self.table:
             # Determine segment number color based on theme
             is_dark_theme = theme.name == "Dark"
             segment_num_color = theme.text if is_dark_theme else "black"
-            
+
             for row in range(self.table.rowCount()):
+                # Keep UI responsive during large grid updates
+                if row % 50 == 0:
+                    QApplication.processEvents()
                 id_item = self.table.item(row, 0)
                 if id_item:
                     # Don't change currently highlighted row (orange background)
@@ -43645,6 +44764,11 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             if hasattr(self.termview_widget, 'apply_theme'):
                 self.termview_widget.apply_theme()
 
+        # Also refresh Match Panel TermView (right panel)
+        if hasattr(self, 'termview_widget_match') and self.termview_widget_match:
+            if hasattr(self.termview_widget_match, 'apply_theme'):
+                self.termview_widget_match.apply_theme()
+
     def show_file_progress_dialog(self):
         """Show File Progress dialog for multi-file projects.
         
@@ -43941,12 +45065,12 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             self._pending_mt_llm_segment = segment
             self._pending_termbase_matches = termbase_matches or []
             
-            # Start debounced timer - only call APIs after user stops clicking for 0.3 seconds
+            # Start debounced timer - only call APIs after user stops navigating
             from PyQt6.QtCore import QTimer
             self._mt_llm_timer = QTimer()
             self._mt_llm_timer.setSingleShot(True)
             self._mt_llm_timer.timeout.connect(lambda: self._execute_mt_llm_lookup())
-            self._mt_llm_timer.start(300)  # Wait 0.3 seconds of inactivity
+            self._mt_llm_timer.start(150)  # Wait 150ms of inactivity before external API calls
                 
         except Exception as e:
             self.log(f"Error scheduling MT/LLM search: {e}")
@@ -43971,7 +45095,21 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """Search for TM, MT and LLM matches - called only after debounce delay"""
         try:
             from modules.translation_results_panel import TranslationMatch
-            
+
+            # v1.9.182: Validate we're still on the same segment before displaying results
+            # This prevents stale results from showing when user navigates quickly
+            current_row = self.table.currentRow() if hasattr(self, 'table') and self.table else -1
+            if current_row >= 0:
+                id_item = self.table.item(current_row, 0)
+                if id_item:
+                    try:
+                        current_segment_id = int(id_item.text())
+                        if current_segment_id != segment.id:
+                            # User has moved to a different segment - abort this lookup
+                            return
+                    except (ValueError, AttributeError):
+                        pass
+
             # Get current project languages for all translation services
             source_lang = getattr(self.current_project, 'source_lang', None) if self.current_project else None
             target_lang = getattr(self.current_project, 'target_lang', None) if self.current_project else None
@@ -44044,6 +45182,22 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     
                     # Show TM matches immediately (progressive loading)
                     if matches_dict["TM"]:
+                        # v1.9.182: Re-validate we're still on same segment before displaying
+                        current_row = self.table.currentRow() if hasattr(self, 'table') and self.table else -1
+                        if current_row >= 0:
+                            id_item = self.table.item(current_row, 0)
+                            if id_item:
+                                try:
+                                    current_segment_id = int(id_item.text())
+                                    if current_segment_id != segment.id:
+                                        # User moved - still cache results but don't display
+                                        with self.translation_matches_cache_lock:
+                                            if segment.id in self.translation_matches_cache:
+                                                self.translation_matches_cache[segment.id]["TM"] = matches_dict["TM"]
+                                        return  # Don't display stale results
+                                except (ValueError, AttributeError):
+                                    pass
+
                         tm_only = {"TM": matches_dict["TM"]}
                         if hasattr(self, 'results_panels') and self.results_panels:
                             for panel in self.results_panels:
@@ -44097,6 +45251,16 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         has_fuzzy_match = any(float(tm.relevance) < 99.5 and float(tm.relevance) >= 50 for tm in matches_dict["TM"])
                         if has_fuzzy_match and not has_100_match:
                             self._play_sound_effect('tm_fuzzy_match')
+
+                    # v1.9.182: Update cache with TM results so subsequent visits are instant
+                    if matches_dict["TM"]:
+                        with self.translation_matches_cache_lock:
+                            if segment.id in self.translation_matches_cache:
+                                # Merge TM results into existing cache entry
+                                self.translation_matches_cache[segment.id]["TM"] = matches_dict["TM"]
+                            else:
+                                # Create new cache entry with TM results
+                                self.translation_matches_cache[segment.id] = matches_dict
                 except Exception as e:
                     self.log(f"Error in delayed TM search: {e}")
             
@@ -44659,7 +45823,7 @@ class SuperlookupTab(QWidget):
         self.main_window = parent  # Store reference to main window for database access
         self.user_data_path = user_data_path  # Store user data path for web cache
         
-        print("[Superlookup] SuperlookupTab.__init__ called")
+        print("[SuperLookup] SuperlookupTab.__init__ called")
         
         # Get theme manager from main window (try parent first, then parent's parent for dialogs)
         self.theme_manager = getattr(parent, 'theme_manager', None)
@@ -44668,16 +45832,16 @@ class SuperlookupTab(QWidget):
             parent_parent = getattr(parent, 'parent', lambda: None)()
             if parent_parent:
                 self.theme_manager = getattr(parent_parent, 'theme_manager', None)
-        print(f"[Superlookup] theme_manager: {self.theme_manager is not None}")
+        print(f"[SuperLookup] theme_manager: {self.theme_manager is not None}")
         
         # Import lookup engine
         try:
             from modules.superlookup import SuperlookupEngine, LookupResult
             self.SuperlookupEngine = SuperlookupEngine
             self.LookupResult = LookupResult
-            print("[Superlookup] Successfully imported SuperlookupEngine")
+            print("[SuperLookup] Successfully imported SuperlookupEngine")
         except ImportError as e:
-            print(f"[Superlookup] IMPORT ERROR: {e}")
+            print(f"[SuperLookup] IMPORT ERROR: {e}")
             QMessageBox.critical(
                 self,
                 "Missing Module",
@@ -44759,7 +45923,7 @@ class SuperlookupTab(QWidget):
         if self.db_manager or self.termbase_mgr:
             self.populate_language_dropdowns()
             self._languages_populated = True
-            print("[Superlookup] Languages populated on first show")
+            print("[SuperLookup] Languages populated on first show")
     
     def init_ui(self):
         """Initialize the UI"""
@@ -44768,7 +45932,7 @@ class SuperlookupTab(QWidget):
         layout.setSpacing(5)  # Reduced from 10 to 5 for consistency
         
         # Header
-        header = QLabel("🔍 Superlookup")
+        header = QLabel("🔍 SuperLookup")
         header.setStyleSheet("font-size: 16pt; font-weight: bold; color: #1976D2;")
         layout.addWidget(header, 0)  # 0 = no stretch, stays compact
         
@@ -45262,7 +46426,7 @@ class SuperlookupTab(QWidget):
                     })
                     
             except Exception as e:
-                print(f"[Superlookup] MT error ({provider_name}): {e}")
+                print(f"[SuperLookup] MT error ({provider_name}): {e}")
                 results.append({
                     'provider': provider_name,
                     'translation': f"[Error: {str(e)}]",
@@ -45353,9 +46517,9 @@ class SuperlookupTab(QWidget):
             self.web_profile = QWebEngineProfile("SuperlookupProfile", self)
             self.web_profile.setPersistentStoragePath(storage_path)
             self.web_profile.setPersistentCookiesPolicy(QWebEngineProfile.PersistentCookiesPolicy.ForcePersistentCookies)
-            print(f"[Superlookup] QWebEngineView available - embedded browser enabled with persistent storage at {storage_path}")
+            print(f"[SuperLookup] QWebEngineView available - embedded browser enabled with persistent storage at {storage_path}")
         except ImportError:
-            print("[Superlookup] QWebEngineView not available - external browser only")
+            print("[SuperLookup] QWebEngineView not available - external browser only")
             self.QWebEngineView = None
             self.QWebEngineProfile = None
         
@@ -45807,7 +46971,7 @@ class SuperlookupTab(QWidget):
         self.web_view_stack.addWidget(web_view)
         self.web_views[resource['id']] = web_view
         
-        print(f"[Superlookup] Created web view for {resource['name']} (lazy load)")
+        print(f"[SuperLookup] Created web view for {resource['name']} (lazy load)")
     
     def _get_web_view_index(self, resource_id):
         """Get the stack index for a web view by resource ID"""
@@ -45824,7 +46988,7 @@ class SuperlookupTab(QWidget):
         
         self._update_web_view_for_mode()
         self._show_web_welcome_message()
-        print(f"[Superlookup] Web browser mode changed to: {self.web_browser_mode}")
+        print(f"[SuperLookup] Web browser mode changed to: {self.web_browser_mode}")
     
     def _update_web_view_for_mode(self):
         """Update the view stack based on current mode"""
@@ -46457,11 +47621,11 @@ class SuperlookupTab(QWidget):
         if index == 2:
             # Initialize Supermemory when tab is first viewed
             if not self.supermemory_engine:
-                print("[Superlookup] Supermemory tab viewed - initializing engine")
+                print("[SuperLookup] Supermemory tab viewed - initializing engine")
                 self.init_supermemory()
         # Settings tab is at index 5
         elif index == 5:
-            print("[Superlookup] Settings tab viewed - refreshing resource lists")
+            print("[SuperLookup] Settings tab viewed - refreshing resource lists")
             self.refresh_tm_list()
             self.refresh_termbase_list()
             self.populate_language_dropdowns()
@@ -46469,19 +47633,19 @@ class SuperlookupTab(QWidget):
     def on_tm_search_toggled(self, state):
         """Handle TM search checkbox toggle"""
         self.search_tm_enabled = (state == Qt.CheckState.Checked.value)
-        print(f"[Superlookup] TM search {'enabled' if self.search_tm_enabled else 'disabled'}")
+        print(f"[SuperLookup] TM search {'enabled' if self.search_tm_enabled else 'disabled'}")
     
     def on_termbase_search_toggled(self, state):
         """Handle termbase search checkbox toggle"""
         self.search_termbase_enabled = (state == Qt.CheckState.Checked.value)
-        print(f"[Superlookup] Termbase search {'enabled' if self.search_termbase_enabled else 'disabled'}")
+        print(f"[SuperLookup] Termbase search {'enabled' if self.search_termbase_enabled else 'disabled'}")
     
     def _on_web_resource_checkbox_changed(self, index: int, state: int):
         """Handle web resource checkbox change - show/hide corresponding sidebar button"""
         is_checked = (state == Qt.CheckState.Checked.value)
         if hasattr(self, 'web_resource_buttons') and index < len(self.web_resource_buttons):
             self.web_resource_buttons[index].setVisible(is_checked)
-            print(f"[Superlookup] Web resource {index} {'shown' if is_checked else 'hidden'}")
+            print(f"[SuperLookup] Web resource {index} {'shown' if is_checked else 'hidden'}")
             
             # If the hidden resource was selected, select the first visible one
             if not is_checked and hasattr(self, 'current_web_resource_index') and self.current_web_resource_index == index:
@@ -46499,18 +47663,18 @@ class SuperlookupTab(QWidget):
             checkbox.deleteLater()
         self.tm_checkboxes.clear()
         
-        print(f"[Superlookup] refresh_tm_list called")
-        print(f"[Superlookup]   main_window exists: {self.main_window is not None}")
+        print(f"[SuperLookup] refresh_tm_list called")
+        print(f"[SuperLookup]   main_window exists: {self.main_window is not None}")
         
         # Get TMs from main window's database
         if self.main_window and hasattr(self.main_window, 'db_manager') and self.main_window.db_manager:
             try:
-                print(f"[Superlookup]   db_manager found, querying TMs...")
+                print(f"[SuperLookup]   db_manager found, querying TMs...")
                 cursor = self.main_window.db_manager.cursor
                 cursor.execute("SELECT id, name, tm_id FROM translation_memories ORDER BY name")
                 tms = cursor.fetchall()
                 
-                print(f"[Superlookup]   Query returned {len(tms)} TMs")
+                print(f"[SuperLookup]   Query returned {len(tms)} TMs")
                 
                 for db_id, tm_name, tm_id_str in tms:
                     checkbox = CheckmarkCheckBox(f"{tm_name} (ID: {db_id})")
@@ -46521,13 +47685,13 @@ class SuperlookupTab(QWidget):
                     # Insert before the stretch at the end
                     self.tm_scroll_layout.insertWidget(len(self.tm_checkboxes) - 1, checkbox)
                 
-                print(f"[Superlookup] ✓ Loaded {len(tms)} TMs")
+                print(f"[SuperLookup] ✓ Loaded {len(tms)} TMs")
             except Exception as e:
-                print(f"[Superlookup] ✗ Error loading TMs: {e}")
+                print(f"[SuperLookup] ✗ Error loading TMs: {e}")
                 import traceback
                 traceback.print_exc()
         else:
-            print(f"[Superlookup]   db_manager not available")
+            print(f"[SuperLookup]   db_manager not available")
             # Add placeholder label
             placeholder = QLabel("No database connection - TMs unavailable")
             placeholder.setStyleSheet("color: #999; font-style: italic;")
@@ -46541,16 +47705,16 @@ class SuperlookupTab(QWidget):
             checkbox.deleteLater()
         self.tb_checkboxes.clear()
         
-        print(f"[Superlookup] refresh_termbase_list called")
-        print(f"[Superlookup]   main_window exists: {self.main_window is not None}")
+        print(f"[SuperLookup] refresh_termbase_list called")
+        print(f"[SuperLookup]   main_window exists: {self.main_window is not None}")
         
         # Try termbase_mgr first (preferred method)
         if self.main_window and hasattr(self.main_window, 'termbase_mgr') and self.main_window.termbase_mgr:
             try:
-                print(f"[Superlookup]   termbase_mgr found, querying termbases...")
+                print(f"[SuperLookup]   termbase_mgr found, querying termbases...")
                 termbases = self.main_window.termbase_mgr.get_all_termbases()
                 
-                print(f"[Superlookup]   get_all_termbases() returned {len(termbases)} termbases")
+                print(f"[SuperLookup]   get_all_termbases() returned {len(termbases)} termbases")
                 
                 for tb in termbases:
                     tb_id = tb.get('id')
@@ -46562,22 +47726,22 @@ class SuperlookupTab(QWidget):
                     # Insert before the stretch at the end
                     self.tb_scroll_layout.insertWidget(len(self.tb_checkboxes) - 1, checkbox)
                 
-                print(f"[Superlookup] ✓ Loaded {len(termbases)} termbases via termbase_mgr")
+                print(f"[SuperLookup] ✓ Loaded {len(termbases)} termbases via termbase_mgr")
                 return
             except Exception as e:
-                print(f"[Superlookup] ✗ Error loading termbases via termbase_mgr: {e}")
+                print(f"[SuperLookup] ✗ Error loading termbases via termbase_mgr: {e}")
                 import traceback
                 traceback.print_exc()
         
         # Fallback to direct database query
         if self.main_window and hasattr(self.main_window, 'db_manager') and self.main_window.db_manager:
             try:
-                print(f"[Superlookup]   db_manager found, querying termbases...")
+                print(f"[SuperLookup]   db_manager found, querying termbases...")
                 cursor = self.main_window.db_manager.cursor
                 cursor.execute("SELECT id, name FROM termbases ORDER BY name")
                 termbases = cursor.fetchall()
                 
-                print(f"[Superlookup]   Query returned {len(termbases)} termbases")
+                print(f"[SuperLookup]   Query returned {len(termbases)} termbases")
                 
                 for tb_id, tb_name in termbases:
                     checkbox = CheckmarkCheckBox(f"{tb_name} (ID: {tb_id})")
@@ -46587,13 +47751,13 @@ class SuperlookupTab(QWidget):
                     # Insert before the stretch at the end
                     self.tb_scroll_layout.insertWidget(len(self.tb_checkboxes) - 1, checkbox)
                 
-                print(f"[Superlookup] ✓ Loaded {len(termbases)} termbases via db_manager")
+                print(f"[SuperLookup] ✓ Loaded {len(termbases)} termbases via db_manager")
             except Exception as e:
-                print(f"[Superlookup] ✗ Error loading termbases via db_manager: {e}")
+                print(f"[SuperLookup] ✗ Error loading termbases via db_manager: {e}")
                 import traceback
                 traceback.print_exc()
         else:
-            print(f"[Superlookup]   Neither termbase_mgr nor db_manager available")
+            print(f"[SuperLookup]   Neither termbase_mgr nor db_manager available")
             # Add placeholder label
             placeholder = QLabel("No database connection - Glossaries unavailable")
             placeholder.setStyleSheet("color: #999; font-style: italic;")
@@ -46675,10 +47839,8 @@ class SuperlookupTab(QWidget):
                 for row in db_manager.cursor.fetchall():
                     if row[0]:
                         all_languages.add(row[0])
-            except Exception as e:
-                print(f"[DEBUG] Error getting languages from TMs: {e}")
-        else:
-            print(f"[DEBUG] No db_manager available for language population")
+            except Exception:
+                pass  # Silent failure for language population
         
         # Get languages from termbases
         if termbase_mgr:
@@ -46689,8 +47851,8 @@ class SuperlookupTab(QWidget):
                         all_languages.add(tb['source_lang'])
                     if tb.get('target_lang'):
                         all_languages.add(tb['target_lang'])
-            except Exception as e:
-                print(f"[DEBUG] Error getting languages from termbases: {e}")
+            except Exception:
+                pass  # Silent failure for language population
         
         # Group languages by their base language name
         # E.g., "en", "en-US", "en-GB", "English" all map to "English"
@@ -46720,8 +47882,6 @@ class SuperlookupTab(QWidget):
             # Store variants list as the data for this item
             self.lang_from_combo.addItem(base_name, variants)
             self.lang_to_combo.addItem(base_name, variants)
-        
-        print(f"[DEBUG] Populated language dropdowns with {len(sorted_base_langs)} base languages (from {len(all_languages)} variants)")
     
     def _get_base_language_name(self, lang_code):
         """Extract the base language name from any language code or name.
@@ -46908,37 +48068,20 @@ class SuperlookupTab(QWidget):
         selected_tm_ids = self.get_selected_tm_ids()
         search_direction = self.get_search_direction()
         from_lang, to_lang = self.get_language_filters()
-        
-        # Write language info to debug file
-        with open('superlookup_debug.txt', 'a') as f:
-            f.write(f"Language filters: from_lang='{from_lang}', to_lang='{to_lang}'\\n")
-            f.write(f"Search direction: {search_direction}\\n")
-        
-        print(f"[DEBUG] Superlookup: Selected TM IDs: {selected_tm_ids}, direction: {search_direction}", flush=True)
-        print(f"[DEBUG] Superlookup: Language filters: from={from_lang}, to={to_lang}", flush=True)
-        print(f"[DEBUG] Superlookup: tm_database = {self.tm_database}", flush=True)
+
         if self.engine:
             self.engine.set_enabled_tm_ids(selected_tm_ids if selected_tm_ids else None)
         
         # Perform TM lookup with direction and language filters
         tm_results = []
         if self.tm_database:
-            print(f"[DEBUG] Superlookup: Searching TM for '{text[:50]}...'", flush=True)
-            tm_results = self.engine.search_tm(text, direction=search_direction, 
+            tm_results = self.engine.search_tm(text, direction=search_direction,
                                                 source_lang=from_lang, target_lang=to_lang)
-            print(f"[DEBUG] Superlookup: Got {len(tm_results)} TM results", flush=True)
-        else:
-            print(f"[DEBUG] Superlookup: tm_database is None, skipping TM search!", flush=True)
-        
+
         # Perform termbase lookup (search Supervertaler termbases directly)
-        print(f"[DEBUG] About to call search_termbases with from_lang='{from_lang}', to_lang='{to_lang}'", flush=True)
         try:
             termbase_results = self.search_termbases(text, source_lang=from_lang, target_lang=to_lang)
-            print(f"[DEBUG] search_termbases returned {len(termbase_results)} results", flush=True)
-        except Exception as e:
-            print(f"[DEBUG] ERROR in search_termbases: {e}", flush=True)
-            import traceback
-            traceback.print_exc()
+        except Exception:
             termbase_results = []
         
         # Perform Supermemory semantic search
@@ -47425,7 +48568,7 @@ class SuperlookupTab(QWidget):
                 self.status_label.setText(f"Navigated to glossary entry: {source_term}")
             
         except Exception as e:
-            print(f"[Superlookup] Error navigating to glossary: {e}")
+            print(f"[SuperLookup] Error navigating to glossary: {e}")
             self.status_label.setText(f"Error navigating to glossary: {e}")
     
     def _select_first_term_in_table(self, main):
@@ -47439,7 +48582,7 @@ class SuperlookupTab(QWidget):
                     if item:
                         table.scrollToItem(item)
         except Exception as e:
-            print(f"[Superlookup] Error selecting term: {e}")
+            print(f"[SuperLookup] Error selecting term: {e}")
 
     def display_mt_results(self, results):
         """Display MT results in the table"""
@@ -47974,7 +49117,7 @@ class SuperlookupTab(QWidget):
         if self.main_window and hasattr(self.main_window, 'general_settings'):
             saved_path = self.main_window.general_settings.get('autohotkey_path', '')
             if saved_path and os.path.exists(saved_path):
-                print(f"[Superlookup] Using saved AutoHotkey path: {saved_path}")
+                print(f"[SuperLookup] Using saved AutoHotkey path: {saved_path}")
                 return saved_path, 'saved'
         
         # Standard installation paths
@@ -47992,7 +49135,7 @@ class SuperlookupTab(QWidget):
         
         for path in ahk_paths:
             if os.path.exists(path):
-                print(f"[Superlookup] Detected AutoHotkey at: {path}")
+                print(f"[SuperLookup] Detected AutoHotkey at: {path}")
                 return path, 'detected'
         
         return None, None
@@ -48119,7 +49262,7 @@ class SuperlookupTab(QWidget):
             if self.main_window and hasattr(self.main_window, 'general_settings'):
                 self.main_window.general_settings['autohotkey_path'] = file_path
                 self.main_window.save_general_settings()
-                print(f"[Superlookup] Saved AutoHotkey path: {file_path}")
+                print(f"[SuperLookup] Saved AutoHotkey path: {file_path}")
             
             self._ahk_setup_status.setText(f"✓ Saved: {file_path}\n\nRestart Supervertaler to use this path.")
             
@@ -48140,11 +49283,11 @@ class SuperlookupTab(QWidget):
         Note: AutoHotkey is Windows-only, so skip on Linux/Mac.
         """
         global _ahk_process
-        print("[Superlookup] register_global_hotkey called")
+        print("[SuperLookup] register_global_hotkey called")
         
         # AutoHotkey is Windows-only - skip on other platforms
         if sys.platform != 'win32':
-            print("[Superlookup] Skipping AutoHotkey registration (not Windows)")
+            print("[SuperLookup] Skipping AutoHotkey registration (not Windows)")
             self.hotkey_registered = False
             return
         
@@ -48158,24 +49301,24 @@ class SuperlookupTab(QWidget):
         """
         try:
             from ahk import AHK
-            print("[Superlookup] ahk library available, attempting to use it...")
+            print("[SuperLookup] ahk library available, attempting to use it...")
             
             # Find AutoHotkey executable using shared function
             ahk_exe, source = self._find_autohotkey_executable()
             
             # Create AHK instance (with executable path if found)
             if ahk_exe:
-                print(f"[Superlookup] Using AutoHotkey at: {ahk_exe} (source: {source})")
+                print(f"[SuperLookup] Using AutoHotkey at: {ahk_exe} (source: {source})")
                 self._ahk = AHK(executable_path=ahk_exe)
             else:
                 # Let it try to find AHK on PATH (may fail)
                 self._ahk = AHK()
-            print(f"[Superlookup] AHK instance created: {self._ahk}")
+            print(f"[SuperLookup] AHK instance created: {self._ahk}")
             
             # Define hotkey callback
             def on_hotkey():
                 """Called when Ctrl+Alt+L is pressed"""
-                print("[Superlookup] Hotkey triggered via ahk library!")
+                print("[SuperLookup] Hotkey triggered via ahk library!")
                 try:
                     # Copy selection to clipboard
                     self._ahk.send('^c')  # Ctrl+C
@@ -48188,7 +49331,7 @@ class SuperlookupTab(QWidget):
                     try:
                         self._ahk.win_activate('Supervertaler')
                     except Exception as e:
-                        print(f"[Superlookup] win_activate error (non-critical): {e}")
+                        print(f"[SuperLookup] win_activate error (non-critical): {e}")
                     
                     # Trigger lookup in main thread
                     if text:
@@ -48196,22 +49339,22 @@ class SuperlookupTab(QWidget):
                         QTimer.singleShot(0, lambda: self.on_ahk_capture(text))
                         
                 except Exception as e:
-                    print(f"[Superlookup] Error in hotkey callback: {e}")
+                    print(f"[SuperLookup] Error in hotkey callback: {e}")
             
             # Register the hotkey
             self._ahk.add_hotkey('^!l', callback=on_hotkey)  # Ctrl+Alt+L
             self._ahk.start_hotkeys()
             
-            print("[Superlookup] ✓ Hotkey registered via ahk library: Ctrl+Alt+L")
+            print("[SuperLookup] ✓ Hotkey registered via ahk library: Ctrl+Alt+L")
             self.hotkey_registered = True
             self._using_ahk_library = True
             return True
             
         except ImportError:
-            print("[Superlookup] ahk library not installed (pip install ahk)")
+            print("[SuperLookup] ahk library not installed (pip install ahk)")
             return False
         except Exception as e:
-            print(f"[Superlookup] ahk library method failed: {e}")
+            print(f"[SuperLookup] ahk library method failed: {e}")
             # Clean up on failure
             if hasattr(self, '_ahk'):
                 try:
@@ -48292,11 +49435,13 @@ class SuperlookupTab(QWidget):
             self.hotkey_registered = False
     
     def start_file_watcher(self):
-        """Watch for signal file from AHK"""
+        """Watch for signal files from AHK (Superlookup and MT Quick Lookup)"""
         self.signal_file = Path(__file__).parent / "lookup_signal.txt"
         self.capture_file = Path(__file__).parent / "temp_capture.txt"
-        
-        print(f"[Superlookup] File watcher started, watching: {self.signal_file}")
+        self.mt_lookup_signal_file = Path(__file__).parent / "mt_lookup_signal.txt"
+
+        print(f"[SuperLookup] File watcher started, watching: {self.signal_file}")
+        print(f"[QuickTrans] File watcher started, watching: {self.mt_lookup_signal_file}")
         
         # Create timer to check for signal file
         self.file_check_timer = QTimer()
@@ -48305,27 +49450,57 @@ class SuperlookupTab(QWidget):
     
     def check_for_signal(self):
         """Check if AHK wrote a signal file"""
+        # Check for Superlookup signal
         if self.signal_file.exists():
-            print(f"[Superlookup] Signal file detected!")
+            print(f"[SuperLookup] Signal file detected!")
             try:
                 # Delete signal file
                 self.signal_file.unlink()
-                print(f"[Superlookup] Signal file deleted")
-                
+                print(f"[SuperLookup] Signal file deleted")
+
                 # Get text from clipboard (AHK already copied it)
                 time.sleep(0.1)  # Give clipboard a moment
                 text = pyperclip.paste()
-                
+
                 # Trigger lookup
                 if text:
                     self.on_ahk_capture(text)
             except Exception as e:
-                print(f"[Superlookup] Error reading capture: {e}")
+                print(f"[SuperLookup] Error reading capture: {e}")
+
+        # Check for MT Quick Lookup signal
+        if hasattr(self, 'mt_lookup_signal_file') and self.mt_lookup_signal_file.exists():
+            print(f"[QuickTrans] Signal file detected!")
+            try:
+                # Small delay to let AHK finish writing/close the file
+                time.sleep(0.05)
+
+                # Delete signal file with retry for file lock
+                for attempt in range(3):
+                    try:
+                        self.mt_lookup_signal_file.unlink()
+                        print(f"[QuickTrans] Signal file deleted")
+                        break
+                    except PermissionError:
+                        if attempt < 2:
+                            time.sleep(0.05)
+                        else:
+                            raise
+
+                # Get text from clipboard (AHK already copied it)
+                time.sleep(0.1)  # Give clipboard a moment
+                text = pyperclip.paste()
+
+                # Trigger MT Quick Lookup
+                if text:
+                    self.on_ahk_mt_lookup_capture(text)
+            except Exception as e:
+                print(f"[QuickTrans] Error reading capture: {e}")
     
     def on_ahk_capture(self, text):
         """Handle text captured by AHK"""
         try:
-            print(f"[Superlookup] on_ahk_capture called with text: {text[:50]}...")
+            print(f"[SuperLookup] on_ahk_capture called with text: {text[:50]}...")
             
             # Bring Supervertaler to foreground
             main_window = self.window()
@@ -48355,39 +49530,96 @@ class SuperlookupTab(QWidget):
             QTimer.singleShot(250, lambda: self.show_superlookup(text))
             
         except Exception as e:
-            print(f"[Superlookup] Error handling capture: {e}")
-    
+            print(f"[SuperLookup] Error handling capture: {e}")
+
+    def on_ahk_mt_lookup_capture(self, text):
+        """Handle MT Quick Lookup text captured by AHK (Ctrl+Alt+M)"""
+        try:
+            print(f"[QuickTrans] on_ahk_mt_lookup_capture called with text: {text[:50]}...")
+
+            # Show popup directly without bringing Supervertaler to foreground
+            # The popup has WindowStaysOnTopHint so it will appear over any app
+            QTimer.singleShot(100, lambda: self.show_mt_quick_lookup_from_ahk(text))
+
+        except Exception as e:
+            print(f"[QuickTrans] Error handling capture: {e}")
+
+    def show_mt_quick_lookup_from_ahk(self, text):
+        """Show MT Quick Lookup popup with text from AHK capture"""
+        try:
+            print(f"[QuickTrans] show_mt_quick_lookup_from_ahk called with text: {text[:50]}...")
+
+            # Get main window reference for settings access
+            main_window = self.main_window
+            if not main_window:
+                main_window = self.window()
+
+            if not main_window:
+                print("[QuickTrans] ERROR: Could not find main window")
+                return
+
+            # Get language settings
+            source_lang = getattr(main_window, 'source_language', 'English')
+            target_lang = getattr(main_window, 'target_language', 'Dutch')
+
+            # Import and show MT Quick Lookup popup
+            from modules.mt_quick_popup import MTQuickPopup
+
+            # Create popup without Qt parent so it can appear independently over any app
+            # Pass main_window as parent_app for API access
+            popup = MTQuickPopup(
+                parent_app=main_window,
+                source_text=text,
+                source_lang=source_lang,
+                target_lang=target_lang,
+                parent=None  # No Qt parent - allows independent window
+            )
+
+            # Store reference to prevent garbage collection
+            self._ahk_mt_popup = popup
+
+            # Show and ensure it's on top
+            popup.show()
+            popup.raise_()
+            popup.activateWindow()
+            print(f"[QuickTrans] Popup shown for text: {text[:30]}...")
+
+        except Exception as e:
+            print(f"[QuickTrans] Error showing popup: {e}")
+            import traceback
+            traceback.print_exc()
+
     def show_superlookup(self, text):
         """Show Superlookup with pre-filled text"""
         try:
-            print(f"[Superlookup] show_superlookup called with text: {text[:50]}...")
+            print(f"[SuperLookup] show_superlookup called with text: {text[:50]}...")
             
             # Get main window reference
             main_window = self.main_window
             if not main_window:
                 main_window = self.window()
             
-            print(f"[Superlookup] Main window found: {main_window is not None}")
-            print(f"[Superlookup] Main window type: {type(main_window).__name__}")
-            print(f"[Superlookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
+            print(f"[SuperLookup] Main window found: {main_window is not None}")
+            print(f"[SuperLookup] Main window type: {type(main_window).__name__}")
+            print(f"[SuperLookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
             
             # Switch to Tools tab (main_tabs index 3)
             # Tab structure: Grid=0, Resources=1, QuickMenu=2, Tools=3, Settings=4
             if hasattr(main_window, 'main_tabs'):
-                print(f"[Superlookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
+                print(f"[SuperLookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
                 main_window.main_tabs.setCurrentIndex(3)  # Tools tab
-                print(f"[Superlookup] Switched to Tools tab (index 2)")
+                print(f"[SuperLookup] Switched to Tools tab (index 2)")
                 QApplication.processEvents()  # Force GUI update
             else:
-                print(f"[Superlookup] WARNING: Main window has no main_tabs attribute!")
+                print(f"[SuperLookup] WARNING: Main window has no main_tabs attribute!")
             
             # Switch to Superlookup within modules_tabs
             if hasattr(main_window, 'modules_tabs'):
-                print(f"[Superlookup] Current modules_tab index: {main_window.modules_tabs.currentIndex()}")
+                print(f"[SuperLookup] Current modules_tab index: {main_window.modules_tabs.currentIndex()}")
                 for i in range(main_window.modules_tabs.count()):
                     if "Superlookup" in main_window.modules_tabs.tabText(i):
                         main_window.modules_tabs.setCurrentIndex(i)
-                        print(f"[Superlookup] Switched to Superlookup tab (index {i})")
+                        print(f"[SuperLookup] Switched to Superlookup tab (index {i})")
                         QApplication.processEvents()  # Force GUI update
                         break
             
@@ -48395,23 +49627,23 @@ class SuperlookupTab(QWidget):
             QTimer.singleShot(100, lambda: self._fill_and_search(text))
                     
         except Exception as e:
-            print(f"[Superlookup] Error showing lookup: {e}")
+            print(f"[SuperLookup] Error showing lookup: {e}")
     
     def _fill_and_search(self, text):
         """Fill in text and trigger search (called after tab switching completes)"""
         try:
-            print(f"[Superlookup] _fill_and_search called")
+            print(f"[SuperLookup] _fill_and_search called")
             # Fill in text and trigger lookup
             if hasattr(self, 'source_text'):
                 self.source_text.setCurrentText(text)
-                print(f"[Superlookup] Text filled in source_text field")
+                print(f"[SuperLookup] Text filled in source_text field")
                 # Trigger lookup by calling perform_lookup directly
                 self.perform_lookup()
-                print(f"[Superlookup] perform_lookup() called")
+                print(f"[SuperLookup] perform_lookup() called")
             else:
-                print(f"[Superlookup] ERROR: source_text widget not found!")
+                print(f"[SuperLookup] ERROR: source_text widget not found!")
         except Exception as e:
-            print(f"[Superlookup] Error in _fill_and_search: {e}")
+            print(f"[SuperLookup] Error in _fill_and_search: {e}")
             import traceback
             traceback.print_exc()