supervertaler 1.9.153__py3-none-any.whl → 1.9.185__py3-none-any.whl

modules/termview_widget.py

@@ -172,7 +172,7 @@ class TermBlock(QWidget):
         # Get theme colors
         is_dark = self.theme_manager and self.theme_manager.current_theme.name == "Dark"
         separator_color = "#555555" if is_dark else "#CCCCCC"
-        source_text_color = "#E0E0E0" if is_dark else "#333"
+        source_text_color = "#FFFFFF" if is_dark else "#333"
         no_match_color = "#666666" if is_dark else "#ddd"
         no_match_bg = "#2A2A2A" if is_dark else "#F5F5F5"
         
@@ -224,10 +224,17 @@ class TermBlock(QWidget):
         if self.translations:
             target_text = primary_translation.get('target_term', primary_translation.get('target', ''))
             termbase_name = primary_translation.get('termbase_name', '')
-            
-            # Background color based on termbase type
-            bg_color = "#FFE5F0" if self.is_effective_project else "#D6EBFF"  # Pink for project, light blue for regular
-            hover_color = "#FFD0E8" if self.is_effective_project else "#BBDEFB"  # Slightly darker on hover
+
+            # Background color based on termbase type (theme-aware)
+            is_dark = self.theme_manager and self.theme_manager.current_theme.name == "Dark"
+            if is_dark:
+                # Dark mode: darker backgrounds
+                bg_color = "#4A2D3A" if self.is_effective_project else "#2D3E4A"  # Dark pink/blue
+                hover_color = "#5A3D4A" if self.is_effective_project else "#3D4E5A"  # Lighter on hover
+            else:
+                # Light mode: original colors
+                bg_color = "#FFE5F0" if self.is_effective_project else "#D6EBFF"  # Pink for project, light blue for regular
+                hover_color = "#FFD0E8" if self.is_effective_project else "#BBDEFB"  # Slightly darker on hover
             
             # Create horizontal layout for target + shortcut badge
             # Apply background to container so it covers both text and badge
@@ -251,9 +258,11 @@ class TermBlock(QWidget):
             target_font.setBold(self.font_bold)
             target_label.setFont(target_font)
             target_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            # Theme-aware text color
