supervertaler 1.9.109__py3-none-any.whl → 1.9.131__py3-none-any.whl

Supervertaler.py

@@ -3,8 +3,8 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.104 (Packaging + docs)
-Release Date: January 14, 2026
+Version: 1.9.123 (QuickMenu now supports generic AI tasks)
+Release Date: January 19, 2026
 Framework: PyQt6
 
 This is the modern edition of Supervertaler using PyQt6 framework.
@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.109"
+__version__ = "1.9.131"
 __phase__ = "0.9"
-__release_date__ = "2026-01-18"
+__release_date__ = "2026-01-19"
 __edition__ = "Qt"
 
 import sys
@@ -123,10 +123,10 @@ try:
         QButtonGroup, QDialogButtonBox, QTabWidget, QGroupBox, QGridLayout, QCheckBox,
         QProgressBar, QProgressDialog, QFormLayout, QTabBar, QPlainTextEdit, QAbstractItemDelegate,
         QFrame, QListWidget, QListWidgetItem, QStackedWidget, QTreeWidget, QTreeWidgetItem,
-        QScrollArea, QSizePolicy, QSlider, QToolButton
+        QScrollArea, QSizePolicy, QSlider, QToolButton, QAbstractItemView
     )
     from PyQt6.QtCore import Qt, QSize, QTimer, pyqtSignal, QObject, QUrl
-    from PyQt6.QtGui import QFont, QAction, QKeySequence, QIcon, QTextOption, QColor, QDesktopServices, QTextCharFormat, QTextCursor, QBrush, QSyntaxHighlighter, QPalette, QTextBlockFormat
+    from PyQt6.QtGui import QFont, QAction, QKeySequence, QIcon, QTextOption, QColor, QDesktopServices, QTextCharFormat, QTextCursor, QBrush, QSyntaxHighlighter, QPalette, QTextBlockFormat, QCursor
     from PyQt6.QtWidgets import QStyleOptionViewItem, QStyle
     from PyQt6.QtCore import QRectF
     from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -170,11 +170,11 @@ def cleanup_ahk_process():
         try:
             _ahk_process.terminate()
             _ahk_process.wait(timeout=1)
-            print("[Superlookup] AHK process terminated on exit")
+            print("[Hotkeys] AHK process terminated on exit")
         except:
             try:
                 _ahk_process.kill()
-                print("[Superlookup] AHK process killed on exit")
+                print("[Hotkeys] AHK process killed on exit")
             except:
                 pass
 
@@ -910,6 +910,7 @@ class _CtrlReturnEventFilter(QObject):
 
         return False
 
+
 class GridTableEventFilter:
     """Mixin to pass keyboard shortcuts from editor to table"""
     pass
@@ -2559,7 +2560,7 @@ class EditableGridTextEditor(QTextEdit):
                     menu.addSeparator()
                 
                 # Add to dictionary action
-                add_to_dict_action = QAction(f"📖 Add '{misspelled_word}' to Dictionary", self)
+                add_to_dict_action = QAction(f"📖 Add '{misspelled_word}' to Dictionary (Alt+D)", self)
                 add_to_dict_action.triggered.connect(
                     lambda checked, w=misspelled_word: self._add_to_dictionary(w)
                 )
@@ -5322,7 +5323,7 @@ class SupervertalerQt(QMainWindow):
             dialog.exec()
             
             # Navigate to Settings → Features tab
-            self.main_tabs.setCurrentIndex(3)  # Settings tab
+            self.main_tabs.setCurrentIndex(4)  # Settings tab
             if hasattr(self, 'settings_tabs'):
                 # Find the Features tab index
                 for i in range(self.settings_tabs.count()):
@@ -5592,6 +5593,11 @@ class SupervertalerQt(QMainWindow):
         self.termview_shortcuts = []
         self._termview_last_key = None  # Track last key for double-tap detection
         self._termview_last_time = 0    # Track timing for double-tap
+        
+        # Double-tap Shift detection for context menu
+        self._shift_last_press_time = 0
+        self._shift_double_tap_threshold = 0.35  # 350ms window
+        
         for i in range(0, 10):  # 0-9
             shortcut_id = f"termview_insert_{i}"
             default_key = f"Alt+{i}"
@@ -5635,6 +5641,9 @@ class SupervertalerQt(QMainWindow):
             self._ctrl_return_event_filter = _CtrlReturnEventFilter(self)
             QApplication.instance().installEventFilter(self._ctrl_return_event_filter)
         
+        # Note: Double-tap Shift for context menu is handled by AutoHotkey (double_shift_menu.ahk)
+        # Qt's event system makes reliable double-tap detection difficult in Python
+        
         # Ctrl+Shift+Enter - Always confirm all selected segments
         create_shortcut("editor_confirm_selected", "Ctrl+Shift+Return", self.confirm_selected_segments)
         
@@ -5668,6 +5677,84 @@ class SupervertalerQt(QMainWindow):
         
         # Ctrl+Shift+2 - Quick add term with Priority 2
         create_shortcut("editor_quick_add_priority_2", "Ctrl+Shift+2", lambda: self._quick_add_term_with_priority(2))
+        
+        # Alt+D - Add word at cursor to dictionary
+        create_shortcut("editor_add_to_dictionary", "Alt+D", self.add_word_to_dictionary_shortcut)
+        
+        # Ctrl+N - Focus Segment Note tab
+        create_shortcut("editor_focus_notes", "Ctrl+N", self.focus_segment_notes)
+        
+        # Alt+K - Open QuickMenu directly
+        create_shortcut("editor_open_quickmenu", "Alt+K", self.open_quickmenu)
+    
+    def focus_segment_notes(self):
+        """Switch to Segment Note tab and focus the notes editor so user can start typing immediately"""
+        if not hasattr(self, 'bottom_tabs'):
+            return
+        
+        # Switch to Segment note tab (index 1)
+        self.bottom_tabs.setCurrentIndex(1)
+        
+        # Focus the notes editor so user can start typing
+        if hasattr(self, 'bottom_notes_edit'):
+            self.bottom_notes_edit.setFocus()
+    
+    def open_quickmenu(self):
+        """Open QuickMenu popup at current cursor position for quick AI prompt selection.
+        
+        User can navigate with arrow keys and press Enter to select a prompt.
+        """
+        try:
+            # Get QuickMenu items from prompt library
+            quickmenu_items = []
+            if hasattr(self, 'prompt_manager_qt') and self.prompt_manager_qt:
+                lib = getattr(self.prompt_manager_qt, 'library', None)
+                if lib and hasattr(lib, 'get_quickmenu_grid_prompts'):
+                    quickmenu_items = lib.get_quickmenu_grid_prompts() or []
+            
+            if not quickmenu_items:
+                self.log("⚠️ No QuickMenu prompts available. Add prompts with 'Show in Supervertaler QuickMenu' enabled.")
+                return
+            
+            # Find the currently focused widget (source or target cell)
+            focus_widget = QApplication.focusWidget()
+            
+            # Build the menu
+            menu = QMenu(self)
+            menu.setTitle("⚡ QuickMenu")
+            
+            for rel_path, label in sorted(quickmenu_items, key=lambda x: (x[1] or x[0]).lower()):
+                prompt_menu = menu.addMenu(label or rel_path)
+                
+                run_show = QAction("▶ Run (show response)…", self)
+                run_show.triggered.connect(
+                    lambda checked=False, p=rel_path, w=focus_widget: self.run_grid_quickmenu_prompt(p, origin_widget=w, behavior="show")
+                )
+                prompt_menu.addAction(run_show)
+                
+                run_replace = QAction("↺ Run and replace target selection", self)
+                run_replace.triggered.connect(
+                    lambda checked=False, p=rel_path, w=focus_widget: self.run_grid_quickmenu_prompt(p, origin_widget=w, behavior="replace")
+                )
+                prompt_menu.addAction(run_replace)
+            
+            # Show menu at cursor position (or center of focused widget)
+            if focus_widget:
+                # Get cursor rectangle if it's a text editor
+                if hasattr(focus_widget, 'cursorRect'):
+                    cursor_rect = focus_widget.cursorRect()
+                    pos = focus_widget.mapToGlobal(cursor_rect.bottomLeft())
+                else:
+                    # Fallback to center of widget
+                    pos = focus_widget.mapToGlobal(focus_widget.rect().center())
+            else:
+                # Fallback to mouse cursor position
+                pos = QCursor.pos()
+            
+            menu.exec(pos)
+            
+        except Exception as e:
+            self.log(f"❌ Error opening QuickMenu: {e}")
     
     def refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
@@ -6085,8 +6172,8 @@ class SupervertalerQt(QMainWindow):
         export_txt_action.triggered.connect(self.export_simple_txt)
         export_menu.addAction(export_txt_action)
         
-        export_ai_action = QAction("🤖 &AI-Readable Format (TXT)...", self)
-        export_ai_action.triggered.connect(self.export_for_ai)
+        export_ai_action = QAction("📄 &AI-Readable Markdown (.md)...", self)
+        export_ai_action.triggered.connect(self.export_bilingual_table_markdown)
         export_ai_action.setToolTip("Export segments in [SEGMENT] format for AI translation/review")
         export_menu.addAction(export_ai_action)
         
@@ -6307,12 +6394,16 @@ class SupervertalerQt(QMainWindow):
         go_resources_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(1) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_resources_action)
         
+        go_prompt_manager_action = QAction("🤖 &Prompt Manager", self)
+        go_prompt_manager_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(2) if hasattr(self, 'main_tabs') else None)
+        nav_menu.addAction(go_prompt_manager_action)
+        
         go_tools_action = QAction("🛠️ &Tools", self)
-        go_tools_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(2) if hasattr(self, 'main_tabs') else None)
+        go_tools_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(3) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_tools_action)
         
         go_settings_action = QAction("⚙️ &Settings", self)
