supervertaler 1.9.181__py3-none-any.whl → 1.9.184__py3-none-any.whl

Supervertaler.py

@@ -32,9 +32,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.181"
+__version__ = "1.9.184"
 __phase__ = "0.9"
-__release_date__ = "2026-01-30"
+__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):
         """
@@ -2739,10 +2731,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
@@ -6224,6 +6221,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 +6240,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 +6370,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
@@ -10335,12 +10344,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")
 
         # Supervoice - Voice Commands & Dictation
         supervoice_tab = self._create_voice_dictation_settings_tab()
@@ -12231,6 +12237,46 @@ class SupervertalerQt(QMainWindow):
             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.
 
@@ -12263,7 +12309,7 @@ class SupervertalerQt(QMainWindow):
             project_target = (self.current_project.target_lang or '').lower()
 
             # Get all termbases and check language pairs
-            all_termbases = self.termbase_mgr.list_termbases()
+            all_termbases = self.termbase_mgr.get_all_termbases()
             has_matching_language = False
 
             for tb in all_termbases:
@@ -12818,6 +12864,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:
@@ -13703,15 +13782,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)
@@ -17040,7 +17120,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"
@@ -19684,7 +19764,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
@@ -22252,7 +22332,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.
@@ -22260,21 +22487,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...")
@@ -22290,96 +22521,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]:
         """
@@ -22579,11 +22774,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:
@@ -22592,9 +22784,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:
@@ -22602,23 +22792,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)
@@ -22700,43 +22886,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}")
@@ -22786,31 +22964,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:
@@ -22985,8 +23141,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):
         """
@@ -28959,6 +29116,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(8, self.default_font_size - 2))
+                id_item.setFont(seg_num_font)
                 self.table.setItem(row, 0, id_item)
                 
                 # Type - show segment type based on style and content
@@ -29041,13 +29201,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(8, self.default_font_size - 2))
+                type_item.setFont(type_font)
+
                 self.table.setItem(row, 1, type_item)
                 
                 # Source - Use read-only QTextEdit widget for easy text selection
@@ -29324,9 +29488,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
@@ -29350,11 +29518,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
@@ -29496,42 +29672,58 @@ 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()
@@ -30460,8 +30652,8 @@ class SupervertalerQt(QMainWindow):
         status_label = QLabel(status_def.icon)
         status_label.setAlignment(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft)
         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"
+        # Smaller red X for "not_started" to match green checkmark visual size
+        font_size = "8px" if segment.status == "not_started" else "13px"
         # Make confirmed checkmark green
         color = "color: #2e7d32;" if segment.status == "confirmed" else ""
         
@@ -30638,7 +30830,7 @@ class SupervertalerQt(QMainWindow):
         
         self.table.setFont(font)
         
-        # Also update header font
+        # Also update header font - same size as grid content, just bold
         header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Bold)
         self.table.horizontalHeader().setFont(header_font)
         
@@ -30970,8 +31162,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()
@@ -31384,7 +31576,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:
@@ -31392,34 +31584,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.
@@ -31679,9 +31872,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):
@@ -31902,15 +32111,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)
@@ -31922,9 +32135,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:
@@ -31938,15 +32149,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)
                         
@@ -34349,18 +34557,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
@@ -34370,7 +34592,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()
@@ -34592,23 +34814,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()):
@@ -34621,44 +34837,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):
         """
@@ -38828,95 +39025,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
@@ -38938,14 +39072,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.
         
@@ -43763,7 +43989,15 @@ 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
@@ -43800,6 +44034,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.
         
@@ -44096,12 +44335,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}")
@@ -44126,7 +44365,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
@@ -44199,6 +44452,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:
@@ -44252,6 +44521,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}")
             
@@ -46830,10 +47109,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:
@@ -46844,8 +47121,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"
@@ -46875,8 +47152,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.
@@ -47063,37 +47338,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