supervertaler 1.9.116__py3-none-any.whl → 1.9.128__py3-none-any.whl

Supervertaler.py

@@ -3,7 +3,7 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.116 (Fix all tab navigation + startup tab)
+Version: 1.9.123 (QuickMenu now supports generic AI tasks)
 Release Date: January 19, 2026
 Framework: PyQt6
 
@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.116"
+__version__ = "1.9.128"
 __phase__ = "0.9"
-__release_date__ = "2026-01-18"
+__release_date__ = "2026-01-19"
 __edition__ = "Qt"
 
 import sys
@@ -2559,7 +2559,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)
                 )
@@ -5668,6 +5668,24 @@ 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)
+    
+    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 refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
@@ -10836,6 +10854,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():
@@ -13956,6 +14006,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 {{DOCUMENT_CONTEXT}} placeholder 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
@@ -14100,7 +14189,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)
         
@@ -17098,7 +17188,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():
@@ -17157,6 +17248,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()
@@ -31042,11 +31134,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
@@ -31503,7 +31602,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:
@@ -31522,17 +31621,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,
@@ -31541,12 +31655,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"):
@@ -31842,7 +31974,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()
         
@@ -31915,52 +32047,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}'")
@@ -37564,7 +37711,17 @@ 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
+        - {{DOCUMENT_CONTEXT}} - Surrounding segments from the project for context
+        """
         if not hasattr(self, 'prompt_manager_qt') or not self.prompt_manager_qt:
             raise RuntimeError("Prompt manager not available")
 
@@ -37581,25 +37738,70 @@ 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)
+        # Build document context if requested
+        document_context = ""
+        if "{{DOCUMENT_CONTEXT}}" in prompt_content and hasattr(self, 'current_project') and self.current_project:
+            document_context = self._build_quickmenu_document_context()
 
-        library_prompts = "\n\n# PRIMARY INSTRUCTIONS\n\n" + prompt_content
-
-        # Keep any globally attached prompts as additional instructions
+        # 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("{{DOCUMENT_CONTEXT}}", document_context)
+        
+        # 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) -> str:
+        """Build document context for QuickMenu prompts.
+        
+        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_from_file()
+            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
+            context_parts = []
+            context_parts.append(f"=== DOCUMENT CONTEXT ===")
+            context_parts.append(f"(Showing {num_segments} of {total_segments} segments - {context_percent}%)")
+            context_parts.append("")
+            
+            for seg in context_segments:
+                # Source text
+                context_parts.append(f"[{seg.id}] {seg.source}")
+                # Target text if available
+                if seg.target and seg.target.strip():
+                    context_parts.append(f"    → {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
@@ -37679,10 +37881,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
             )
 

modules/shortcut_manager.py

@@ -18,9 +18,15 @@ class ShortcutManager:
         "file_new": {
             "category": "File",
             "description": "New Project",
-            "default": "Ctrl+N",
+            "default": "",
             "action": "new_project"
         },
+        "editor_focus_notes": {
+            "category": "Edit",
+            "description": "Focus Segment Note Tab (Ctrl+N)",
+            "default": "Ctrl+N",
+            "action": "focus_segment_notes"
+        },
         "file_open": {
             "category": "File",
             "description": "Open Project",
@@ -542,6 +548,13 @@ class ShortcutManager:
             "action": "copy_source_to_target",
             "context": "grid_editor"
         },