+            target_text_color = "#B0C4DE" if is_dark else "#0052A3"  # Light blue in dark mode
             target_label.setStyleSheet(f"""
                 QLabel {{
-                    color: #0052A3;
+                    color: {target_text_color};
                     padding: 0px;
                     background-color: transparent;
                     border: none;
@@ -312,11 +321,12 @@ class TermBlock(QWidget):
                     if len(self.translations) > 1:
                         count_label = QLabel(f"+{len(self.translations) - 1}")
                         count_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-                        count_label.setStyleSheet("""
-                            QLabel {
-                                color: #999;
+                        count_color = "#AAA" if is_dark else "#999"  # Lighter in dark mode
+                        count_label.setStyleSheet(f"""
+                            QLabel {{
+                                color: {count_color};
                                 font-size: 7px;
-                            }
+                            }}
                         """)
                         layout.addWidget(count_label)
                     return
@@ -336,10 +346,13 @@ class TermBlock(QWidget):
                 badge_label = QLabel(badge_text)
                 badge_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
                 badge_label.setFixedSize(badge_width, 14)
+                # Theme-aware badge colors
+                badge_bg = "#4A90E2" if is_dark else "#1976D2"  # Lighter blue in dark mode
+                badge_text_color = "#FFFFFF" if is_dark else "white"
                 badge_label.setStyleSheet(f"""
                     QLabel {{
-                        background-color: #1976D2;
-                        color: white;
+                        background-color: {badge_bg};
+                        color: {badge_text_color};
                         font-size: 9px;
                         font-weight: bold;
                         border-radius: 7px;
@@ -352,16 +365,17 @@ class TermBlock(QWidget):
                 target_layout.addWidget(badge_label)
             
             layout.addWidget(target_container)
-            
+
             # Show count if multiple translations - very compact
             if len(self.translations) > 1:
                 count_label = QLabel(f"+{len(self.translations) - 1}")
                 count_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-                count_label.setStyleSheet("""
-                    QLabel {
-                        color: #999;
+                count_color = "#AAA" if is_dark else "#999"  # Lighter in dark mode
+                count_label.setStyleSheet(f"""
+                    QLabel {{
+                        color: {count_color};
                         font-size: 7px;
-                    }
+                    }}
                 """)
                 layout.addWidget(count_label)
         else:
@@ -439,7 +453,7 @@ class NTBlock(QWidget):
         
         # Get theme colors
         is_dark = self.theme_manager and self.theme_manager.current_theme.name == "Dark"
-        source_text_color = "#E0E0E0" if is_dark else "#5D4E37"
+        source_text_color = "#FFFFFF" if is_dark else "#5D4E37"
         
         # Pastel yellow border for non-translatables
         border_color = "#E6C200"  # Darker yellow for border
@@ -515,6 +529,9 @@ class TermviewWidget(QWidget):
         self.current_target_lang = None
         self.current_project_id = None  # Store project ID for termbase priority lookup
         
+        # Debug mode - disable verbose tokenization logging by default (performance)
+        self.debug_tokenize = False
+        
         # Default font settings (will be updated from main app settings)
         self.current_font_family = "Segoe UI"
         self.current_font_size = 10
@@ -634,6 +651,17 @@ class TermviewWidget(QWidget):
             is_dark = theme.name == "Dark"
             info_label_color = "#909090" if is_dark else info_text
             self.info_label.setStyleSheet(f"color: {info_label_color}; font-size: 10px; padding: 5px;")
+
+        # Refresh term blocks to pick up new theme colors
+        if hasattr(self, '_last_termbase_matches') and hasattr(self, '_last_nt_matches') and hasattr(self, 'current_source'):
+            # Re-render with stored matches to apply new theme colors
+            if self.current_source:
+                self.update_with_matches(
+                    self.current_source,
+                    self._last_termbase_matches or [],
+                    self._last_nt_matches,
+                    self._status_hint if hasattr(self, '_status_hint') else None
+                )
     
     def set_font_settings(self, font_family: str = "Segoe UI", font_size: int = 10, bold: bool = False):
         """Update font settings for Termview
@@ -691,27 +719,31 @@ class TermviewWidget(QWidget):
                     font.setBold(self.current_font_bold)
                     block.source_label.setFont(font)
     
-    def update_with_matches(self, source_text: str, termbase_matches: List[Dict], nt_matches: List[Dict] = None):
+    def update_with_matches(self, source_text: str, termbase_matches: List[Dict], nt_matches: List[Dict] = None, status_hint: str = None):
         """
         Update the termview display with pre-computed termbase and NT matches
-        
+
         RYS-STYLE DISPLAY: Show source text as tokens with translations underneath
-        
+
         Args:
             source_text: Source segment text
             termbase_matches: List of termbase match dicts from Translation Results
             nt_matches: Optional list of NT match dicts with 'text', 'start', 'end', 'list_name' keys
+            status_hint: Optional hint about why there might be no matches (e.g., 'no_termbases_activated', 'wrong_language')
         """
         self.current_source = source_text
-        
+        # Store matches for theme refresh
+        self._last_termbase_matches = termbase_matches
+        self._last_nt_matches = nt_matches
+
         # Clear existing blocks and shortcut mappings
         self.clear_terms()
         self.shortcut_terms = {}  # Reset shortcut mappings
-        
+
         if not source_text or not source_text.strip():
             self.info_label.setText("No segment selected")
             return
-        
+
         # Strip HTML/XML tags from source text for display in TermView
         # This handles CAT tool tags like <b>, </b>, <i>, </i>, <u>, </u>, <bi>, <sub>, <sup>, <li-o>, <li-b>
         # as well as memoQ tags {1}, [2}, {3], Trados tags <1>, </1>, and Déjà Vu tags {00001}
@@ -722,17 +754,17 @@ class TermviewWidget(QWidget):
         display_text = re.sub(r'\[[^\[\]]*\}', '', display_text)  # Opening: [anything}
         display_text = re.sub(r'\{[^\{\}]*\]', '', display_text)  # Closing: {anything]
         display_text = display_text.strip()
-        
+
         # If stripping tags leaves nothing, fall back to original
         if not display_text:
             display_text = source_text
-        
+
         has_termbase = termbase_matches and len(termbase_matches) > 0
         has_nt = nt_matches and len(nt_matches) > 0
-        
-        if not has_termbase and not has_nt:
-            self.info_label.setText("No terminology or NT matches for this segment")
-            return
+
+        # Store status hint for info label (will be set at the end)
+        self._status_hint = status_hint
+        self._has_any_matches = has_termbase or has_nt
         
         # Convert termbase matches to dict for easy lookup: {source_term.lower(): [translations]}
         matches_dict = {}
@@ -820,7 +852,6 @@ class TermviewWidget(QWidget):
             
             # Check if this is a non-translatable
             if lookup_key in nt_dict:
-                # Create NT block
                 nt_block = NTBlock(token, nt_dict[lookup_key], self, theme_manager=self.theme_manager, 
                                    font_size=self.current_font_size, font_family=self.current_font_family, 
                                    font_bold=self.current_font_bold)
@@ -865,11 +896,18 @@ class TermviewWidget(QWidget):
             info_parts.append(f"{blocks_with_translations} terms")
         if blocks_with_nt > 0:
             info_parts.append(f"{blocks_with_nt} NTs")
-        
+
         if info_parts:
             self.info_label.setText(f"✓ Found {', '.join(info_parts)} in {len(tokens)} words")
         else:
-            self.info_label.setText(f"No matches in {len(tokens)} words")
+            # Show appropriate message based on status hint when no matches
+            status_hint = getattr(self, '_status_hint', None)
+            if status_hint == 'no_termbases_activated':
+                self.info_label.setText(f"No glossaries activated ({len(tokens)} words)")
+            elif status_hint == 'wrong_language':
+                self.info_label.setText(f"Glossaries don't match language pair ({len(tokens)} words)")
+            else:
+                self.info_label.setText(f"No matches in {len(tokens)} words")
     
     def get_all_termbase_matches(self, text: str) -> Dict[str, List[Dict]]:
         """
@@ -996,9 +1034,9 @@ class TermviewWidget(QWidget):
         Returns:
             List of tokens (words/phrases/numbers), with multi-word terms kept together
         """
-        # DEBUG: Log multi-word terms we're looking for
+        # DEBUG: Log multi-word terms we're looking for (only if debug_tokenize enabled)
         multi_word_terms = [k for k in matches.keys() if ' ' in k]
-        if multi_word_terms:
+        if multi_word_terms and self.debug_tokenize:
             self.log(f"🔍 Tokenize: Looking for {len(multi_word_terms)} multi-word terms:")
             for term in sorted(multi_word_terms, key=len, reverse=True)[:3]:
                 self.log(f"    - '{term}'")
@@ -1023,11 +1061,12 @@ class TermviewWidget(QWidget):
                 else:
                     pattern = r'\b' + term_escaped + r'\b'
                 
-                # DEBUG: Check if multi-word term is found
+                # DEBUG: Check if multi-word term is found (only if debug_tokenize enabled)
                 found = re.search(pattern, text_lower)
-                self.log(f"🔍 Tokenize: Pattern '{pattern}' for '{term}' → {'FOUND' if found else 'NOT FOUND'}")
-                if found:
-                    self.log(f"    Match at position {found.span()}: '{text[found.start():found.end()]}'")
+                if self.debug_tokenize:
+                    self.log(f"🔍 Tokenize: Pattern '{pattern}' for '{term}' → {'FOUND' if found else 'NOT FOUND'}")
+                    if found:
+                        self.log(f"    Match at position {found.span()}: '{text[found.start():found.end()]}'")
                 
                 # Find all matches using regex
                 for match in re.finditer(pattern, text_lower):
@@ -1040,10 +1079,11 @@ class TermviewWidget(QWidget):
                         original_term = text[pos:pos + len(term)]
                         tokens_with_positions.append((pos, len(term), original_term))
                         used_positions.update(term_positions)
-                        self.log(f"    ✅ Added multi-word token: '{original_term}' covering positions {pos}-{pos+len(term)}")
+                        if self.debug_tokenize:
+                            self.log(f"    ✅ Added multi-word token: '{original_term}' covering positions {pos}-{pos+len(term)}")
         
-        # DEBUG: Log used_positions after first pass
-        if ' ' in sorted(matches.keys(), key=len, reverse=True)[0]:
+        # DEBUG: Log used_positions after first pass (only if debug_tokenize enabled)
+        if matches and ' ' in sorted(matches.keys(), key=len, reverse=True)[0] and self.debug_tokenize:
             self.log(f"🔍 After first pass: {len(used_positions)} positions marked as used")
             self.log(f"    Used positions: {sorted(list(used_positions))[:20]}...")
         

modules/theme_manager.py

@@ -212,7 +212,10 @@ class ThemeManager:
         self.themes_file = user_data_path / "themes.json"
         self.current_theme: Theme = self.PREDEFINED_THEMES["Light (Default)"]
         self.custom_themes: Dict[str, Theme] = {}
-        
+
+        # Global UI font scale (50-200%, default 100%)
+        self.font_scale: int = 100
+
         # Load custom themes
         self.load_custom_themes()
     
@@ -289,14 +292,48 @@ class ThemeManager:
     def apply_theme(self, app: QApplication):
         """
         Apply current theme to application
-        
+
         Args:
             app: QApplication instance
         """
         theme = self.current_theme
-        
+
+        # Calculate scaled font sizes based on font_scale (default 100%)
+        base_font_size = int(10 * self.font_scale / 100)  # Base: 10pt at 100%
+        small_font_size = max(7, int(9 * self.font_scale / 100))  # Small text (status bar)
+
+        # Font scaling rules (only applied if scale != 100%)
+        font_rules = ""
+        if self.font_scale != 100:
+            font_rules = f"""
+            /* Global font scaling ({self.font_scale}%) */
+            QWidget {{ font-size: {base_font_size}pt; }}
+            QMenuBar {{ font-size: {base_font_size}pt; }}
+            QMenuBar::item {{ font-size: {base_font_size}pt; }}
+            QMenu {{ font-size: {base_font_size}pt; }}
+            QMenu::item {{ font-size: {base_font_size}pt; }}
+            QStatusBar {{ font-size: {small_font_size}pt; }}
+            QTabBar::tab {{ font-size: {base_font_size}pt; }}
+            QToolBar {{ font-size: {base_font_size}pt; }}
+            QLabel {{ font-size: {base_font_size}pt; }}
+            QCheckBox {{ font-size: {base_font_size}pt; }}
+            QRadioButton {{ font-size: {base_font_size}pt; }}
+            QComboBox {{ font-size: {base_font_size}pt; }}
+            QSpinBox {{ font-size: {base_font_size}pt; }}
+            QDoubleSpinBox {{ font-size: {base_font_size}pt; }}
+            QLineEdit {{ font-size: {base_font_size}pt; }}
+            QPushButton {{ font-size: {base_font_size}pt; }}
+            QGroupBox {{ font-size: {base_font_size}pt; }}
+            QGroupBox::title {{ font-size: {base_font_size}pt; }}
+            QTextEdit {{ font-size: {base_font_size}pt; }}
+            QPlainTextEdit {{ font-size: {base_font_size}pt; }}
+            QListWidget {{ font-size: {base_font_size}pt; }}
+            QTreeWidget {{ font-size: {base_font_size}pt; }}
+            QHeaderView::section {{ font-size: {base_font_size}pt; }}
+            """
+
         # Create and apply stylesheet - COLORS ONLY, preserves native sizes/spacing
-        stylesheet = f"""
+        stylesheet = font_rules + f"""
             /* Main window background */
             QMainWindow, QWidget {{
                 background-color: {theme.window_bg};

modules/tm_metadata_manager.py

@@ -344,19 +344,22 @@ class TMMetadataManager:
         """Check if a TM is active for a project (or global when project_id=0)"""
         if project_id is None:
             return False  # If None (not 0), default to inactive
-        
+
         try:
             cursor = self.db_manager.cursor
-            
+
+            # Check if TM is active for this project OR globally (project_id=0)
             cursor.execute("""
-                SELECT is_active FROM tm_activation 
-                WHERE tm_id = ? AND project_id = ?
+                SELECT is_active FROM tm_activation
+                WHERE tm_id = ? AND (project_id = ? OR project_id = 0)
+                ORDER BY project_id DESC
             """, (tm_db_id, project_id))
-            
-            row = cursor.fetchone()
-            if row:
-                return bool(row[0])
-            
+
+            # Return True if any activation is active (project-specific takes priority due to ORDER BY)
+            for row in cursor.fetchall():
+                if bool(row[0]):
+                    return True
+
             # If no activation record exists, TM is inactive by default
             return False
         except Exception as e:
@@ -382,20 +385,63 @@ class TMMetadataManager:
         
         try:
             cursor = self.db_manager.cursor
-            
+
             # Only return TMs that have been explicitly activated (is_active = 1)
+            # Include both project-specific activations AND global activations (project_id=0)
             cursor.execute("""
-                SELECT tm.tm_id 
+                SELECT DISTINCT tm.tm_id
                 FROM translation_memories tm
                 INNER JOIN tm_activation ta ON tm.id = ta.tm_id
-                WHERE ta.project_id = ? AND ta.is_active = 1
+                WHERE (ta.project_id = ? OR ta.project_id = 0) AND ta.is_active = 1
             """, (project_id,))
-            
+
             return [row[0] for row in cursor.fetchall()]
         except Exception as e:
             self.log(f"✗ Error fetching active tm_ids: {e}")
             return []
     
+    def get_writable_tm_ids(self, project_id: Optional[int]) -> List[str]:
+        """
+        Get list of writable tm_id strings for a project.
+        
+        Returns TMs where:
+        - The TM has an activation record for this project AND
+        - read_only = 0 (Write checkbox is enabled)
+        
+        This is used for SAVING segments to TM, separate from get_active_tm_ids()
+        which is used for READING/matching from TM.
+        
+        Returns:
+            List of tm_id strings that are writable for the project
+        """
+        if project_id is None:
+            # No project - return all writable TMs
+            try:
+                cursor = self.db_manager.cursor
+                cursor.execute("SELECT tm_id FROM translation_memories WHERE read_only = 0")
+                return [row[0] for row in cursor.fetchall()]
+            except Exception as e:
+                self.log(f"✗ Error fetching all writable tm_ids: {e}")
+                return []
+        
+        try:
+            cursor = self.db_manager.cursor
+
+            # Return TMs where Write checkbox is enabled (read_only = 0)
+            # AND the TM has an activation record for this project OR for global (project_id=0)
+            # This ensures TMs created when no project was loaded still work
+            cursor.execute("""
+                SELECT DISTINCT tm.tm_id
+                FROM translation_memories tm
+                INNER JOIN tm_activation ta ON tm.id = ta.tm_id
+                WHERE (ta.project_id = ? OR ta.project_id = 0) AND tm.read_only = 0
+            """, (project_id,))
+
+            return [row[0] for row in cursor.fetchall()]
+        except Exception as e:
+            self.log(f"✗ Error fetching writable tm_ids: {e}")
+            return []
+    
     # ========================================================================
     # PROJECT TM MANAGEMENT (similar to termbases)
     # ========================================================================

modules/translation_memory.py

@@ -123,7 +123,7 @@ class TMDatabase:
         if source_lang and target_lang:
             self.set_tm_languages(source_lang, target_lang)
         
-        # Global fuzzy threshold
+        # Global fuzzy threshold (75% minimum similarity for fuzzy matches)
         self.fuzzy_threshold = 0.75
         
         # TM metadata cache (populated from database as needed)
@@ -205,20 +205,14 @@ class TMDatabase:
         Returns:
             List of match dictionaries sorted by similarity
         """
-        print(f"[DEBUG] TMDatabase.search_all: source='{source[:50]}...', tm_ids={tm_ids}")
-        
         # Determine which TMs to search
         # If tm_ids is None or empty, search ALL TMs (don't filter by tm_id)
         if tm_ids is None and enabled_only:
             tm_ids = [tm_id for tm_id, meta in self.tm_metadata.items() if meta.get('enabled', True)]
-            print(f"[DEBUG] TMDatabase.search_all: No tm_ids provided, using from metadata: {tm_ids}")
-        
+
         # If tm_ids is still empty, set to None to search ALL TMs
         if tm_ids is not None and len(tm_ids) == 0:
             tm_ids = None
-            print(f"[DEBUG] TMDatabase.search_all: Empty tm_ids, setting to None to search ALL")
-        
-        print(f"[DEBUG] TMDatabase.search_all: Final tm_ids to search: {tm_ids}")
         
         # First try exact match
         exact_match = self.db.get_exact_match(
@@ -227,8 +221,7 @@ class TMDatabase:
             source_lang=self.source_lang,
             target_lang=self.target_lang
         )
-        print(f"[DEBUG] TMDatabase.search_all: Exact match result: {exact_match}")
-        
+
         if exact_match:
             # Format as match dictionary
             return [{
@@ -241,7 +234,6 @@ class TMDatabase:
             }]
         
         # Try fuzzy matches
-        print(f"[DEBUG] TMDatabase.search_all: Calling fuzzy search with source_lang={self.source_lang}, target_lang={self.target_lang}")
         fuzzy_matches = self.db.search_fuzzy_matches(
             source=source,
             tm_ids=tm_ids,
@@ -250,8 +242,7 @@ class TMDatabase:
             source_lang=self.source_lang,
             target_lang=self.target_lang
         )
-        print(f"[DEBUG] TMDatabase.search_all: Fuzzy search returned {len(fuzzy_matches)} matches")
-        
+
         # Format matches for UI
         formatted_matches = []
         for match in fuzzy_matches:

modules/translation_results_panel.py

@@ -1676,13 +1676,6 @@ class TranslationResultsPanel(QWidget):
         Args:
             matches_dict: Dict with keys like "NT", "MT", "TM", "Termbases"
         """
-        print(f"🎯 TranslationResultsPanel.set_matches() called with matches_dict keys: {list(matches_dict.keys())}")
-        for match_type, matches in matches_dict.items():
-            print(f"  {match_type}: {len(matches)} matches")
-            if match_type == "Termbases" and matches:
-                for i, match in enumerate(matches[:2]):  # Show first 2 for debugging
-                    print(f"    [{i}] {match.source} → {match.target}")
-        
         # Ensure CompactMatchItem has current theme_manager
         if self.theme_manager:
             CompactMatchItem.theme_manager = self.theme_manager

modules/unified_prompt_library.py

@@ -367,7 +367,7 @@ class UnifiedPromptLibrary:
         
         self.active_primary_prompt = self.prompts[relative_path]['content']
         self.active_primary_prompt_path = relative_path
-        self.log(f"✓ Set primary prompt: {self.prompts[relative_path].get('name', relative_path)}")
+        self.log(f"✓ Set custom prompt: {self.prompts[relative_path].get('name', relative_path)}")
         return True
     
     def set_external_primary_prompt(self, file_path: str) -> Tuple[bool, str]:
@@ -399,7 +399,7 @@ class UnifiedPromptLibrary:
         self.active_primary_prompt = content
         self.active_primary_prompt_path = f"[EXTERNAL] {file_path}"
         
-        self.log(f"✓ Set external primary prompt: {display_name}")
+        self.log(f"✓ Set external custom prompt: {display_name}")
         return True, display_name
     
     def attach_prompt(self, relative_path: str) -> bool:

modules/unified_prompt_manager_qt.py

@@ -1566,9 +1566,9 @@ class UnifiedPromptManagerQt:
         
         layout.addWidget(mode_frame)
         
-        # Primary Prompt
+        # Custom Prompt
         primary_layout = QHBoxLayout()
-        primary_label = QLabel("Primary Prompt ⭐:")
+        primary_label = QLabel("Custom Prompt ⭐:")
         primary_label.setFont(QFont("Segoe UI", 9, QFont.Weight.Bold))
         primary_layout.addWidget(primary_label)
         
@@ -2210,8 +2210,8 @@ class UnifiedPromptManagerQt:
         if data['type'] == 'prompt':
             path = data['path']
             
-            # Set as primary
-            action_primary = menu.addAction("⭐ Set as Primary Prompt")
+            # Set as custom prompt
+            action_primary = menu.addAction("⭐ Set as Custom Prompt")
             action_primary.triggered.connect(lambda: self._set_primary_prompt(path))
             
             # Attach/detach
@@ -2372,8 +2372,20 @@ class UnifiedPromptManagerQt:
                 else:
                     # Name unchanged, just update in place
                     if self.library.save_prompt(path, prompt_data):
+                        # Refresh active prompts if this prompt is currently active or attached
+                        # This ensures "Preview Combined" shows the updated content immediately
+                        if self.library.active_primary_prompt_path == path:
+                            # Update cached primary prompt content
+                            self.library.active_primary_prompt = self.library.prompts[path]['content']
+
+                        if path in self.library.attached_prompt_paths:
+                            # Update cached attached prompt content
+                            idx = self.library.attached_prompt_paths.index(path)
+                            self.library.attached_prompts[idx] = self.library.prompts[path]['content']
+
                         QMessageBox.information(self.main_widget, "Saved", "Prompt updated successfully!")
                         self._refresh_tree()
+                        self._update_attached_list()  # Refresh attached list to show updated names
                     else:
                         QMessageBox.warning(self.main_widget, "Error", "Failed to save prompt")
             else:
@@ -2493,7 +2505,7 @@ class UnifiedPromptManagerQt:
         self.library.active_primary_prompt_path = None
         self.primary_prompt_label.setText("[None selected]")
         self.primary_prompt_label.setStyleSheet("color: #999;")
-        self.log_message("✓ Cleared primary prompt")
+        self.log_message("✓ Cleared custom prompt")
     
     def _load_external_primary_prompt(self):
         """Load an external prompt file (not in library) as primary"""
@@ -2787,7 +2799,7 @@ class UnifiedPromptManagerQt:
         composition_parts.append(f"📏 Total prompt length: {len(combined):,} characters")
         
         if self.library.active_primary_prompt:
-            composition_parts.append(f"✓ Primary prompt attached")
+            composition_parts.append(f"✓ Custom prompt attached")
         
         if self.library.attached_prompts:
             composition_parts.append(f"✓ {len(self.library.attached_prompts)} additional prompt(s) attached")
@@ -2993,49 +3005,66 @@ If the text refers to figures (e.g., 'Figure 1A'), relevant images may be provid
     
     # === Prompt Composition (for translation) ===
     
-    def build_final_prompt(self, source_text: str, source_lang: str, target_lang: str, mode: str = None) -> str:
+    def build_final_prompt(self, source_text: str, source_lang: str, target_lang: str,
+                           mode: str = None, glossary_terms: list = None) -> str:
         """
         Build final prompt for translation using 2-layer architecture:
         1. System Prompt (auto-selected by mode)
         2. Combined prompts from library (primary + attached)
-        
+        3. Glossary terms (optional, injected before translation delimiter)
+
         Args:
             source_text: Text to translate
             source_lang: Source language
             target_lang: Target language
             mode: Override mode (if None, uses self.current_mode)
-        
+            glossary_terms: Optional list of term dicts with 'source_term' and 'target_term' keys
+
         Returns:
             Complete prompt ready for LLM
         """
         if mode is None:
             mode = self.current_mode
-        
+
         # Layer 1: System Prompt
         system_template = self.get_system_template(mode)
-        
+
         # Replace placeholders in system prompt
         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)
-        
+
         # Layer 2: Library prompts (primary + attached)
         library_prompts = ""
-        
+
         if self.library.active_primary_prompt:
-            library_prompts += "\n\n# PRIMARY INSTRUCTIONS\n\n"
+            library_prompts += "\n\n# CUSTOM PROMPT\n\n"
             library_prompts += self.library.active_primary_prompt
-        
+
         for attached_content in self.library.attached_prompts:
             library_prompts += "\n\n# ADDITIONAL INSTRUCTIONS\n\n"
             library_prompts += attached_content
-        
+
         # Combine
         final_prompt = system_template + library_prompts
-        
+
+        # Glossary injection (if terms provided)
+        if glossary_terms:
+            final_prompt += "\n\n# GLOSSARY\n\n"
+            final_prompt += "Use these approved terms in your translation:\n\n"
+            for term in glossary_terms:
+                source_term = term.get('source_term', '')
+                target_term = term.get('target_term', '')
+                if source_term and target_term:
+                    # Mark forbidden terms
+                    if term.get('forbidden'):
+                        final_prompt += f"- {source_term} → ⚠️ DO NOT USE: {target_term}\n"
+                    else:
+                        final_prompt += f"- {source_term} → {target_term}\n"
+
         # Add translation delimiter
         final_prompt += "\n\n**YOUR TRANSLATION (provide ONLY the translated text, no numbering or labels):**\n"
-        
+
         return final_prompt
     
     # ============================================================================