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

Supervertaler.py

@@ -32,9 +32,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.181"
+__version__ = "1.9.183"
 __phase__ = "0.9"
-__release_date__ = "2026-01-30"
+__release_date__ = "2026-01-31"
 __edition__ = "Qt"
 
 import sys
@@ -1659,16 +1659,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 +1673,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 +1690,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 +1699,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 +1824,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):
         """
@@ -6224,6 +6211,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 +6230,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)
@@ -10335,12 +10328,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 +12221,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 +12293,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 +12848,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 +13766,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 +17104,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 +19748,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 +22316,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 +22471,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 +22505,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 +22758,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 +22768,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 +22776,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 +22870,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 +22948,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 +23125,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):
         """
@@ -30970,8 +31111,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 +31525,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 +31533,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 +31821,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 +32060,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 +32084,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 +32098,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 +34506,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 +34541,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 +34763,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 +34786,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 +38974,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 +39021,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.
         
@@ -44096,12 +44271,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 +44301,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 +44388,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 +44457,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 +47045,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 +47057,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 +47088,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 +47274,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