+        "editor_add_to_dictionary": {
+            "category": "Editor",
+            "description": "Add word at cursor to custom dictionary",
+            "default": "Alt+D",
+            "action": "add_word_to_dictionary",
+            "context": "grid_editor"
+        },
         
         # Filter Operations
         "filter_selected_text": {

modules/termview_widget.py

@@ -941,13 +941,20 @@ class TermviewWidget(QWidget):
                     for quote_char in '\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A':
                         normalized_text = normalized_text.replace(quote_char, ' ')
                     
+                    # CRITICAL FIX v1.9.118: Strip punctuation from glossary term before matching
+                    # This allows entries like "...problemen." (with period) to match source text
+                    # where tokenization strips the period during word splitting
+                    # Comprehensive set of quote and punctuation characters to strip
+                    PUNCT_CHARS = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A'
+                    normalized_term = source_lower.rstrip(PUNCT_CHARS).lstrip(PUNCT_CHARS)
+                    
                     # Use word boundaries to match complete words/phrases only
                     if ' ' in source_term:
                         # Multi-word term - must exist as exact phrase
-                        pattern = r'\b' + re.escape(source_lower) + r'\b'
+                        pattern = r'\b' + re.escape(normalized_term) + r'\b'
                     else:
                         # Single word
-                        pattern = r'\b' + re.escape(source_lower) + r'\b'
+                        pattern = r'\b' + re.escape(normalized_term) + r'\b'
                     
                     # Try matching on normalized text first, then original
                     if not re.search(pattern, normalized_text) and not re.search(pattern, text_lower):

modules/unified_prompt_library.py

@@ -171,11 +171,14 @@ class UnifiedPromptLibrary:
             # Backward compatibility: quick_run is the legacy field; internally we
             # treat it as the "QuickMenu (future app menu)" flag.
             prompt_data.setdefault('quick_run', False)
-            prompt_data['quickmenu_quickmenu'] = bool(
-                prompt_data.get('quickmenu_quickmenu', prompt_data.get('quick_run', False))
+            # Support legacy quickmenu_quickmenu field (rename to sv_quickmenu)
+            if 'quickmenu_quickmenu' in prompt_data:
+                prompt_data['sv_quickmenu'] = prompt_data['quickmenu_quickmenu']
+            prompt_data['sv_quickmenu'] = bool(
+                prompt_data.get('sv_quickmenu', prompt_data.get('quick_run', False))
             )
             # Keep legacy field in sync so older code/versions still behave.
-            prompt_data['quick_run'] = bool(prompt_data['quickmenu_quickmenu'])
+            prompt_data['quick_run'] = bool(prompt_data['sv_quickmenu'])
 
             # New QuickMenu fields
             prompt_data.setdefault('quickmenu_grid', False)
@@ -270,7 +273,7 @@ class UnifiedPromptLibrary:
                 'name', 'description', 'domain', 'version', 'task_type', 
                 'favorite',
                 # QuickMenu
-                'quickmenu_label', 'quickmenu_grid', 'quickmenu_quickmenu',
+                'quickmenu_label', 'quickmenu_grid', 'sv_quickmenu',
                 # Legacy (kept for backward compatibility)
                 'quick_run',
                 'folder', 'tags',
@@ -309,8 +312,8 @@ class UnifiedPromptLibrary:
             prompt_data['_relative_path'] = relative_path
 
             # Keep legacy field in sync
-            if 'quickmenu_quickmenu' in prompt_data:
-                prompt_data['quick_run'] = bool(prompt_data.get('quickmenu_quickmenu', False))
+            if 'sv_quickmenu' in prompt_data:
+                prompt_data['quick_run'] = bool(prompt_data.get('sv_quickmenu', False))
             self.prompts[relative_path] = prompt_data
             
             self.log(f"✓ Saved prompt: {prompt_data.get('name', relative_path)}")
@@ -456,8 +459,8 @@ class UnifiedPromptLibrary:
             return False
         
         prompt_data = self.prompts[relative_path]
-        new_value = not bool(prompt_data.get('quickmenu_quickmenu', prompt_data.get('quick_run', False)))
-        prompt_data['quickmenu_quickmenu'] = new_value
+        new_value = not bool(prompt_data.get('sv_quickmenu', prompt_data.get('quick_run', False)))
+        prompt_data['sv_quickmenu'] = new_value
         prompt_data['quick_run'] = new_value  # keep legacy in sync
         prompt_data['modified'] = datetime.now().strftime("%Y-%m-%d")
         
@@ -493,7 +496,7 @@ class UnifiedPromptLibrary:
         """Update cached QuickMenu (future app menu) list (legacy name: quick_run)."""
         self._quick_run = []
         for path, data in self.prompts.items():
-            is_enabled = bool(data.get('quickmenu_quickmenu', data.get('quick_run', False)))
+            is_enabled = bool(data.get('sv_quickmenu', data.get('quick_run', False)))
             if not is_enabled:
                 continue
             label = (data.get('quickmenu_label') or data.get('name') or Path(path).stem).strip()

modules/unified_prompt_manager_qt.py

@@ -18,7 +18,7 @@ from PyQt6.QtWidgets import (
     QTextEdit, QPlainTextEdit, QSplitter, QGroupBox, QMessageBox, QFileDialog,
     QInputDialog, QLineEdit, QFrame, QMenu, QCheckBox, QSizePolicy, QScrollArea, QTabWidget,
     QListWidget, QListWidgetItem, QStyledItemDelegate, QStyleOptionViewItem, QApplication, QDialog,
-    QAbstractItemView
+    QAbstractItemView, QTableWidget, QTableWidgetItem, QHeaderView
 )
 from PyQt6.QtCore import Qt, QSettings, pyqtSignal, QThread, QSize, QRect, QRectF
 from PyQt6.QtGui import QFont, QColor, QAction, QIcon, QPainter, QPen, QBrush, QPainterPath, QLinearGradient
@@ -31,6 +31,89 @@ from modules.ai_file_viewer_dialog import FileViewerDialog, FileRemoveConfirmDia
 from modules.ai_actions import AIActionSystem
 
 
+class CheckmarkCheckBox(QCheckBox):
+    """Custom checkbox with green background and white checkmark when checked"""
+    
+    def __init__(self, text="", parent=None):
+        super().__init__(text, parent)
+        self.setCheckable(True)
+        self.setEnabled(True)
+        self.setStyleSheet("""
+            QCheckBox {
+                font-size: 9pt;
+                spacing: 6px;
+            }
+            QCheckBox::indicator {
+                width: 16px;
+                height: 16px;
+                border: 2px solid #999;
+                border-radius: 3px;
+                background-color: white;
+            }
+            QCheckBox::indicator:checked {
+                background-color: #4CAF50;
+                border-color: #4CAF50;
+            }
+            QCheckBox::indicator:hover {
+                border-color: #666;
+            }
+            QCheckBox::indicator:checked:hover {
+                background-color: #45a049;
+                border-color: #45a049;
+            }
+        """)
+    
+    def paintEvent(self, event):
+        """Override paint event to draw white checkmark when checked"""
+        super().paintEvent(event)
+        
+        if self.isChecked():
+            # Get the indicator rectangle using QStyle
+            from PyQt6.QtWidgets import QStyleOptionButton
+            from PyQt6.QtCore import QPointF
+            
+            opt = QStyleOptionButton()
+            self.initStyleOption(opt)
+            indicator_rect = self.style().subElementRect(
+                self.style().SubElement.SE_CheckBoxIndicator,
+                opt,
+                self
+            )
+            
+            if indicator_rect.isValid():
+                # Draw white checkmark
+                painter = QPainter(self)
+                painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+                pen_width = max(2.0, min(indicator_rect.width(), indicator_rect.height()) * 0.12)
+                painter.setPen(QPen(QColor(255, 255, 255), pen_width, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap, Qt.PenJoinStyle.RoundJoin))
+                painter.setBrush(QColor(255, 255, 255))
+                
+                # Draw checkmark (✓ shape) - coordinates relative to indicator
+                x = indicator_rect.x()
+                y = indicator_rect.y()
+                w = indicator_rect.width()
+                h = indicator_rect.height()
+                
+                # Add padding (15% on all sides)
+                padding = min(w, h) * 0.15
+                x += padding
+                y += padding
+                w -= padding * 2
+                h -= padding * 2
+                
+                # Checkmark path
+                check_x1 = x + w * 0.10
+                check_y1 = y + h * 0.50
+                check_x2 = x + w * 0.35
+                check_y2 = y + h * 0.70
+                check_x3 = x + w * 0.90
+                check_y3 = y + h * 0.25
+                
+                # Draw two lines forming the checkmark
+                painter.drawLine(QPointF(check_x2, check_y2), QPointF(check_x3, check_y3))
+                painter.drawLine(QPointF(check_x1, check_y1), QPointF(check_x2, check_y2))
+
+
 class PromptLibraryTreeWidget(QTreeWidget):
     """Tree widget that supports drag-and-drop moves for prompt files."""
 
@@ -563,6 +646,10 @@ class UnifiedPromptManagerQt:
         assistant_tab = self._create_ai_assistant_tab()
         self.sub_tabs.addTab(assistant_tab, "✨ AI Assistant")
 
+        # Tab 3: Placeholders Reference
+        placeholders_tab = self._create_placeholders_tab()
+        self.sub_tabs.addTab(placeholders_tab, "📝 Placeholders")
+
         # Connect tab change signal to update context
         self.sub_tabs.currentChanged.connect(self._on_tab_changed)
 
@@ -764,6 +851,143 @@ class UnifiedPromptManagerQt:
         
         return tab
     
+    def _create_placeholders_tab(self) -> QWidget:
+        """Create the Placeholders Reference sub-tab"""
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        layout.setContentsMargins(10, 10, 10, 10)
+        layout.setSpacing(5)
+        
+        # Header (matches standard tool style: Superbench, AutoFingers, TMX Editor)
+        header = QLabel("📝 Available Placeholders")
+        header.setStyleSheet("font-size: 16pt; font-weight: bold; color: #1976D2;")
+        layout.addWidget(header, 0)
+        
+        # Description box (matches standard tool style)
+        description = QLabel(
+            "Use these placeholders in your prompts. They will be replaced with actual values when the prompt runs."
+        )
+        description.setWordWrap(True)
+        description.setStyleSheet("color: #666; padding: 5px; background-color: #E3F2FD; border-radius: 3px;")
+        layout.addWidget(description, 0)
+        
+        # Horizontal splitter for table and tips
+        splitter = QSplitter(Qt.Orientation.Horizontal)
+        splitter.setHandleWidth(3)
+        
+        # Left: Table with placeholders
+        table = QTableWidget()
+        table.setColumnCount(3)
+        table.setHorizontalHeaderLabels(["Placeholder", "Description", "Example"])
+        table.horizontalHeader().setStretchLastSection(True)
+        table.verticalHeader().setVisible(False)
+        table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
+        table.setAlternatingRowColors(True)
+        
+        # Placeholder data
+        placeholders = [
+            (
+                "{{SELECTION}}",
+                "Currently selected text in the grid (source or target cell)",
+                "If you select 'translation memory' in the grid, this will contain that text"
+            ),
+            (
+                "{{SOURCE_TEXT}}",
+                "Full text of the current source segment",
+                "The complete source sentence/paragraph from the active segment"
+            ),
+            (
+                "{{SOURCE_LANGUAGE}}",
+                "Project's source language",
+                "Dutch, English, German, French, etc."
+            ),
+            (
+                "{{TARGET_LANGUAGE}}",
+                "Project's target language",
+                "English, Spanish, Portuguese, etc."
+            ),
+            (
+                "{{DOCUMENT_CONTEXT}}",
+                "Formatted list of project segments (configurable % in Settings → AI Settings)",
+                "[1] Source text\\n    → Target text\\n\\n[2] Source text\\n    → Target text\\n\\n..."
+            )
+        ]
+        
+        table.setRowCount(len(placeholders))
+        for row, (placeholder, description, example) in enumerate(placeholders):
+            # Placeholder column (monospace, bold)
+            item_placeholder = QTableWidgetItem(placeholder)
+            item_placeholder.setFont(QFont("Courier New", 10, QFont.Weight.Bold))
+            table.setItem(row, 0, item_placeholder)
+            
+            # Description column
+            item_desc = QTableWidgetItem(description)
+            item_desc.setToolTip(description)
+            table.setItem(row, 1, item_desc)
+            
+            # Example column (monospace, italic)
+            item_example = QTableWidgetItem(example)
+            item_example.setFont(QFont("Courier New", 9))
+            item_example.setToolTip(example)
+            table.setItem(row, 2, item_example)
+        
+        # Set column widths
+        table.setColumnWidth(0, 200)
+        table.setColumnWidth(1, 300)
+        header = table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeMode.Fixed)
+        header.setSectionResizeMode(1, QHeaderView.ResizeMode.Interactive)
+        header.setSectionResizeMode(2, QHeaderView.ResizeMode.Stretch)
+        
+        # Adjust row heights for readability
+        for row in range(table.rowCount()):
+            table.setRowHeight(row, 60)
+        
+        splitter.addWidget(table)
+        
+        # Right: Usage tips panel
+        tips_panel = QWidget()
+        tips_layout = QVBoxLayout(tips_panel)
+        tips_layout.setContentsMargins(10, 0, 0, 0)
+        
+        tips_header = QLabel("💡 Usage Tips")
+        tips_header.setStyleSheet("font-weight: bold; font-size: 11pt; color: #2196F3; margin-bottom: 8px;")
+        tips_layout.addWidget(tips_header)
+        
+        tips_intro = QLabel(
+            "Use these placeholders in your prompts. They will be replaced with actual values when the prompt runs."
+        )
+        tips_intro.setWordWrap(True)
+        tips_intro.setStyleSheet("color: #666; margin-bottom: 15px; font-style: italic;")
+        tips_layout.addWidget(tips_intro)
+        
+        tips_text = QLabel(
+            "• Placeholders are case-sensitive (use UPPERCASE)\n\n"
+            "• Surround placeholders with double curly braces: {{ }}\n\n"
+            "• You can combine multiple placeholders in one prompt\n\n"
+            "• Use {{DOCUMENT_CONTEXT}} for context-aware translations\n\n"
+            "• Configure {{DOCUMENT_CONTEXT}} percentage in Settings → AI Settings"
+        )
+        tips_text.setWordWrap(True)
+        tips_text.setStyleSheet("color: #666; line-height: 1.6;")
+        tips_layout.addWidget(tips_text)
+        
+        tips_layout.addStretch()
+        
+        tips_panel.setMinimumWidth(280)
+        tips_panel.setMaximumWidth(400)
+        splitter.addWidget(tips_panel)
+        
+        # Set splitter proportions (75% table, 25% tips)
+        splitter.setSizes([750, 250])
+        splitter.setStretchFactor(0, 1)  # Table expands
+        splitter.setStretchFactor(1, 0)  # Tips panel fixed-ish
+        
+        layout.addWidget(splitter, 1)  # 1 = stretch to fill all available space
+        
+        return tab
+    
     def _create_context_sidebar(self) -> QWidget:
         """Create context sidebar showing available resources"""
         panel = QWidget()
@@ -1470,10 +1694,10 @@ class UnifiedPromptManagerQt:
         self.editor_quickmenu_label_input.setPlaceholderText("Label shown in QuickMenu")
         quickmenu_layout.addWidget(self.editor_quickmenu_label_input, 2)
 
-        self.editor_quickmenu_in_grid_cb = QCheckBox("Show in Grid right-click QuickMenu")
+        self.editor_quickmenu_in_grid_cb = CheckmarkCheckBox("Show in Grid right-click QuickMenu")
         quickmenu_layout.addWidget(self.editor_quickmenu_in_grid_cb, 2)
 
-        self.editor_quickmenu_in_quickmenu_cb = QCheckBox("Show in QuickMenu")
+        self.editor_quickmenu_in_quickmenu_cb = CheckmarkCheckBox("Show in Supervertaler QuickMenu")
         quickmenu_layout.addWidget(self.editor_quickmenu_in_quickmenu_cb, 1)
 
         layout.addLayout(quickmenu_layout)
@@ -1950,7 +2174,7 @@ class UnifiedPromptManagerQt:
                     indicators = []
                     if prompt_data.get('favorite'):
                         indicators.append("⭐")
-                    if prompt_data.get('quickmenu_quickmenu', prompt_data.get('quick_run', False)):
+                    if prompt_data.get('sv_quickmenu', prompt_data.get('quick_run', False)):
                         indicators.append("⚡")
                     if prompt_data.get('quickmenu_grid', False):
                         indicators.append("🖱️")
@@ -2018,7 +2242,7 @@ class UnifiedPromptManagerQt:
             action_fav.triggered.connect(lambda: self._toggle_favorite(path))
             
             # Toggle QuickMenu (legacy: quick_run)
-            if prompt_data.get('quickmenu_quickmenu', prompt_data.get('quick_run', False)):
+            if prompt_data.get('sv_quickmenu', prompt_data.get('quick_run', False)):
                 action_qr = menu.addAction("⚡ Remove from QuickMenu")
             else:
                 action_qr = menu.addAction("⚡ Add to QuickMenu")
@@ -2070,7 +2294,7 @@ class UnifiedPromptManagerQt:
         if hasattr(self, 'editor_quickmenu_in_grid_cb'):
             self.editor_quickmenu_in_grid_cb.setChecked(bool(prompt_data.get('quickmenu_grid', False)))
         if hasattr(self, 'editor_quickmenu_in_quickmenu_cb'):
-            self.editor_quickmenu_in_quickmenu_cb.setChecked(bool(prompt_data.get('quickmenu_quickmenu', prompt_data.get('quick_run', False))))
+            self.editor_quickmenu_in_quickmenu_cb.setChecked(bool(prompt_data.get('sv_quickmenu', prompt_data.get('quick_run', False))))
         self.editor_content.setPlainText(prompt_data.get('content', ''))
         
         # Store current path for saving
@@ -2083,119 +2307,127 @@ class UnifiedPromptManagerQt:
     
     def _save_current_prompt(self):
         """Save currently edited prompt"""
-        name = self.editor_name_input.text().strip()
-        description = self.editor_desc_input.text().strip()
-        content = self.editor_content.toPlainText().strip()
-        
-        # Name field now represents the complete filename with extension
-        # No stripping needed - user sees and edits the full filename
-
-        quickmenu_label = ''
-        quickmenu_grid = False
-        quickmenu_quickmenu = False
-        if hasattr(self, 'editor_quickmenu_label_input'):
-            quickmenu_label = self.editor_quickmenu_label_input.text().strip()
-        if hasattr(self, 'editor_quickmenu_in_grid_cb'):
-            quickmenu_grid = bool(self.editor_quickmenu_in_grid_cb.isChecked())
-        if hasattr(self, 'editor_quickmenu_in_quickmenu_cb'):
-            quickmenu_quickmenu = bool(self.editor_quickmenu_in_quickmenu_cb.isChecked())
-
-        if not name or not content:
-            QMessageBox.warning(self.main_widget, "Error", "Name and content are required")
-            return
-
-        # Check if this is a new prompt or editing existing
-        if hasattr(self, 'editor_current_path') and self.editor_current_path:
-            path = self.editor_current_path
-            
-            # Handle external prompts (save back to external file)
-            if path.startswith("[EXTERNAL] "):
-                external_file_path = path[11:]  # Remove "[EXTERNAL] " prefix
-                self._save_external_prompt(external_file_path, name, description, content)
-                return
+        try:
+            name = self.editor_name_input.text().strip()
+            description = self.editor_desc_input.text().strip()
+            content = self.editor_content.toPlainText().strip()
             
-            # Editing existing library prompt
-            if path not in self.library.prompts:
-                QMessageBox.warning(self.main_widget, "Error", "Prompt no longer exists")
+            # Name field now represents the complete filename with extension
+            # No stripping needed - user sees and edits the full filename
+
+            quickmenu_label = ''
+            quickmenu_grid = False
+            sv_quickmenu = False
+            if hasattr(self, 'editor_quickmenu_label_input'):
+                quickmenu_label = self.editor_quickmenu_label_input.text().strip()
+            if hasattr(self, 'editor_quickmenu_in_grid_cb'):
+                quickmenu_grid = bool(self.editor_quickmenu_in_grid_cb.isChecked())
+            if hasattr(self, 'editor_quickmenu_in_quickmenu_cb'):
+                sv_quickmenu = bool(self.editor_quickmenu_in_quickmenu_cb.isChecked())
+
+            if not name or not content:
+                QMessageBox.warning(self.main_widget, "Error", "Name and content are required")
                 return
 
-            prompt_data = self.library.prompts[path].copy()
-            old_filename = Path(path).name
-            
-            # Extract name without extension for metadata
-            name_without_ext = Path(name).stem
-            
-            prompt_data['name'] = name_without_ext
-            prompt_data['description'] = description
-            prompt_data['content'] = content
-            prompt_data['quickmenu_label'] = quickmenu_label or name_without_ext
-            prompt_data['quickmenu_grid'] = quickmenu_grid
-            prompt_data['quickmenu_quickmenu'] = quickmenu_quickmenu
-            # Keep legacy field in sync
-            prompt_data['quick_run'] = quickmenu_quickmenu
-            
-            # Check if filename changed - need to rename file
-            if old_filename != name:
-                from pathlib import Path
-                old_path = Path(path)
-                folder = str(old_path.parent) if old_path.parent != Path('.') else ''
-                new_path = f"{folder}/{name}" if folder else name
+            # Check if this is a new prompt or editing existing
+            if hasattr(self, 'editor_current_path') and self.editor_current_path:
+                path = self.editor_current_path
                 
-                # Delete old file and save to new location
-                if self.library.delete_prompt(path):
-                    if self.library.save_prompt(new_path, prompt_data):
-                        self.library.load_all_prompts()
-                        self._refresh_tree()
-                        self._select_and_reveal_prompt(new_path)
-                        self.editor_current_path = new_path  # Update to new path
-                        QMessageBox.information(self.main_widget, "Saved", f"Prompt renamed to '{name}' successfully!")
-                        self.log_message(f"✓ Renamed prompt: {old_filename} → {name}")
+                # Handle external prompts (save back to external file)
+                if path.startswith("[EXTERNAL] "):
+                    external_file_path = path[11:]  # Remove "[EXTERNAL] " prefix
+                    self._save_external_prompt(external_file_path, name, description, content)
+                    return
+                
+                # Editing existing library prompt
+                if path not in self.library.prompts:
+                    QMessageBox.warning(self.main_widget, "Error", "Prompt no longer exists")
+                    return
+
+                prompt_data = self.library.prompts[path].copy()
+                old_filename = Path(path).name
+                
+                # Extract name without extension for metadata
+                name_without_ext = Path(name).stem
+                
+                prompt_data['name'] = name_without_ext
+                prompt_data['description'] = description
+                prompt_data['content'] = content
+                prompt_data['quickmenu_label'] = quickmenu_label or name_without_ext
+                prompt_data['quickmenu_grid'] = quickmenu_grid
+                prompt_data['sv_quickmenu'] = sv_quickmenu
+                # Keep legacy field in sync
+                prompt_data['quick_run'] = sv_quickmenu
+                
+                # Check if filename changed - need to rename file
+                if old_filename != name:
+                    old_path = Path(path)
+                    folder = str(old_path.parent) if old_path.parent != Path('.') else ''
+                    new_path = f"{folder}/{name}" if folder else name
+                    
+                    # Delete old file and save to new location
+                    if self.library.delete_prompt(path):
+                        if self.library.save_prompt(new_path, prompt_data):
+                            self.library.load_all_prompts()
+                            self._refresh_tree()
+                            self._select_and_reveal_prompt(new_path)
+                            self.editor_current_path = new_path  # Update to new path
+                            QMessageBox.information(self.main_widget, "Saved", f"Prompt renamed to '{name}' successfully!")
+                            self.log_message(f"✓ Renamed prompt: {old_filename} → {name}")
+                        else:
+                            QMessageBox.warning(self.main_widget, "Error", "Failed to rename prompt")
                     else:
-                        QMessageBox.warning(self.main_widget, "Error", "Failed to rename prompt")
+                        QMessageBox.warning(self.main_widget, "Error", "Failed to delete old prompt file")
                 else:
-                    QMessageBox.warning(self.main_widget, "Error", "Failed to delete old prompt file")
+                    # Name unchanged, just update in place
+                    if self.library.save_prompt(path, prompt_data):
+                        QMessageBox.information(self.main_widget, "Saved", "Prompt updated successfully!")
+                        self._refresh_tree()
+                    else:
+                        QMessageBox.warning(self.main_widget, "Error", "Failed to save prompt")
             else:
-                # Name unchanged, just update in place
-                if self.library.save_prompt(path, prompt_data):
-                    QMessageBox.information(self.main_widget, "Saved", "Prompt updated successfully!")
+                # Creating new prompt
+                folder = getattr(self, 'editor_target_folder', 'Project Prompts')
+
+                # Create new prompt data
+                from datetime import datetime
+                prompt_data = {
+                    'name': name,
+                    'description': description,
+                    'content': content,
+                    'domain': '',
+                    'version': '1.0',
+                    'task_type': 'Translation',
+                    'favorite': False,
+                    # QuickMenu
+                    'quickmenu_label': quickmenu_label or name,
+                    'quickmenu_grid': quickmenu_grid,
+                    'sv_quickmenu': sv_quickmenu,
+                    # Legacy
+                    'quick_run': sv_quickmenu,
+                    'folder': folder,
+                    'tags': [],
+                    'created': datetime.now().strftime('%Y-%m-%d'),
+                    'modified': datetime.now().strftime('%Y-%m-%d')
+                }
+
+                # Create the prompt file (save_prompt creates new file if it doesn't exist)
+                relative_path = f"{folder}/{name}.svprompt"
+                if self.library.save_prompt(relative_path, prompt_data):
+                    QMessageBox.information(self.main_widget, "Created", f"Prompt '{name}' created successfully!")
+                    self.library.load_all_prompts()  # Reload to get new prompt in memory
                     self._refresh_tree()
+                    self.editor_current_path = relative_path  # Now editing this prompt
                 else:
-                    QMessageBox.warning(self.main_widget, "Error", "Failed to save prompt")
-        else:
-            # Creating new prompt
-            folder = getattr(self, 'editor_target_folder', 'Project Prompts')
-
-            # Create new prompt data
-            from datetime import datetime
-            prompt_data = {
-                'name': name,
-                'description': description,
-                'content': content,
-                'domain': '',
-                'version': '1.0',
-                'task_type': 'Translation',
-                'favorite': False,
-                # QuickMenu
-                'quickmenu_label': quickmenu_label or name,
-                'quickmenu_grid': quickmenu_grid,
-                'quickmenu_quickmenu': quickmenu_quickmenu,
-                # Legacy
-                'quick_run': quickmenu_quickmenu,
-                'folder': folder,
-                'tags': [],
-                'created': datetime.now().strftime('%Y-%m-%d'),
-                'modified': datetime.now().strftime('%Y-%m-%d')
-            }
-
-            # Create the prompt file (save_prompt creates new file if it doesn't exist)
-            relative_path = f"{folder}/{name}.svprompt"
-            if self.library.save_prompt(relative_path, prompt_data):
-                QMessageBox.information(self.main_widget, "Created", f"Prompt '{name}' created successfully!")
-                self.library.load_all_prompts()  # Reload to get new prompt in memory
-                self._refresh_tree()
-                self.editor_current_path = relative_path  # Now editing this prompt
-            else:
-                QMessageBox.warning(self.main_widget, "Error", "Failed to create prompt")
+                    QMessageBox.warning(self.main_widget, "Error", "Failed to create prompt")
+        
+        except Exception as e:
+            import traceback
+            error_msg = f"Prompt save error: {str(e)}\n{traceback.format_exc()}"
+            print(f"[ERROR] {error_msg}")
+            self.log_message(f"❌ Prompt save error: {str(e)}")
+            QMessageBox.critical(self.main_widget, "Save Error", f"Failed to save prompt:\n\n{str(e)}")
+            return
     
     def _save_external_prompt(self, file_path: str, name: str, description: str, content: str):
         """Save changes to an external prompt file"""
@@ -2421,7 +2653,7 @@ class UnifiedPromptManagerQt:
             'favorite': False,
             'quickmenu_label': name_without_ext,
             'quickmenu_grid': False,
-            'quickmenu_quickmenu': False,
+            'sv_quickmenu': False,
             'quick_run': False,
             'folder': folder_path,
             'tags': [],
@@ -2437,6 +2669,7 @@ class UnifiedPromptManagerQt:
             self._refresh_tree()
             self._select_and_reveal_prompt(relative_path)
             self._load_prompt_in_editor(relative_path)
+            self.btn_save_prompt.setEnabled(True)  # Ensure Save button is enabled for new prompt
             self.log_message(f"✓ Created new prompt '{name}' in folder: {folder_path}")
         else:
             QMessageBox.warning(self.main_widget, "Error", "Failed to create prompt")
@@ -2469,7 +2702,7 @@ class UnifiedPromptManagerQt:
         src_data['favorite'] = False
         src_data['quick_run'] = False
         src_data['quickmenu_grid'] = False
-        src_data['quickmenu_quickmenu'] = False
+        src_data['sv_quickmenu'] = False
         src_data['folder'] = folder
         src_data['created'] = datetime.now().strftime('%Y-%m-%d')
         src_data['modified'] = datetime.now().strftime('%Y-%m-%d')

{supervertaler-1.9.116.dist-info → supervertaler-1.9.128.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervertaler
-Version: 1.9.116
+Version: 1.9.128
 Summary: Professional AI-powered translation workbench with multi-LLM support, glossary system, TM, spellcheck, voice commands, and PyQt6 interface. Batteries included (core).
 Home-page: https://supervertaler.com
 Author: Michael Beijer
@@ -71,7 +71,7 @@ Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 
-# 🚀 Supervertaler v1.9.116
+# 🚀 Supervertaler v1.9.125
 
 [![PyPI version](https://badge.fury.io/py/supervertaler.svg)](https://pypi.org/project/Supervertaler/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
@@ -79,7 +79,37 @@ Dynamic: requires-python
 
 AI-enhanced CAT tool with multi-LLM support (GPT-4, Claude, Gemini, Ollama), innovative Superlookup concordance system offering access to multiple terminology sources (TMs, glossaries, web resources, etc.), and seamless CAT tool integration (memoQ, Trados, CafeTran, Phrase).
 
-**Current Version:** v1.9.116 (January 19, 2026)
+**Current Version:** v1.9.125 (January 19, 2026)
+
+### FIXED in v1.9.125 - 🐛 Prompt Save Crash
+
+**Critical Fix:** Wrapped prompt save logic in comprehensive error handling to prevent silent crashes. Now shows detailed error messages if save fails instead of crashing the app.
+
+### ADDED in v1.9.124 - 📄 QuickMenu Document Context
+
+**Context-Aware AI Suggestions:** QuickMenu prompts can now access the full document context! Use the new `{{DOCUMENT_CONTEXT}}` placeholder to give the AI access to your project's source segments. Configure what percentage of segments to include (0-100%, default 50%) in Settings → AI Settings. Perfect for: "Suggest the best translation of '{{SELECTION}}' within the context of this project."
+
+### FIXED in v1.9.123 - 🤖 QuickMenu Generic AI Support
+
+**QuickMenu Now Works for Any Task:** Fixed bug where QuickMenu prompts were forced into translation mode. Now supports any AI task: explain terms, define concepts, suggest multiple options, analyze tone, etc.
+
+### ENHANCED in v1.9.122 - ⌨️ Ctrl+N for Quick Notes
+
+**Faster Note-Taking:** Ctrl+N now focuses the Segment Note tab and places your cursor in the notes field, ready to type. Perfect for quick proofreading notes, context reminders, or translation decisions.
+
+### FIXED in v1.9.121 - 🐛 Find & Replace Performance
+
+**Critical Fix:** v1.9.120 accidentally made Find & Replace slower (37+ seconds). v1.9.121 actually fixes it by updating cells in-place instead of recreating all widgets. Now near-instant!
+
+### OPTIMIZED in v1.9.120 - ⚡ Find & Replace Speed (BUGGY - USE v1.9.121)
+
+### ADDED in v1.9.119 - ⌨️ Alt+D Dictionary Shortcut
+
+**Quick Dictionary Addition:** Press Alt+D to instantly add misspelled words to your custom dictionary without using the right-click menu.
+
+### FIXED in v1.9.117 - 🐛 Glossary Punctuation Matching
+
+**Critical Fix:** Glossary entries with trailing punctuation (periods, quotes, etc.) now match correctly! Previously, "sentence." in glossary wouldn't match "sentence." in source text due to tokenization stripping punctuation from source but not from glossary entries.
 
 ### FIXED in v1.9.116 - 🐛 Tab Navigation & Startup
 

{supervertaler-1.9.116.dist-info → supervertaler-1.9.128.dist-info}/RECORD

@@ -1,4 +1,4 @@
-Supervertaler.py,sha256=5fxmIoIe8FTV9XFVmQ9l-BsZ9lkBwis0WZNjX0VZINw,2126515
+Supervertaler.py,sha256=SZo1QhKtxynjmTAgmUXA5js44gwWsIEZidWgrccrXp0,2137119
 modules/__init__.py,sha256=G58XleS-EJ2sX4Kehm-3N2m618_W2Es0Kg8CW_eBG7g,327
 modules/ai_actions.py,sha256=i5MJcM-7Y6CAvKUwxmxrVHeoZAVtAP7aRDdWM5KLkO0,33877
 modules/ai_attachment_manager.py,sha256=mA5ISI22qN9mH3DQFF4gOTciDyBt5xVR7sHTkgkTIlw,11361
@@ -41,7 +41,7 @@ modules/quick_access_sidebar.py,sha256=RPn5ssvYXlitNMWFZN9Yxv7So8u_z5RGNpHN6N-SF
 modules/ribbon_widget.py,sha256=QNGKxmit_oM5C5nJViadYYEzeRlIdIsla8Bzu_RNGO0,21990
 modules/sdlppx_handler.py,sha256=o6Rj_T0B94toiYlvDDwMYLSz4q6kANgegFaDK5i3yhs,33538
 modules/setup_wizard.py,sha256=1prK5GPrUU4U4CqdT3G1RA3iy8FG1Z4jgPmPPZXOOEA,13115
-modules/shortcut_manager.py,sha256=-QyDA3GjmEaytXSPEZVRaD1i0iglihRP-0su-Rrfjjw,30827
+modules/shortcut_manager.py,sha256=h8a9-ENKpXGvdTHFcemOH3GRYQVqGRQnHnQAP7xgqnY,31305
 modules/simple_segmenter.py,sha256=-V7L-tjajW1M3DADxvcYEgBu0VLJvmRQl6VB9OshiuM,4480
 modules/spellcheck_manager.py,sha256=jwduHJ66pOKv1MtzSAltxpP8LPgz11FvF6j8h7BiRZY,27592
 modules/statuses.py,sha256=t6TCA9pNZHDw3SbKTxT73uKezJhwWk9gFLr0NOgEufs,6911
@@ -59,7 +59,7 @@ modules/term_extractor.py,sha256=qPvKNCVXFTGEGwXNvvC0cfCmdb5c3WhzE38EOgKdKUI,112
 modules/termbase_entry_editor.py,sha256=iWO9CgLjMomGAqBXDsGAX7TFJvDOp2s_taS4gBL1rZY,35818
 modules/termbase_import_export.py,sha256=16IAY04IS_rgt0GH5UOUzUI5NoqAli4JMfMquxmFBm0,23552
 modules/termbase_manager.py,sha256=-PlGF6fIA7KYCteoQ8FZ_0SQZNRRBFAtLimHPbmhQ6w,44544
-modules/termview_widget.py,sha256=qaVeXPZinCzfq9QeLWWoTvu2gmsM0lwu_AQTUco-j9s,52158
+modules/termview_widget.py,sha256=KNzgQ7dEFW5ANcbCsUPHJ268MYwBmV5MQG-9GQJoobY,52745
 modules/theme_manager.py,sha256=EOI_5pM2bXAadw08bbl92TLN-w28lbw4Zi1E8vQ-kM0,16694
 modules/tm_editor_dialog.py,sha256=AzGwq4QW641uFJdF8DljLTRRp4FLoYX3Pe4rlTjQWNg,3517
 modules/tm_manager_qt.py,sha256=h2bvXkRuboHf_RRz9-5FX35GVRlpXgRDWeXyj1QWtPs,54406
@@ -72,14 +72,14 @@ modules/trados_docx_handler.py,sha256=VPRAQ73cUHs_SEj6x81z1PmSxfjnwPBp9P4fXeK3Kp
 modules/translation_memory.py,sha256=U-deNPybG2PKeEt2LSTZv0Ziu5VwxkH2BsuCCXbpalc,26453
 modules/translation_results_panel.py,sha256=DmEe0pZRSfcZFg2cWeEREK7H9vrTcPkgeuMW54Pgrys,92505
 modules/translation_services.py,sha256=lyVpWuZK1wtVtYZMDMdLoq1DHBoSaeAnp-Yejb0TlVQ,10530
-modules/unified_prompt_library.py,sha256=f9C0oTmOCCL5yzDrTpPPPWk_67uwFnH1-wOGyqaYIBA,25862
-modules/unified_prompt_manager_qt.py,sha256=x6MwpLb2hZcjhKKqkVvDNsJb5I8o2vML443hHADmQ08,160675
+modules/unified_prompt_library.py,sha256=L3do_T-7NHnC5CxJ1TDq63iVM60XLkvovDJ9g4cJmZQ,26016
+modules/unified_prompt_manager_qt.py,sha256=2EvOEryM699xJHIYJrqRSPUqpypnVJOErc-W0PfjaaQ,170988
 modules/voice_commands.py,sha256=iBb-gjWxRMLhFH7-InSRjYJz1EIDBNA2Pog8V7TtJaY,38516
 modules/voice_dictation.py,sha256=QmitXfkG-vRt5hIQATjphHdhXfqmwhzcQcbXB6aRzIg,16386
 modules/voice_dictation_lite.py,sha256=jorY0BmWE-8VczbtGrWwt1zbnOctMoSlWOsQrcufBcc,9423
-supervertaler-1.9.116.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
-supervertaler-1.9.116.dist-info/METADATA,sha256=ct3FGXY8i9w3atJ-rlfeo4-WiO1lgBbTie9H7UQSt6c,40009
-supervertaler-1.9.116.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-supervertaler-1.9.116.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
-supervertaler-1.9.116.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
-supervertaler-1.9.116.dist-info/RECORD,,
+supervertaler-1.9.128.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
+supervertaler-1.9.128.dist-info/METADATA,sha256=TeUD7EbvGmLtukvAIep4czAC7P8YNm4wLoGH244ug8U,42109
+supervertaler-1.9.128.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+supervertaler-1.9.128.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
+supervertaler-1.9.128.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
+supervertaler-1.9.128.dist-info/RECORD,,