-        go_settings_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(3) if hasattr(self, 'main_tabs') else None)
+        go_settings_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(4) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_settings_action)
         
         view_menu.addSeparator()
@@ -6415,11 +6506,53 @@ class SupervertalerQt(QMainWindow):
         # Tools Menu
         tools_menu = menubar.addMenu("&Tools")
         
-        autofingers_action = QAction("✋ &AutoFingers - CAT Tool Automation...", self)
+        # Tools in same order as Tools tab
+        autofingers_action = QAction("✋ &AutoFingers...", self)
         autofingers_action.setShortcut("Ctrl+Shift+A")
         autofingers_action.triggered.connect(self.show_autofingers)
         tools_menu.addAction(autofingers_action)
         
+        superconverter_action = QAction("🔄 Super&converter...", self)
+        superconverter_action.triggered.connect(lambda: self._navigate_to_tool("Superconverter"))
+        tools_menu.addAction(superconverter_action)
+        
+        pdf_rescue_action = QAction("📄 &PDF Rescue...", self)
+        pdf_rescue_action.triggered.connect(lambda: self._navigate_to_tool("PDF Rescue"))
+        tools_menu.addAction(pdf_rescue_action)
+        
+        superbench_action = QAction("📊 Super&bench...", self)
+        superbench_action.triggered.connect(lambda: self._navigate_to_tool("Superbench"))
+        tools_menu.addAction(superbench_action)
+        
+        superbrowser_action = QAction("🌐 Super&browser...", self)
+        superbrowser_action.triggered.connect(lambda: self._navigate_to_tool("Superbrowser"))
+        tools_menu.addAction(superbrowser_action)
+        
+        supercleaner_action = QAction("🧹 Supercleaner...", self)
+        supercleaner_action.triggered.connect(lambda: self._navigate_to_tool("Supercleaner"))
+        tools_menu.addAction(supercleaner_action)
+        
+        superlookup_action = QAction("🔍 Super&lookup...", self)
+        superlookup_action.setShortcut("Ctrl+K")
+        superlookup_action.triggered.connect(self._go_to_superlookup)
+        tools_menu.addAction(superlookup_action)
+        
+        supervoice_action = QAction("🎤 Super&voice...", self)
+        supervoice_action.triggered.connect(lambda: self._navigate_to_tool("Supervoice"))
+        tools_menu.addAction(supervoice_action)
+        
+        encoding_action = QAction("🔧 &Text Encoding Repair...", self)
+        encoding_action.triggered.connect(lambda: self._navigate_to_tool("Text Encoding Repair"))
+        tools_menu.addAction(encoding_action)
+        
+        tmx_editor_action = QAction("✏️ T&MX Editor...", self)
+        tmx_editor_action.triggered.connect(lambda: self._navigate_to_tool("TMX Editor"))
+        tools_menu.addAction(tmx_editor_action)
+        
+        tracked_changes_action = QAction("🔄 Tracked &Changes...", self)
+        tracked_changes_action.triggered.connect(lambda: self._navigate_to_tool("Tracked Changes"))
+        tools_menu.addAction(tracked_changes_action)
+        
         tools_menu.addSeparator()
         
         image_extractor_action = QAction("🖼️ &Image Extractor (Superimage)...", self)
@@ -6758,6 +6891,9 @@ class SupervertalerQt(QMainWindow):
         settings_tab = self.create_settings_tab()
         self.main_tabs.addTab(settings_tab, "⚙️ Settings")
         
+        # Set startup tab to Grid (index 0)
+        self.main_tabs.setCurrentIndex(0)
+        
         main_layout.addWidget(self.main_tabs)
         
         # Connect tab changes to handle view refreshes
@@ -7282,6 +7418,143 @@ class SupervertalerQt(QMainWindow):
         
         return prompt_widget
     
+    
+    def create_superconverter_tab(self) -> QWidget:
+        """Create the Superconverter tab - Format conversion tools"""
+        container = QWidget()
+        main_layout = QVBoxLayout(container)
+        main_layout.setContentsMargins(10, 10, 10, 10)
+        main_layout.setSpacing(10)
+        
+        # Header
+        header = QLabel("🔄 Superconverter")
+        header.setStyleSheet("font-size: 16pt; font-weight: bold; color: #1976D2;")
+        main_layout.addWidget(header)
+        
+        # Description
+        description = QLabel(
+            "Convert translation data between different formats - perfect for AI workflows, CAT tool exchanges, and data processing."
+        )
+        description.setWordWrap(True)
+        description.setStyleSheet("color: #666; padding: 5px; background-color: #E3F2FD; border-radius: 3px;")
+        main_layout.addWidget(description)
+        
+        main_layout.addSpacing(5)
+        
+        # Create tabbed interface for different conversion types
+        tabs = QTabWidget()
+        tabs.setStyleSheet("QTabBar::tab { outline: 0; } QTabBar::tab:focus { outline: none; }")
+        
+        # Tab 1: Bilingual Export (current project)
+        bilingual_tab = QWidget()
+        bilingual_layout = QVBoxLayout(bilingual_tab)
+        bilingual_layout.setContentsMargins(15, 15, 15, 15)
+        
+        bilingual_info = QLabel(
+            "<b>Export Current Project</b><br><br>"
+            "Export your translation project as a Markdown table - perfect for AI chat interfaces like ChatGPT and Claude.<br><br>"
+            "The table format renders beautifully and makes it easy for AI to understand and process your segments."
+        )
+        bilingual_info.setWordWrap(True)
+        bilingual_info.setTextFormat(Qt.TextFormat.RichText)
+        bilingual_layout.addWidget(bilingual_info)
+        
+        bilingual_layout.addSpacing(15)
+        
+        bilingual_btn = QPushButton("📄 Export as Markdown Table")
+        bilingual_btn.setMinimumHeight(40)
+        bilingual_btn.setStyleSheet(
+            "QPushButton { background-color: #2196F3; color: white; font-weight: bold; "
+            "border: none; border-radius: 5px; padding: 10px; outline: none; }"
+            "QPushButton:hover { background-color: #1976D2; }"
+        )
+        bilingual_btn.clicked.connect(self.export_bilingual_table_markdown)
+        bilingual_layout.addWidget(bilingual_btn)
+        
+        bilingual_layout.addStretch()
+        tabs.addTab(bilingual_tab, "📊 Bilingual Table")
+        
+        # Tab 2: Document Converter (monolingual docs to Markdown)
+        doc_tab = QWidget()
+        doc_layout = QVBoxLayout(doc_tab)
+        doc_layout.setContentsMargins(15, 15, 15, 15)
+        
+        doc_info = QLabel(
+            "<b>Convert Documents to Markdown</b><br><br>"
+            "Convert DOCX or TXT documents to Markdown format, preserving structure (headings, lists, paragraphs).<br><br>"
+            "Perfect for preparing documents for AI processing or publishing on web platforms."
+        )
+        doc_info.setWordWrap(True)
+        doc_info.setTextFormat(Qt.TextFormat.RichText)
+        doc_layout.addWidget(doc_info)
+        
+        doc_layout.addSpacing(15)
+        
+        # Single file button
+        single_doc_btn = QPushButton("📄 Convert Single Document")
+        single_doc_btn.setMinimumHeight(40)
+        single_doc_btn.setStyleSheet(
+            "QPushButton { background-color: #4CAF50; color: white; font-weight: bold; "
+            "border: none; border-radius: 5px; padding: 10px; outline: none; }"
+            "QPushButton:hover { background-color: #388E3C; }"
+        )
+        single_doc_btn.clicked.connect(self.convert_document_to_markdown)
+        doc_layout.addWidget(single_doc_btn)
+        
+        doc_layout.addSpacing(10)
+        
+        # Batch conversion button
+        batch_doc_btn = QPushButton("📁 Batch Convert Multiple Documents")
+        batch_doc_btn.setMinimumHeight(40)
+        batch_doc_btn.setStyleSheet(
+            "QPushButton { background-color: #FF9800; color: white; font-weight: bold; "
+            "border: none; border-radius: 5px; padding: 10px; outline: none; }"
+            "QPushButton:hover { background-color: #F57C00; }"
+        )
+        batch_doc_btn.clicked.connect(self.batch_convert_documents_to_markdown)
+        doc_layout.addWidget(batch_doc_btn)
+        
+        doc_layout.addStretch()
+        tabs.addTab(doc_tab, "📝 Document → Markdown")
+        
+        # Tab 3: TMX Tools (placeholder for future)
+        tmx_tab = QWidget()
+        tmx_layout = QVBoxLayout(tmx_tab)
+        tmx_layout.setContentsMargins(15, 15, 15, 15)
+        
+        tmx_info = QLabel(
+            "<b>TMX Conversion Tools</b><br><br>"
+            "Convert Translation Memory eXchange (TMX) files to and from tab-delimited format.<br><br>"
+            "<i>Coming soon...</i>"
+        )
+        tmx_info.setWordWrap(True)
+        tmx_info.setTextFormat(Qt.TextFormat.RichText)
+        tmx_info.setStyleSheet("color: #888;")
+        tmx_layout.addWidget(tmx_info)
+        
+        tmx_layout.addSpacing(15)
+        
+        tmx_to_tsv_btn = QPushButton("TMX → Tab-delimited")
+        tmx_to_tsv_btn.setMinimumHeight(40)
+        tmx_to_tsv_btn.setEnabled(False)
+        tmx_to_tsv_btn.setStyleSheet("QPushButton:disabled { color: #999; background-color: #E0E0E0; }")
+        tmx_layout.addWidget(tmx_to_tsv_btn)
+        
+        tmx_layout.addSpacing(10)
+        
+        tsv_to_tmx_btn = QPushButton("Tab-delimited → TMX")
+        tsv_to_tmx_btn.setMinimumHeight(40)
+        tsv_to_tmx_btn.setEnabled(False)
+        tsv_to_tmx_btn.setStyleSheet("QPushButton:disabled { color: #999; background-color: #E0E0E0; }")
+        tmx_layout.addWidget(tsv_to_tmx_btn)
+        
+        tmx_layout.addStretch()
+        tabs.addTab(tmx_tab, "🔄 TMX Tools")
+        
+        main_layout.addWidget(tabs)
+        
+        return container
+    
     def create_supercleaner_tab(self) -> QWidget:
         """Create the Supercleaner tab - Clean DOCX documents"""
         from modules.supercleaner_ui import SupercleanerUI
@@ -8412,6 +8685,10 @@ class SupervertalerQt(QMainWindow):
         autofingers_tab = AutoFingersWidget(self)
         modules_tabs.addTab(autofingers_tab, "✋ AutoFingers")
         
+        # Superconverter - Format conversion tools
+        superconverter_tab = self.create_superconverter_tab()
+        modules_tabs.addTab(superconverter_tab, "🔄 Superconverter")
+        
         pdf_tab = self.create_pdf_rescue_tab()
         modules_tabs.addTab(pdf_tab, "📄 PDF Rescue")
         
@@ -9734,8 +10011,12 @@ class SupervertalerQt(QMainWindow):
                         elif status in ('draft', 'needs_review'):
                             run.font.color.rgb = RGBColor(200, 100, 0)  # Orange
                 
-                # Notes column - empty for user to fill
-                cells[4].text = ''
+                # Notes column - populate with segment notes if available
+                notes_text = seg.notes if hasattr(seg, 'notes') else ''
+                cells[4].text = notes_text
+                for para in cells[4].paragraphs:
+                    for run in para.runs:
+                        run.font.size = Pt(8)
             
             # Add footer with branding
             footer_para = doc.add_paragraph()
@@ -10642,6 +10923,38 @@ class SupervertalerQt(QMainWindow):
             self._play_sound_effect('glossary_term_error')
             self.statusBar().showMessage(f"Error adding term: {e}", 3000)
 
+    def add_word_to_dictionary_shortcut(self):
+        """Add word at cursor position to custom dictionary (Alt+D shortcut)
+        
+        Finds the misspelled word at the current cursor position and adds it to the
+        custom dictionary. Works when focus is in a grid target cell.
+        """
+        # Get currently focused widget
+        focused_widget = QApplication.focusWidget()
+        
+        # Check if we're in an editable grid cell
+        if not isinstance(focused_widget, EditableGridTextEditor):
+            self.statusBar().showMessage("Alt+D: Place cursor on a misspelled word in the target cell first", 3000)
+            return
+        
+        # Get cursor position
+        cursor = focused_widget.textCursor()
+        
+        # Try to find misspelled word at cursor
+        word_info = focused_widget._get_misspelled_word_at_cursor(cursor)
+        
+        if word_info[0] is None:
+            # No misspelled word found at cursor
+            self.statusBar().showMessage("No misspelled word at cursor position", 3000)
+            return
+        
+        word, start_pos, end_pos = word_info
+        
+        # Add to dictionary
+        focused_widget._add_to_dictionary(word)
+        
+        # Status message already shown by _add_to_dictionary
+
     def add_text_to_non_translatables(self, text: str):
         """Add selected text to active non-translatable list(s)"""
         if not text or not text.strip():
@@ -13240,7 +13553,9 @@ class SupervertalerQt(QMainWindow):
         
         # ===== TAB 2: AI Settings (LLM, Ollama) =====
         ai_tab = self._create_ai_settings_tab()
-        settings_tabs.addTab(scroll_area_wrapper(ai_tab), "🤖 AI Settings")
+        ai_scroll = scroll_area_wrapper(ai_tab)
+        settings_tabs.addTab(ai_scroll, "🤖 AI Settings")
+        self.ai_settings_scroll = ai_scroll  # Store reference for scrolling to API keys
         
         # ===== TAB 3: Language Pair Settings =====
         lang_tab = self._create_language_pair_tab()
@@ -13760,6 +14075,45 @@ class SupervertalerQt(QMainWindow):
         full_context_cb.stateChanged.connect(lambda: context_slider.setEnabled(full_context_cb.isChecked()))
         update_context_label(context_window_size)
         
+        prefs_layout.addSpacing(10)
+        
+        # QuickMenu document context
+        quickmenu_context_label = QLabel("<b>QuickMenu Document Context:</b>")
+        prefs_layout.addWidget(quickmenu_context_label)
+        
+        quickmenu_context_percent = general_prefs.get('quickmenu_context_percent', 50)
+        quickmenu_context_layout = QHBoxLayout()
+        quickmenu_context_layout.addWidget(QLabel("  Document context size:"))
+        quickmenu_context_slider = QSlider(Qt.Orientation.Horizontal)
+        quickmenu_context_slider.setMinimum(0)
+        quickmenu_context_slider.setMaximum(100)
+        quickmenu_context_slider.setValue(quickmenu_context_percent)
+        quickmenu_context_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        quickmenu_context_slider.setTickInterval(10)
+        quickmenu_context_layout.addWidget(quickmenu_context_slider)
+        quickmenu_context_value_label = QLabel(f"{quickmenu_context_percent}%")
+        quickmenu_context_value_label.setMinimumWidth(60)
+        quickmenu_context_layout.addWidget(quickmenu_context_value_label)
+        quickmenu_context_layout.addStretch()
+        prefs_layout.addLayout(quickmenu_context_layout)
+        
+        quickmenu_context_info = QLabel(
+            "  ⓘ When using {{SOURCE+TARGET_CONTEXT}} or {{SOURCE_CONTEXT}} placeholders in QuickMenu prompts.\n"
+            "  0% = disabled, 50% = half the document (default), 100% = entire document.\n"
+            "  Limit: maximum 100 segments for performance."
+        )
+        quickmenu_context_info.setStyleSheet("font-size: 9pt; color: #666; padding-left: 20px;")
+        quickmenu_context_info.setWordWrap(True)
+        prefs_layout.addWidget(quickmenu_context_info)
+        
+        def update_quickmenu_context_label(value):
+            if value == 0:
+                quickmenu_context_value_label.setText("0% (disabled)")
+            else:
+                quickmenu_context_value_label.setText(f"{value}%")
+        
+        quickmenu_context_slider.valueChanged.connect(update_quickmenu_context_label)
+        
         prefs_layout.addSpacing(5)
         
         # Check TM before API call
@@ -13904,7 +14258,8 @@ class SupervertalerQt(QMainWindow):
             batch_size_spin, surrounding_spin, full_context_cb, context_slider,
             check_tm_cb, auto_propagate_cb, delay_spin,
             ollama_keepwarm_cb,
-            llm_matching_cb, auto_markdown_cb, llm_spin
+            llm_matching_cb, auto_markdown_cb, llm_spin,
+            quickmenu_context_slider
         ))
         layout.addWidget(save_btn)
         
@@ -16902,7 +17257,8 @@ class SupervertalerQt(QMainWindow):
                                    batch_size_spin, surrounding_spin, full_context_cb, context_slider,
                                    check_tm_cb, auto_propagate_cb, delay_spin,
                                    ollama_keepwarm_cb,
-                                   llm_matching_cb, auto_markdown_cb, llm_spin):
+                                   llm_matching_cb, auto_markdown_cb, llm_spin,
+                                   quickmenu_context_slider):
         """Save all AI settings from the unified AI Settings tab"""
         # Determine selected provider
         if openai_radio.isChecked():
@@ -16961,6 +17317,7 @@ class SupervertalerQt(QMainWindow):
         general_prefs['surrounding_segments'] = surrounding_spin.value()
         general_prefs['use_full_context'] = full_context_cb.isChecked()
         general_prefs['context_window_size'] = context_slider.value()
+        general_prefs['quickmenu_context_percent'] = quickmenu_context_slider.value()
         general_prefs['check_tm_before_api'] = check_tm_cb.isChecked()
         general_prefs['auto_propagate_100'] = auto_propagate_cb.isChecked()
         general_prefs['lookup_delay'] = delay_spin.value()
@@ -18502,7 +18859,7 @@ class SupervertalerQt(QMainWindow):
         header.setStretchLastSection(False)  # Don't auto-stretch last section (we use Stretch mode for Source/Target)
         
         # Set initial column widths - give Source and Target equal space
-        self.table.setColumnWidth(0, 55)   # ID - fits 4-digit segment numbers
+        self.table.setColumnWidth(0, 40)   # ID - compact, fits up to 3 digits comfortably
         self.table.setColumnWidth(1, 40)   # Type - narrower
         self.table.setColumnWidth(2, 400)  # Source
         self.table.setColumnWidth(3, 400)  # Target
@@ -20922,6 +21279,9 @@ class SupervertalerQt(QMainWindow):
             # Initialize TM for this project
             self.initialize_tm_database()
             
+            # Deactivate all resources for new project (user explicitly activates what they need)
+            self._deactivate_all_resources_for_new_project()
+            
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
 
@@ -21670,6 +22030,493 @@ class SupervertalerQt(QMainWindow):
                 "Export Error",
                 f"Failed to export AI format:\n\n{str(e)}"
             )
+    
+    def export_bilingual_table_markdown(self):
+        """Export current project segments as Markdown table (for AI systems)"""
+        try:
+            if not self.current_project or not self.current_project.segments:
+                QMessageBox.warning(self, "No Project", "Please open a project with segments first")
+                return
+            
+            segments = list(self.current_project.segments)
+            
+            # Get language names
+            source_lang = self.current_project.source_lang or "Source"
+            target_lang = self.current_project.target_lang or "Target"
+            
+            # Check translation status
+            translated_count = sum(1 for seg in segments if seg.target and seg.target.strip())
+            total_count = len(segments)
+            
+            # Show export options dialog
+            dialog = QDialog(self)
+            dialog.setWindowTitle("Export as Markdown Table")
+            dialog.setMinimumWidth(500)
+            
+            layout = QVBoxLayout(dialog)
+            
+            # Info label
+            info_label = QLabel(
+                "Export segments as a <b>Markdown table</b> optimized for AI systems.\n"
+                "The table format renders beautifully in ChatGPT, Claude, and all AI chat interfaces."
+            )
+            info_label.setWordWrap(True)
+            info_label.setTextFormat(Qt.TextFormat.RichText)
+            layout.addWidget(info_label)
+            
+            layout.addSpacing(10)
+            
+            # Status info
+            status_label = QLabel(
+                f"📊 <b>{translated_count} of {total_count}</b> segments have translations."
+                if translated_count > 0
+                else f"📊 <b>{total_count}</b> segments (none translated yet)."
+            )
+            status_label.setTextFormat(Qt.TextFormat.RichText)
+            layout.addWidget(status_label)
+            
+            layout.addSpacing(10)
+            
+            # Content options
+            content_group = QGroupBox("Content Options")
+            content_layout = QVBoxLayout(content_group)
+            
+            include_both_radio = CheckmarkRadioButton(f"Include both {source_lang} and {target_lang} (bilingual table)")
+            include_both_radio.setChecked(True)
+            source_only_radio = CheckmarkRadioButton(f"{source_lang} only (for AI translation)")
+            target_only_radio = CheckmarkRadioButton(f"{target_lang} only (translated segments)")
+            
+            content_layout.addWidget(include_both_radio)
+            content_layout.addWidget(source_only_radio)
+            content_layout.addWidget(target_only_radio)
+            layout.addWidget(content_group)
+            
+            # Filter options
+            filter_group = QGroupBox("Segment Filter")
+            filter_layout = QVBoxLayout(filter_group)
+            
+            all_segments_radio = CheckmarkRadioButton("All segments")
+            all_segments_radio.setChecked(True)
+            untranslated_radio = CheckmarkRadioButton("Untranslated segments only (empty target)")
+            translated_radio = CheckmarkRadioButton("Translated segments only (has target)")
+            
+            filter_layout.addWidget(all_segments_radio)
+            filter_layout.addWidget(untranslated_radio)
+            filter_layout.addWidget(translated_radio)
+            layout.addWidget(filter_group)
+            
+            layout.addSpacing(10)
+            
+            # Preview
+            preview_group = QGroupBox("Preview")
+            preview_layout = QVBoxLayout(preview_group)
+            preview_text = QTextEdit()
+            preview_text.setReadOnly(True)
+            preview_text.setMaximumHeight(150)
+            preview_text.setStyleSheet("font-family: Consolas, monospace; font-size: 10px;")
+            preview_layout.addWidget(preview_text)
+            layout.addWidget(preview_group)
+            
+            def update_preview():
+                # Show preview with sample data
+                if include_both_radio.isChecked():
+                    preview = f"# Translation Project: {self.current_project.name or 'Untitled'}\n\n"
+                    preview += f"| Segment | {source_lang} | {target_lang} |\n"
+                    preview += "|---------|" + "-" * (len(source_lang) + 2) + "|" + "-" * (len(target_lang) + 2) + "|\n"
+                    preview += "| 1 | Source text example... | Target text example... |\n"
+                    preview += "| 2 | Another segment... | Translation here... |"
+                elif source_only_radio.isChecked():
+                    preview = f"# Translation Project: {self.current_project.name or 'Untitled'}\n\n"
+                    preview += f"| Segment | {source_lang} |\n"
+                    preview += "|---------|" + "-" * (len(source_lang) + 2) + "|\n"
+                    preview += "| 1 | Source text example... |\n"
+                    preview += "| 2 | Another segment... |"
+                else:
+                    preview = f"# Translation Project: {self.current_project.name or 'Untitled'}\n\n"
+                    preview += f"| Segment | {target_lang} |\n"
+                    preview += "|---------|" + "-" * (len(target_lang) + 2) + "|\n"
+                    preview += "| 1 | Target text example... |\n"
+                    preview += "| 2 | Translation here... |"
+                
+                preview_text.setPlainText(preview)
+            
+            # Connect signals for live preview
+            include_both_radio.toggled.connect(update_preview)
+            source_only_radio.toggled.connect(update_preview)
+            target_only_radio.toggled.connect(update_preview)
+            
+            update_preview()  # Initial preview
+            
+            layout.addSpacing(10)
+            
+            # Buttons
+            button_layout = QHBoxLayout()
+            ok_btn = QPushButton("Export")
+            ok_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; border: none; outline: none;")
+            ok_btn.clicked.connect(dialog.accept)
+            cancel_btn = QPushButton("Cancel")
+            cancel_btn.clicked.connect(dialog.reject)
+            
+            button_layout.addStretch()
+            button_layout.addWidget(cancel_btn)
+            button_layout.addWidget(ok_btn)
+            layout.addLayout(button_layout)
+            
+            if dialog.exec() != QDialog.DialogCode.Accepted:
+                return
+            
+            # Determine content mode
+            if source_only_radio.isChecked():
+                content_mode = "source_only"
+            elif target_only_radio.isChecked():
+                content_mode = "target_only"
+            else:
+                content_mode = "bilingual"
+            
+            # Filter segments
+            if untranslated_radio.isChecked():
+                filtered_segments = [s for s in segments if not (s.target and s.target.strip())]
+            elif translated_radio.isChecked():
+                filtered_segments = [s for s in segments if s.target and s.target.strip()]
+            else:
+                filtered_segments = segments
+            
+            if not filtered_segments:
+                QMessageBox.warning(
+                    self, "No Segments",
+                    "No segments match the selected filter criteria."
+                )
+                return
+            
+            # Get save path
+            default_name = ""
+            if self.current_project.name:
+                default_name = self.current_project.name.replace(" ", "_") + "_table.md"
+            
+            file_path, _ = QFileDialog.getSaveFileName(
+                self,
+                "Export Markdown Table",
+                default_name,
+                "Markdown Files (*.md);;All Files (*.*)"
+            )
+            
+            if not file_path:
+                return
+            
+            # Ensure .md extension
+            if not file_path.lower().endswith('.md'):
+                file_path += '.md'
+            
+            # Build Markdown table
+            output_lines = []
+            output_lines.append(f"# Translation Project: {self.current_project.name or 'Untitled'}")
+            output_lines.append("")
+            output_lines.append(f"**Languages:** {source_lang} → {target_lang}")
+            output_lines.append(f"**Segments:** {len(filtered_segments)}")
+            output_lines.append(f"**Exported:** {datetime.now().strftime('%Y-%m-%d %H:%M')}")
+            output_lines.append("")
+            
+            # Table header
+            if content_mode == "bilingual":
+                output_lines.append(f"| Segment | {source_lang} | {target_lang} |")
+                output_lines.append("|---------|" + "-" * (len(source_lang) + 2) + "|" + "-" * (len(target_lang) + 2) + "|")
+            elif content_mode == "source_only":
+                output_lines.append(f"| Segment | {source_lang} |")
+                output_lines.append("|---------|" + "-" * (len(source_lang) + 2) + "|")
+            else:  # target_only
+                output_lines.append(f"| Segment | {target_lang} |")
+                output_lines.append("|---------|" + "-" * (len(target_lang) + 2) + "|")
+            
+            # Table rows
+            for i, seg in enumerate(filtered_segments, 1):
+                # Escape pipe characters in text for Markdown tables
+                source_text = seg.source.replace("|", "\\|").replace("\n", " ")
+                target_text = (seg.target or "").replace("|", "\\|").replace("\n", " ")
+                
+                if content_mode == "bilingual":
+                    output_lines.append(f"| {i} | {source_text} | {target_text} |")
+                elif content_mode == "source_only":
+                    output_lines.append(f"| {i} | {source_text} |")
+                else:  # target_only
+                    output_lines.append(f"| {i} | {target_text} |")
+            
+            # Write file
+            with open(file_path, 'w', encoding='utf-8', newline='\n') as f:
+                f.write('\n'.join(output_lines))
+            
+            self.log(f"✓ Exported {len(filtered_segments)} segments as Markdown table to: {os.path.basename(file_path)}")
+            
+            QMessageBox.information(
+                self,
+                "Export Complete",
+                f"Successfully exported {len(filtered_segments)} segments as Markdown table to:\n\n{os.path.basename(file_path)}\n\n"
+                f"This format renders beautifully in ChatGPT, Claude, and other AI chat interfaces!"
+            )
+            
+        except Exception as e:
+            self.log(f"✗ Markdown table export failed: {str(e)}")
+            QMessageBox.critical(
+                self,
+                "Export Error",
+                f"Failed to export Markdown table:\n\n{str(e)}"
+            )
+    
+    def convert_document_to_markdown(self):
+        """Convert a single DOCX or TXT document to Markdown format, preserving structure"""
+        try:
+            # Select input file
+            file_path, _ = QFileDialog.getOpenFileName(
+                self,
+                "Select Document to Convert",
+                "",
+                "Documents (*.docx *.txt);;All Files (*.*)"
+            )
+            
+            if not file_path:
+                return
+            
+            # Determine output path
+            base_name = os.path.splitext(file_path)[0]
+            output_path, _ = QFileDialog.getSaveFileName(
+                self,
+                "Save Markdown File",
+                base_name + ".md",
+                "Markdown Files (*.md);;All Files (*.*)"
+            )
+            
+            if not output_path:
+                return
+            
+            # Ensure .md extension
+            if not output_path.lower().endswith('.md'):
+                output_path += '.md'
+            
+            # Convert based on file type
+            if file_path.lower().endswith('.docx'):
+                self._convert_docx_to_markdown(file_path, output_path)
+            else:  # TXT
+                self._convert_txt_to_markdown(file_path, output_path)
+            
+            self.log(f"✓ Converted {os.path.basename(file_path)} → {os.path.basename(output_path)}")
+            
+            QMessageBox.information(
+                self,
+                "Conversion Complete",
+                f"Successfully converted document to Markdown:\n\n{os.path.basename(output_path)}"
+            )
+            
+        except Exception as e:
+            self.log(f"✗ Document conversion failed: {str(e)}")
+            QMessageBox.critical(
+                self,
+                "Conversion Error",
+                f"Failed to convert document:\n\n{str(e)}"
+            )
+    
+    def batch_convert_documents_to_markdown(self):
+        """Batch convert multiple documents to Markdown format"""
+        try:
+            # Select multiple files
+            file_paths, _ = QFileDialog.getOpenFileNames(
+                self,
+                "Select Documents to Convert",
+                "",
+                "Documents (*.docx *.txt);;All Files (*.*)"
+            )
+            
+            if not file_paths:
+                return
+            
+            # Select output folder
+            output_folder = QFileDialog.getExistingDirectory(
+                self,
+                "Select Output Folder for Markdown Files",
+                "",
+                QFileDialog.Option.ShowDirsOnly
+            )
+            
+            if not output_folder:
+                return
+            
+            # Progress dialog
+            progress = QProgressDialog(
+                "Converting documents to Markdown...",
+                "Cancel",
+                0,
+                len(file_paths),
+                self
+            )
+            progress.setWindowModality(Qt.WindowModality.WindowModal)
+            progress.setMinimumDuration(0)
+            
+            converted_count = 0
+            failed_count = 0
+            
+            for i, file_path in enumerate(file_paths):
+                if progress.wasCanceled():
+                    break
+                
+                progress.setValue(i)
+                progress.setLabelText(f"Converting: {os.path.basename(file_path)}")
+                QApplication.processEvents()
+                
+                try:
+                    # Determine output path
+                    base_name = os.path.splitext(os.path.basename(file_path))[0]
+                    output_path = os.path.join(output_folder, base_name + ".md")
+                    
+                    # Convert based on file type
+                    if file_path.lower().endswith('.docx'):
+                        self._convert_docx_to_markdown(file_path, output_path)
+                    else:  # TXT
+                        self._convert_txt_to_markdown(file_path, output_path)
+                    
+                    converted_count += 1
+                    self.log(f"✓ Converted: {os.path.basename(file_path)}")
+                    
+                except Exception as e:
+                    failed_count += 1
+                    self.log(f"✗ Failed: {os.path.basename(file_path)} - {str(e)}")
+            
+            progress.setValue(len(file_paths))
+            
+            # Show summary
+            summary = f"Batch conversion complete!\n\n"
+            summary += f"✓ Successfully converted: {converted_count} files\n"
+            if failed_count > 0:
+                summary += f"✗ Failed: {failed_count} files\n"
+            summary += f"\nOutput folder: {output_folder}"
+            
+            QMessageBox.information(
+                self,
+                "Batch Conversion Complete",
+                summary
+            )
+            
+        except Exception as e:
+            self.log(f"✗ Batch conversion failed: {str(e)}")
+            QMessageBox.critical(
+                self,
+                "Conversion Error",
+                f"Failed to perform batch conversion:\n\n{str(e)}"
+            )
+    
+    def _convert_docx_to_markdown(self, docx_path: str, output_path: str):
+        """Convert DOCX document to Markdown, preserving structure"""
+        from docx import Document
+        
+        doc = Document(docx_path)
+        markdown_lines = []
+        
+        # Add document title
+        doc_name = os.path.splitext(os.path.basename(docx_path))[0]
+        markdown_lines.append(f"# {doc_name}")
+        markdown_lines.append("")
+        
+        for para in doc.paragraphs:
+            if not para.text.strip():
+                markdown_lines.append("")
+                continue
+            
+            # Check paragraph style
+            style = para.style.name.lower()
+            text = para.text.strip()
+            
+            # Detect ALL CAPS headings (common in patent documents)
+            words = text.split()
+            is_all_caps = (
+                len(words) >= 2 and 
+                all(word.isupper() or not word.isalpha() for word in words) and
+                len(text) <= 100  # Reasonable heading length
+            )
+            
+            if 'heading 1' in style or style == 'title':
+                markdown_lines.append(f"# {text}")
+            elif 'heading 2' in style:
+                markdown_lines.append(f"## {text}")
+            elif 'heading 3' in style:
+                markdown_lines.append(f"### {text}")
+            elif 'heading 4' in style:
+                markdown_lines.append(f"#### {text}")
+            elif 'heading 5' in style:
+                markdown_lines.append(f"##### {text}")
+            elif 'heading 6' in style:
+                markdown_lines.append(f"###### {text}")
+            elif is_all_caps:
+                # ALL CAPS line without heading style - treat as heading
+                markdown_lines.append(f"## {text.title()}")
+            elif 'list bullet' in style or 'bullet' in style:
+                markdown_lines.append(f"- {text}")
+            elif 'list number' in style or 'numbering' in style:
+                markdown_lines.append(f"1. {text}")
+            elif 'quote' in style or 'quotation' in style:
+                markdown_lines.append(f"> {text}")
+            else:
+                # Regular paragraph - preserve bold/italic if present
+                # Simple formatting detection (runs with bold/italic)
+                has_bold = any(run.bold for run in para.runs if run.text.strip())
+                has_italic = any(run.italic for run in para.runs if run.text.strip())
+                
+                if has_bold and has_italic:
+                    markdown_lines.append(f"***{text}***")
+                elif has_bold:
+                    markdown_lines.append(f"**{text}**")
+                elif has_italic:
+                    markdown_lines.append(f"*{text}*")
+                else:
+                    markdown_lines.append(text)
+            
+            markdown_lines.append("")
+        
+        # Write output
+        with open(output_path, 'w', encoding='utf-8', newline='\n') as f:
+            f.write('\n'.join(markdown_lines))
+    
+    def _convert_txt_to_markdown(self, txt_path: str, output_path: str):
+        """Convert TXT document to Markdown with minimal formatting"""
+        with open(txt_path, 'r', encoding='utf-8') as f:
+            lines = f.readlines()
+        
+        markdown_lines = []
+        
+        # Add document title
+        doc_name = os.path.splitext(os.path.basename(txt_path))[0]
+        markdown_lines.append(f"# {doc_name}")
+        markdown_lines.append("")
+        
+        # Process lines - detect simple patterns
+        for line in lines:
+            stripped = line.strip()
+            
+            if not stripped:
+                markdown_lines.append("")
+                continue
+            
+            # Detect ALL CAPS headings (common in plain text documents)
+            # Must be at least 3 words long and all uppercase
+            words = stripped.split()
+            is_all_caps = (
+                len(words) >= 2 and 
+                all(word.isupper() or not word.isalpha() for word in words) and
+                len(stripped) <= 100  # Reasonable heading length
+            )
+            
+            if is_all_caps:
+                # Convert to title case and make it a heading
+                markdown_lines.append(f"## {stripped.title()}")
+            # Detect simple bullet points
+            elif stripped.startswith('- ') or stripped.startswith('* '):
+                markdown_lines.append(stripped)
+            # Detect numbered lists
+            elif len(stripped) > 2 and stripped[0].isdigit() and stripped[1] in '.):':
+                markdown_lines.append(stripped)
+            # Regular text
+            else:
+                markdown_lines.append(stripped)
+        
+        # Write output
+        with open(output_path, 'w', encoding='utf-8', newline='\n') as f:
+            f.write('\n'.join(markdown_lines))
 
     # ========================================================================
     # MULTI-FILE FOLDER IMPORT
@@ -22912,6 +23759,9 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
+            # Deactivate all resources for new project (user explicitly activates what they need)
+            self._deactivate_all_resources_for_new_project()
+            
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
             
@@ -23406,6 +24256,9 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
+            # Deactivate all resources for new project (user explicitly activates what they need)
+            self._deactivate_all_resources_for_new_project()
+            
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
             
@@ -23672,6 +24525,9 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
+            # Deactivate all resources for new project (user explicitly activates what they need)
+            self._deactivate_all_resources_for_new_project()
+            
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
             
@@ -23881,6 +24737,9 @@ class SupervertalerQt(QMainWindow):
             self.load_segments_to_grid()
             self.initialize_tm_database()
             
+            # Deactivate all resources for new project (user explicitly activates what they need)
+            self._deactivate_all_resources_for_new_project()
+            
             # Auto-resize rows for better initial display
             self.auto_resize_rows()
             
@@ -27508,6 +28367,20 @@ class SupervertalerQt(QMainWindow):
         # Full processing for non-arrow-key navigation (click, etc.)
         self._on_cell_selected_full(current_row, current_col, previous_row, previous_col)
     
+    def _center_row_in_viewport(self, row: int):
+        """Center the given row vertically in the visible table viewport.
+        
+        Uses Qt's built-in scrollTo() with PositionAtCenter hint.
+        """
+        if row < 0 or row >= self.table.rowCount():
+            return
+        
+        # Get the model index for any cell in this row (use column 0)
+        index = self.table.model().index(row, 0)
+        if index.isValid():
+            # Use Qt's built-in centering - PositionAtCenter puts the item in the center of the viewport
+            self.table.scrollTo(index, QAbstractItemView.ScrollHint.PositionAtCenter)
+    
     def _on_cell_selected_minimal(self, current_row, previous_row):
         """Minimal UI update for fast arrow key navigation - just highlight and scroll"""
         try:
@@ -27529,7 +28402,7 @@ class SupervertalerQt(QMainWindow):
                 
                 # Auto-center if enabled
                 if getattr(self, 'auto_center_active_segment', False) and not getattr(self, 'filtering_active', False):
-                    self.table.scrollToItem(current_id_item, QTableWidget.ScrollHint.PositionAtCenter)
+                    self._center_row_in_viewport(current_row)
         except Exception as e:
             if self.debug_mode_enabled:
                 self.log(f"Error in minimal cell selection: {e}")
@@ -27574,7 +28447,7 @@ class SupervertalerQt(QMainWindow):
                     current_id_item.setForeground(QColor("white"))
                 
                 if getattr(self, 'auto_center_active_segment', False) and not getattr(self, 'filtering_active', False):
-                    self.table.scrollToItem(current_id_item, QTableWidget.ScrollHint.PositionAtCenter)
+                    self._center_row_in_viewport(current_row)
             
             if not self.current_project or current_row < 0:
                 return
@@ -29800,6 +30673,35 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         except Exception as e:
             self.log(f"⚠ Could not initialize spellcheck: {e}")
     
+    def _deactivate_all_resources_for_new_project(self):
+        """Deactivate all TMs, termbases, and NT lists for a freshly imported project.
+        This ensures new projects start with clean slate - user explicitly activates what they need."""
+        if not self.current_project or not hasattr(self.current_project, 'id'):
+            return
+        
+        project_id = self.current_project.id
+        if not project_id:
+            return
+        
+        # Deactivate all TMs for this project
+        if hasattr(self, 'tm_metadata_mgr') and self.tm_metadata_mgr:
+            all_tms = self.tm_metadata_mgr.get_all_tms()
+            for tm in all_tms:
+                self.tm_metadata_mgr.deactivate_tm(tm['id'], project_id)
+        
+        # Deactivate all termbases for this project
+        if hasattr(self, 'termbase_mgr') and self.termbase_mgr:
+            all_termbases = self.termbase_mgr.get_all_termbases()
+            for tb in all_termbases:
+                self.termbase_mgr.deactivate_termbase(tb['id'], project_id)
+        
+        # Deactivate all NT lists
+        if hasattr(self, 'nt_manager') and self.nt_manager:
+            for list_name in list(self.nt_manager.lists.keys()):
+                self.nt_manager.set_list_active(list_name, False)
+        
+        self.log("📋 New project: All TMs, glossaries, and NT lists deactivated (start clean)")
+    
     def search_and_display_tm_matches(self, source_text: str):
         """Search TM and Termbases and display matches with visual diff for fuzzy matches"""
         self.log(f"🚨 search_and_display_tm_matches called with source_text: '{source_text[:50]}...'")
@@ -30315,11 +31217,18 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         normalized_source = clean_source_lower
                         for quote_char in '\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A':
                             normalized_source = normalized_source.replace(quote_char, ' ')
+                        
+                        # CRITICAL FIX: Strip trailing punctuation from glossary term before matching
+                        # This allows entries like "De huidige uitvinding...problemen." (with period)
+                        # to match source text "...problemen." where tokenization strips the period
+                        # Strip from both ends to handle quotes and trailing punctuation
+                        normalized_term = source_term.lower().rstrip(PUNCT_CHARS).lstrip(PUNCT_CHARS)
+                        
                         # Check if term has punctuation - use different pattern
-                        if any(char in source_term for char in ['.', '%', ',', '-', '/']):
-                            pattern = re.compile(r'(?<!\w)' + re.escape(source_term.lower()) + r'(?!\w)')
+                        if any(char in normalized_term for char in ['.', '%', ',', '-', '/']):
+                            pattern = re.compile(r'(?<!\w)' + re.escape(normalized_term) + r'(?!\w)')
                         else:
-                            pattern = re.compile(r"\b" + re.escape(source_term.lower()) + r"\b")
+                            pattern = re.compile(r"\b" + re.escape(normalized_term) + r"\b")
                         
                         # Try matching on normalized (tag-stripped, quote-stripped) text first, 
                         # then tag-stripped, then original with tags
@@ -30776,7 +31685,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         self.case_sensitive_cb.setChecked(op.case_sensitive)
     
     def _fr_run_set_batch(self, fr_set: FindReplaceSet):
-        """Run all enabled operations in a F&R Set as a batch."""
+        """Run all enabled operations in a F&R Set as a batch (optimized for speed)."""
         enabled_ops = [op for op in fr_set.operations if op.enabled and op.find_text]
         
         if not enabled_ops:
@@ -30795,17 +31704,32 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if reply != QMessageBox.StandardButton.Yes:
             return
         
-        # Run each operation
-        total_replaced = 0
-        for op in enabled_ops:
-            count = self._execute_single_fr_operation(op)
-            total_replaced += count
-            self.log(f"  '{op.find_text}' → '{op.replace_text}': {count} replacement(s)")
+        # OPTIMIZATION: Disable UI updates during batch processing
+        self.table.setUpdatesEnabled(False)
         
-        # Refresh grid
-        self.load_segments_to_grid()
-        self.project_modified = True
-        self.update_window_title()
+        try:
+            # Run each operation
+            total_replaced = 0
+            for op in enabled_ops:
+                count = self._execute_single_fr_operation(op)
+                total_replaced += count
+                self.log(f"  '{op.find_text}' → '{op.replace_text}': {count} replacement(s)")
+            
+            self.project_modified = True
+            self.update_window_title()
+            
+        finally:
+            # OPTIMIZATION: Re-enable UI updates and refresh only target column cells
+            self.table.setUpdatesEnabled(True)
+            # Update all target cells in-place (batch operations can affect many segments)
+            for row in range(len(self.current_project.segments)):
+                segment = self.current_project.segments[row]
+                target_widget = self.table.cellWidget(row, 3)
+                if target_widget and hasattr(target_widget, 'setPlainText'):
+                    target_widget.blockSignals(True)
+                    target_widget.setPlainText(segment.target)
+                    target_widget.blockSignals(False)
+            self.table.viewport().update()
         
         QMessageBox.information(
             self.find_replace_dialog,
@@ -30814,12 +31738,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         )
     
     def _execute_single_fr_operation(self, op: FindReplaceOperation) -> int:
-        """Execute a single F&R operation on all segments. Returns replacement count."""
+        """Execute a single F&R operation on all segments (optimized). Returns replacement count."""
         import re
         count = 0
         
+        # OPTIMIZATION: Pre-filter segments - only check segments that might contain the text
+        # Quick case-insensitive check to skip segments that definitely don't match
+        search_text_lower = op.find_text.lower() if not op.case_sensitive else None
+        
         for segment in self.current_project.segments:
             texts_to_check = []
+            
+            # Pre-filter: skip segments that can't possibly match
+            if not op.case_sensitive:
+                # Quick check: does the segment contain the search text at all?
+                skip_segment = True
+                if op.search_in in ("source", "both") and self.allow_replace_in_source:
+                    if search_text_lower in segment.source.lower():
+                        skip_segment = False
+                if op.search_in in ("target", "both"):
+                    if search_text_lower in segment.target.lower():
+                        skip_segment = False
+                if skip_segment:
+                    continue
+            
             if op.search_in in ("source", "both") and self.allow_replace_in_source:
                 texts_to_check.append(("source", segment.source))
             if op.search_in in ("target", "both"):
@@ -31115,7 +32057,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         self.find_next_match()
     
     def replace_all_matches(self):
-        """Replace all matches in target segments"""
+        """Replace all matches in target segments (optimized for speed)"""
         find_text = self.find_input.text()
         replace_text = self.replace_input.text()
         
@@ -31188,52 +32130,67 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if reply != QMessageBox.StandardButton.Yes:
             return
         
-        # Perform replacements
-        import re
-        replaced_count = 0
+        # OPTIMIZATION: Disable UI updates during batch replacement
+        self.table.setUpdatesEnabled(False)
         
-        for row, col in self.find_matches:
-            segment = self.current_project.segments[row]
-            
-            # Get the appropriate field
-            if col == 2:  # Source
-                old_text = segment.source
-            else:  # col == 3, Target
-                old_text = segment.target
+        try:
+            # Perform replacements
+            import re
+            replaced_count = 0
+            updated_rows = set()  # Track which rows need UI updates
             
-            # Perform replacement
-            if match_mode == 2:  # Entire segment
-                new_text = replace_text
-            else:
-                if case_sensitive:
-                    new_text = old_text.replace(find_text, replace_text)
-                else:
-                    pattern = re.escape(find_text)
-                    new_text = re.sub(pattern, replace_text, old_text, flags=re.IGNORECASE)
-            
-            if new_text != old_text:
-                replaced_count += 1
-                # Update the appropriate field
-                if col == 2:
-                    segment.source = new_text
+            for row, col in self.find_matches:
+                segment = self.current_project.segments[row]
+                
+                # Get the appropriate field
+                if col == 2:  # Source
+                    old_text = segment.source
+                else:  # col == 3, Target
+                    old_text = segment.target
+                
+                # Perform replacement
+                if match_mode == 2:  # Entire segment
+                    new_text = replace_text
                 else:
-                    old_target = segment.target
-                    old_status = segment.status
-                    segment.target = new_text
-                    # Record undo state for find/replace operation
-                    self.record_undo_state(segment.id, old_target, new_text, old_status, old_status)
+                    if case_sensitive:
+                        new_text = old_text.replace(find_text, replace_text)
+                    else:
+                        pattern = re.escape(find_text)
+                        new_text = re.sub(pattern, replace_text, old_text, flags=re.IGNORECASE)
                 
-                # Update table
-                item = self.table.item(row, col)
-                if item:
-                    item.setText(new_text)
-        
-        self.project_modified = True
-        self.update_window_title()
-        
-        # Clear matches and reload
-        self.find_matches = []
-        self.load_segments_to_grid()
+                if new_text != old_text:
+                    replaced_count += 1
+                    updated_rows.add(row)
+                    
+                    # Update the appropriate field
+                    if col == 2:
+                        segment.source = new_text
+                    else:
+                        old_target = segment.target
+                        old_status = segment.status
+                        segment.target = new_text
+                        # Record undo state for find/replace operation
+                        self.record_undo_state(segment.id, old_target, new_text, old_status, old_status)
+                    
+                    # OPTIMIZATION: Update only the affected cell widget in-place
+                    cell_widget = self.table.cellWidget(row, col)
+                    if cell_widget and hasattr(cell_widget, 'setPlainText'):
+                        cell_widget.blockSignals(True)
+                        cell_widget.setPlainText(new_text)
+                        cell_widget.blockSignals(False)
+            
+            self.project_modified = True
+            self.update_window_title()
+            
+            # Clear matches
+            self.find_matches = []
+            
+        finally:
+            # OPTIMIZATION: Re-enable UI updates without full grid reload
+            self.table.setUpdatesEnabled(True)
+            # Trigger a repaint of updated rows only
+            for row in updated_rows:
+                self.table.viewport().update()
         
         QMessageBox.information(self.find_replace_dialog, "Replace All", f"Replaced {replaced_count} occurrence(s).")
         self.log(f"✓ Replaced {replaced_count} occurrence(s) of '{find_text}'")
@@ -31999,15 +32956,17 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         
         try:
             visible_count = 0
-            row_count = self.table.rowCount()
             segments = self.current_project.segments
+            total_segments = len(segments)
             
             # Pre-compute lowercase filter texts
             source_filter_lower = source_filter_text.lower() if source_filter_text else None
             target_filter_lower = target_filter_text.lower() if target_filter_text else None
             
-            for row in range(row_count):
-                if row >= len(segments):
+            # IMPORTANT: Always search through ALL segments, not just visible rows
+            # Pagination state should not affect which segments we search
+            for row in range(total_segments):
+                if row >= total_segments:
                     break
                     
                 segment = segments[row]
@@ -35221,11 +36180,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         except Exception as e:
             QMessageBox.warning(self, "Error", f"Could not open api_keys.txt: {str(e)}")
     
-    def _go_to_settings_tab(self):
-        """Navigate to Settings tab (from menu)"""
+    def _go_to_settings_tab(self, subtab_name: str = None):
+        """Navigate to Settings tab (from menu), optionally to a specific sub-tab
+        
+        Args:
+            subtab_name: Name of the sub-tab to navigate to (e.g., "AI Settings")
+        """
         if hasattr(self, 'main_tabs'):
-            # Main tabs: Grid=0, Project resources=1, Tools=2, Settings=3
-            self.main_tabs.setCurrentIndex(3)
+            # Main tabs: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            self.main_tabs.setCurrentIndex(4)
+            
+            # Navigate to specific sub-tab if requested
+            if subtab_name and hasattr(self, 'settings_tabs'):
+                for i in range(self.settings_tabs.count()):
+                    if subtab_name.lower() in self.settings_tabs.tabText(i).lower():
+                        self.settings_tabs.setCurrentIndex(i)
+                        
+                        # If navigating to AI Settings, scroll to bottom (API keys section)
+                        if "ai settings" in subtab_name.lower() and hasattr(self, 'ai_settings_scroll'):
+                            # Use QTimer to ensure the tab is fully rendered before scrolling
+                            from PyQt6.QtCore import QTimer
+                            QTimer.singleShot(100, lambda: self.ai_settings_scroll.verticalScrollBar().setValue(
+                                self.ai_settings_scroll.verticalScrollBar().maximum()
+                            ))
+                        break
     
     def _go_to_superlookup(self):
         """Navigate to Superlookup in Tools tab"""
@@ -35240,6 +36218,18 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         self.modules_tabs.setCurrentIndex(i)
                         break
     
+    def _navigate_to_tool(self, tool_name: str):
+        """Navigate to a specific tool in the Tools tab"""
+        if hasattr(self, 'main_tabs'):
+            # Main tabs: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            self.main_tabs.setCurrentIndex(3)  # Switch to Tools tab
+            # Then switch to the specific tool sub-tab
+            if hasattr(self, 'modules_tabs'):
+                for i in range(self.modules_tabs.count()):
+                    if tool_name in self.modules_tabs.tabText(i):
+                        self.modules_tabs.setCurrentIndex(i)
+                        break
+    
     def open_api_keys_file(self):
         """Open API keys file in system text editor"""
         api_keys_file = self.user_data_path / "api_keys.txt"
@@ -36445,7 +37435,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
                 )
                 if reply == QMessageBox.StandardButton.Yes:
-                    self._go_to_settings_tab()
+                    self._go_to_settings_tab("AI Settings")
                 return
             
             # Check if API key exists for selected provider
@@ -36804,7 +37794,19 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         return text.strip()
 
     def _quickmenu_build_custom_prompt(self, prompt_relative_path: str, source_text: str, source_lang: str, target_lang: str) -> str:
-        """Build a complete translation prompt using the chosen QuickMenu prompt as PRIMARY instructions."""
+        """Build a prompt for QuickMenu using the selected prompt as instructions.
+        
+        This is a GENERIC prompt builder (not translation-specific) that allows QuickMenu prompts
+        to do anything: explain, define, search, translate, analyze, etc.
+        
+        Supports placeholders:
+        - {{SELECTION}} or {{SOURCE_TEXT}} - The selected text
+        - {{SOURCE_LANGUAGE}} - Source language name
+        - {{TARGET_LANGUAGE}} - Target language name
+        - {{SOURCE+TARGET_CONTEXT}} - Project segments with both source and target (for proofreading)
+        - {{SOURCE_CONTEXT}} - Project segments with source only (for translation questions)
+        - {{TARGET_CONTEXT}} - Project segments with target only (for consistency/style analysis)
+        """
         if not hasattr(self, 'prompt_manager_qt') or not self.prompt_manager_qt:
             raise RuntimeError("Prompt manager not available")
 
@@ -36821,25 +37823,114 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if not prompt_content:
             raise RuntimeError("Prompt content is empty")
 
-        mode = getattr(pm, 'current_mode', None) or "single"
-        system_template = pm.get_system_template(mode)
-
-        system_template = system_template.replace("{{SOURCE_LANGUAGE}}", source_lang)
-        system_template = system_template.replace("{{TARGET_LANGUAGE}}", target_lang)
-        system_template = system_template.replace("{{SOURCE_TEXT}}", source_text)
-
-        library_prompts = "\n\n# PRIMARY INSTRUCTIONS\n\n" + prompt_content
-
-        # Keep any globally attached prompts as additional instructions
+        # Build document context if requested (three variants)
+        source_target_context = ""
+        source_only_context = ""
+        target_only_context = ""
+        
+        has_source_target = "{{SOURCE+TARGET_CONTEXT}}" in prompt_content
+        has_source_only = "{{SOURCE_CONTEXT}}" in prompt_content
+        has_target_only = "{{TARGET_CONTEXT}}" in prompt_content
+        
+        if (has_source_target or has_source_only or has_target_only) and hasattr(self, 'current_project') and self.current_project:
+            if has_source_target:
+                source_target_context = self._build_quickmenu_document_context(mode="both")
+                self.log(f"🔍 QuickMenu: Built SOURCE+TARGET context ({len(source_target_context)} chars)")
+            if has_source_only:
+                source_only_context = self._build_quickmenu_document_context(mode="source")
+                self.log(f"🔍 QuickMenu: Built SOURCE_ONLY context ({len(source_only_context)} chars)")
+            if has_target_only:
+                target_only_context = self._build_quickmenu_document_context(mode="target")
+                self.log(f"🔍 QuickMenu: Built TARGET_ONLY context ({len(target_only_context)} chars)")
+        else:
+            if has_source_target:
+                self.log("⚠️ QuickMenu: {{SOURCE+TARGET_CONTEXT}} requested but no project loaded")
+            if has_source_only:
+                self.log("⚠️ QuickMenu: {{SOURCE_CONTEXT}} requested but no project loaded")
+            if has_target_only:
+                self.log("⚠️ QuickMenu: {{TARGET_CONTEXT}} requested but no project loaded")
+
+        # Replace placeholders in the prompt content
+        prompt_content = prompt_content.replace("{{SOURCE_LANGUAGE}}", source_lang)
+        prompt_content = prompt_content.replace("{{TARGET_LANGUAGE}}", target_lang)
+        prompt_content = prompt_content.replace("{{SOURCE_TEXT}}", source_text)
+        prompt_content = prompt_content.replace("{{SELECTION}}", source_text)  # Alternative placeholder
+        prompt_content = prompt_content.replace("{{SOURCE+TARGET_CONTEXT}}", source_target_context)
+        prompt_content = prompt_content.replace("{{SOURCE_CONTEXT}}", source_only_context)
+        prompt_content = prompt_content.replace("{{TARGET_CONTEXT}}", target_only_context)
+        
+        # Debug: Log the final prompt being sent
+        self.log(f"📝 QuickMenu: Final prompt ({len(prompt_content)} chars):")
+        self.log("─" * 80)
+        self.log(prompt_content[:500] + ("..." if len(prompt_content) > 500 else ""))
+        self.log("─" * 80)
+        
+        # If the prompt doesn't contain the selection/text, append it
+        if "{{SOURCE_TEXT}}" not in prompt_data.get('content', '') and "{{SELECTION}}" not in prompt_data.get('content', ''):
+            prompt_content += f"\n\nText:\n{source_text}"
+        
+        return prompt_content
+    
+    def _build_quickmenu_document_context(self, mode: str = "both") -> str:
+        """Build document context for QuickMenu prompts.
+        
+        Args:
+            mode: One of:
+                - "both": Include both source and target text (for proofreading)
+                - "source": Include only source text (for translation/terminology questions)
+                - "target": Include only target text (for consistency/style analysis)
+        
+        Returns a formatted string with segments from the project for context.
+        Uses the 'quickmenu_context_segments' setting (default: 50% of total segments).
+        """
+        if not hasattr(self, 'current_project') or not self.current_project or not self.current_project.segments:
+            return "(No project context available)"
+        
         try:
-            for attached_content in lib.attached_prompts:
-                library_prompts += "\n\n# ADDITIONAL INSTRUCTIONS\n\n" + (attached_content or "")
-        except Exception:
-            pass
-
-        final_prompt = system_template + library_prompts
-        final_prompt += "\n\n**YOUR TRANSLATION (provide ONLY the translated text, no numbering or labels):**\n"
-        return final_prompt
+            # Get settings
+            general_prefs = self.load_general_settings()
+            context_percent = general_prefs.get('quickmenu_context_percent', 50)  # Default: 50%
+            max_context_segments = general_prefs.get('quickmenu_context_max', 100)  # Safety limit
+            
+            # Calculate how many segments to include
+            total_segments = len(self.current_project.segments)
+            num_segments = min(
+                int(total_segments * context_percent / 100),
+                max_context_segments
+            )
+            
+            if num_segments == 0:
+                return "(Document context disabled)"
+            
+            # Get segments (from start of document)
+            context_segments = self.current_project.segments[:num_segments]
+            
+            # Format segments based on mode
+            context_parts = []
+            mode_labels = {"both": "SOURCE + TARGET", "source": "SOURCE ONLY", "target": "TARGET ONLY"}
+            context_parts.append(f"=== DOCUMENT CONTEXT ({mode_labels.get(mode, 'UNKNOWN')}) ===")
+            context_parts.append(f"(Showing {num_segments} of {total_segments} segments - {context_percent}%)")
+            context_parts.append("")
+            
+            for seg in context_segments:
+                if mode == "both":
+                    # Source + Target
+                    context_parts.append(f"[{seg.id}] {seg.source}")
+                    if seg.target and seg.target.strip():
+                        context_parts.append(f"    → {seg.target}")
+                elif mode == "source":
+                    # Source only
+                    context_parts.append(f"[{seg.id}] {seg.source}")
+                elif mode == "target":
+                    # Target only (skip empty targets)
+                    if seg.target and seg.target.strip():
+                        context_parts.append(f"[{seg.id}] {seg.target}")
+                context_parts.append("")  # Blank line between segments
+            
+            return "\n".join(context_parts)
+            
+        except Exception as e:
+            return f"(Error building document context: {e})"
 
     def _quickmenu_show_result_dialog(self, title: str, output_text: str, apply_callback=None):
         from PyQt6.QtWidgets import QDialog, QVBoxLayout, QTextEdit, QDialogButtonBox, QPushButton, QApplication
@@ -36919,10 +38010,14 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             )
 
             client = LLMClient(api_key=api_key, provider=provider, model=model)
+            
+            # Use translate() with empty text and custom_prompt for generic AI completion
+            # This allows QuickMenu prompts to do anything (explain, define, search, etc.)
+            # not just translation. Same pattern as AI Assistant.
             output_text = client.translate(
-                text=input_text,
-                source_lang=source_lang,
-                target_lang=target_lang,
+                text="",  # Empty - we're using custom_prompt for everything
+                source_lang="en",  # Dummy values
+                target_lang="en",
                 custom_prompt=custom_prompt
             )
 
@@ -38672,11 +39767,26 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             return f"[MyMemory error: {str(e)}]"
     
     def load_api_keys(self) -> Dict[str, str]:
-        """Load API keys from user_data folder"""
+        """Load API keys with dev-first priority
+        
+        Priority order:
+        1. user_data_private/api_keys.txt (dev mode, gitignored)
+        2. user_data/api_keys.txt (user mode, shipped with app)
+        """
         api_keys = {}
-        api_keys_file = self.user_data_path / "api_keys.txt"
         
-        if not api_keys_file.exists():
+        # Priority 1: Dev mode (gitignored, never shipped)
+        dev_file = Path("user_data_private") / "api_keys.txt"
+        
+        # Priority 2: User mode (ships with app)
+        user_file = self.user_data_path / "api_keys.txt"
+        
+        # Check dev first, then user
+        if dev_file.exists():
+            api_keys_file = dev_file
+        elif user_file.exists():
+            api_keys_file = user_file
+        else:
             return api_keys
         
         try:
@@ -38806,9 +39916,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
     def show_autofingers(self):
         """Show AutoFingers by switching to the AutoFingers tab"""
         # Find the AutoFingers tab index and activate it
-        # AutoFingers is in Tools tab (main_tabs index 2)
+        # AutoFingers is in Tools tab (main_tabs index 3)
         if hasattr(self, 'main_tabs'):
-            self.main_tabs.setCurrentIndex(2)  # Switch to Tools tab
+            self.main_tabs.setCurrentIndex(3)  # Switch to Tools tab
             # Then switch to AutoFingers sub-tab
             if hasattr(self, 'modules_tabs'):
                 for i in range(self.modules_tabs.count()):
@@ -43493,7 +44603,7 @@ class SuperlookupTab(QWidget):
                 try:
                     # Use multiple methods to ensure cleanup
                     # Method 1: Kill by window title
-                    subprocess.run(['taskkill', '/F', '/FI', 'WINDOWTITLE eq superlookup_hotkey.ahk*'],
+                    subprocess.run(['taskkill', '/F', '/FI', 'WINDOWTITLE eq supervertaler_hotkeys.ahk*'],
                                  capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
                     
                     # Method 2: Kill AutoHotkey processes more aggressively
@@ -43505,7 +44615,7 @@ class SuperlookupTab(QWidget):
                     try:
                         for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
                             try:
-                                if 'superlookup_hotkey' in ' '.join(proc.cmdline() or []):
+                                if 'supervertaler_hotkeys' in ' '.join(proc.cmdline() or []):
                                     proc.kill()
                             except:
                                 pass
@@ -43518,8 +44628,8 @@ class SuperlookupTab(QWidget):
             ahk_exe, source = self._find_autohotkey_executable()
             
             if not ahk_exe:
-                print("[Superlookup] AutoHotkey not found.")
-                print("[Superlookup] Global hotkey (Ctrl+Alt+L) will not be available.")
+                print("[Hotkeys] AutoHotkey not found.")
+                print("[Hotkeys] Global hotkeys (Ctrl+Alt+L, Shift+Shift) will not be available.")
                 self.hotkey_registered = False
                 # Show setup dialog (deferred to avoid blocking startup) - unless user opted out
                 if self.main_window and hasattr(self.main_window, 'general_settings'):
@@ -43529,11 +44639,11 @@ class SuperlookupTab(QWidget):
                     QTimer.singleShot(2000, self._show_autohotkey_setup_dialog)
                 return
             
-            print(f"[Superlookup] Found AutoHotkey at: {ahk_exe} (source: {source})")
+            print(f"[Hotkeys] Found AutoHotkey at: {ahk_exe} (source: {source})")
             
-            ahk_script = Path(__file__).parent / "superlookup_hotkey.ahk"
-            print(f"[Superlookup] Looking for script at: {ahk_script}")
-            print(f"[Superlookup] Script exists: {ahk_script.exists()}")
+            ahk_script = Path(__file__).parent / "supervertaler_hotkeys.ahk"
+            print(f"[Hotkeys] Looking for script at: {ahk_script}")
+            print(f"[Hotkeys] Script exists: {ahk_script.exists()}")
             
             if ahk_script.exists():
                 # Start AHK script in background (hidden)
@@ -43541,16 +44651,16 @@ class SuperlookupTab(QWidget):
                                                    creationflags=subprocess.CREATE_NO_WINDOW if os.name == 'nt' else 0)
                 # Store in global variable for atexit cleanup
                 _ahk_process = self.ahk_process
-                print(f"[Superlookup] AHK hotkey registered: Ctrl+Alt+L")
+                print(f"[Hotkeys] AHK hotkeys registered (Ctrl+Alt+L, Shift+Shift)")
                 
                 # Start file watcher
                 self.start_file_watcher()
                 self.hotkey_registered = True
             else:
-                print(f"[Superlookup] AHK script not found: {ahk_script}")
+                print(f"[Hotkeys] AHK script not found: {ahk_script}")
                 self.hotkey_registered = False
         except Exception as e:
-            print(f"[Superlookup] Could not start AHK hotkey: {e}")
+            print(f"[Hotkeys] Could not start AHK hotkeys: {e}")
             self.hotkey_registered = False
     
     def start_file_watcher(self):
@@ -43633,11 +44743,11 @@ class SuperlookupTab(QWidget):
             print(f"[Superlookup] Main window type: {type(main_window).__name__}")
             print(f"[Superlookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
             
-            # Switch to Tools tab (main_tabs index 2)
-            # Tab structure: Grid=0, Project resources=1, Tools=2, Settings=3
+            # Switch to Tools tab (main_tabs index 3)
+            # Tab structure: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
             if hasattr(main_window, 'main_tabs'):
                 print(f"[Superlookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
-                main_window.main_tabs.setCurrentIndex(2)  # Tools tab is at index 2
+                main_window.main_tabs.setCurrentIndex(3)  # Tools tab
                 print(f"[Superlookup] Switched to Tools tab (index 2)")
                 QApplication.processEvents()  # Force GUI update
             else: