feat: multilingual glossary templates + inline GlossarySelector rewrite

- Enriched 8 glossary templates with 18,191 translations across 11 languages
  using LLM batch generation + back-translation validation (99.98% confirmed)
- Rewrote GlossarySelector as inline section with template creation
- Fixed sidebar duplicate (single Glossaries link with proOnly flag)
- Added glossaryId reset when sourceLang changes
- Always show GlossarySelector (locked with Pro badge for free users)
- Added source_language flag on glossary cards
- Redirected /dashboard/context to /dashboard/glossaries
- Updated import endpoint to read translations from templates
- Added enrichment script (scripts/enrich_glossary_templates.py)
- Added 6 i18n keys across all 13 locales

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

frontend/src/app/dashboard/DashboardHeader.tsx

@@ -11,7 +11,7 @@ import {
 import { cn } from '@/lib/utils';
 import { useUser } from './useUser';
 import { useLogout } from './useLogout';
-import { getNavItems } from './constants';
+import { baseNavItems } from './constants';
 import { getInitials, translateTier } from './utils';
 import { ThemeToggle } from '@/components/ui/theme-toggle';
 import { useI18n } from '@/lib/i18n';
@@ -23,7 +23,8 @@ export function DashboardHeader() {
   const { logout } = useLogout();
   const { t } = useI18n();
 
-  const navItems = getNavItems(['pro', 'business', 'enterprise'].includes(user?.tier ?? ''));
+  const isPro = ['pro', 'business', 'enterprise'].includes(user?.tier ?? '');
+  const navItems = isPro ? baseNavItems : baseNavItems.filter(item => !item.proOnly);
 
   return (
     <>

frontend/src/app/dashboard/DashboardSidebar.tsx

@@ -6,7 +6,7 @@ import { LogOut } from 'lucide-react';
 import { cn } from '@/lib/utils';
 import { useUser } from './useUser';
 import { useLogout } from './useLogout';
-import { getNavItems } from './constants';
+import { baseNavItems } from './constants';
 import { getInitials, translateTier } from './utils';
 import { ThemeToggle } from '@/components/ui/theme-toggle';
 import { useI18n } from '@/lib/i18n';
@@ -17,7 +17,8 @@ export function DashboardSidebar() {
   const { logout } = useLogout();
   const { t } = useI18n();
 
-  const navItems = getNavItems(['pro', 'business', 'enterprise'].includes(user?.tier ?? ''));
+  const isPro = ['pro', 'business', 'enterprise'].includes(user?.tier ?? '');
+  const navItems = isPro ? baseNavItems : baseNavItems.filter(item => !item.proOnly);
 
   return (
     <aside className="hidden w-72 shrink-0 border-r border-black/5 dark:border-white/5 bg-white dark:bg-[#141414] lg:flex lg:flex-col">

frontend/src/app/dashboard/constants.ts

@@ -1,4 +1,4 @@
-import { FileText, Key, BookText, User, Globe, type LucideIcon } from 'lucide-react';
+import { FileText, Key, BookText, User, type LucideIcon } from 'lucide-react';
 
 export interface NavItem {
   labelKey: string;
@@ -13,15 +13,3 @@ export const baseNavItems: NavItem[] = [
   { labelKey: 'dashboard.nav.glossaries', href: '/dashboard/glossaries', icon: BookText, proOnly: true },
   { labelKey: 'dashboard.nav.apiKeys', href: '/dashboard/api-keys', icon: Key, proOnly: true },
 ];
-
-export const proNavItem: NavItem = {
-  labelKey: 'dashboard.nav.glossaries',
-  href: '/dashboard/glossaries',
-  icon: BookText,
-  proOnly: true,
-};
-
-export function getNavItems(isPro: boolean): NavItem[] {
-  if (isPro) return [...baseNavItems, proNavItem];
-  return baseNavItems.filter(item => !item.proOnly);
-}

frontend/src/app/dashboard/context/page.tsx

@@ -1,262 +1,12 @@
 'use client';
 
-import { useState, useEffect } from 'react';
-import {
-  Zap, Save, Crown, Loader2, Trash2,
-  Wrench, HardHat, Monitor, Scale, Stethoscope, BarChart3,
-  Megaphone, Car, MessageSquare, BookOpen, CheckCircle2,
-} from 'lucide-react';
-import { useTranslationStore } from '@/lib/store';
-import { API_BASE } from '@/lib/config';
-import { useI18n } from '@/lib/i18n';
-import { useToast } from '@/components/ui/toast';
-import Link from 'next/link';
-import { cn } from '@/lib/utils';
-
-const PRESETS = [
-  { key: 'hvac', title: 'HVAC / Génie climatique', desc: 'Thermique, ventilation, climatisation', icon: Wrench, templateId: 'hvac' },
-  { key: 'construction', title: 'BTP / Construction', desc: 'Gros œuvre, second œuvre, normes', icon: HardHat, templateId: 'construction' },
-  { key: 'it', title: 'IT / Logiciel', desc: 'Développement, infrastructure, DevOps', icon: Monitor, templateId: 'technology' },
-  { key: 'legal', title: 'Juridique / Contrats', desc: 'Droit des affaires, contentieux', icon: Scale, templateId: 'legal' },
-  { key: 'medical', title: 'Médical / Santé', desc: 'Pharmacologie, chirurgie, diagnostic', icon: Stethoscope, templateId: 'medical' },
-  { key: 'finance', title: 'Finance / Comptabilité', desc: 'IFRS, bilans, fiscalité', icon: BarChart3, templateId: 'finance' },
-  { key: 'marketing', title: 'Marketing / Publicité', desc: 'Digital, branding, analytics', icon: Megaphone, templateId: 'marketing' },
-  { key: 'automotive', title: 'Automobile', desc: 'Motorisation, ADAS, homologation', icon: Car, templateId: 'automotive' },
-];
-
-export default function ContextGlossaryPage() {
-  const { t } = useI18n();
-  const { settings, updateSettings } = useTranslationStore();
-  const { toast } = useToast();
-  const [isSaving, setIsSaving] = useState(false);
-  const [isPro, setIsPro] = useState(false);
-  const [creatingPreset, setCreatingPreset] = useState<string | null>(null);
-
-  const [systemPrompt, setSystemPrompt] = useState(settings.systemPrompt);
+import { useEffect } from 'react';
+import { useRouter } from 'next/navigation';
 
+export default function ContextPage() {
+  const router = useRouter();
   useEffect(() => {
-    setSystemPrompt(settings.systemPrompt);
-  }, [settings]);
-
-  useEffect(() => {
-    const checkTier = async () => {
-      const isProTier = (user: any) => ['pro', 'business', 'enterprise'].includes(user?.plan ?? user?.tier ?? '');
-      const userStr = localStorage.getItem('user');
-      if (userStr) {
-        try {
-          const user = JSON.parse(userStr);
-          if (user?.plan || user?.tier) { setIsPro(isProTier(user)); return; }
-        } catch { /* continue */ }
-      }
-      try {
-        const token = localStorage.getItem('token');
-        if (!token) return;
-        const res = await fetch(`${API_BASE}/api/v1/auth/me`, { headers: { Authorization: `Bearer ${token}` } });
-        if (res.ok) {
-          const result = await res.json();
-          const user = result.data;
-          setIsPro(isProTier(user));
-          localStorage.setItem('user', JSON.stringify(user));
-        }
-      } catch { /* ignore */ }
-    };
-    checkTier();
-  }, []);
-
-  const handleSave = async () => {
-    setIsSaving(true);
-    try {
-      updateSettings({ systemPrompt });
-      await new Promise(resolve => setTimeout(resolve, 500));
-      toast({ title: t('context.saved'), description: t('context.savedDesc') });
-    } finally { setIsSaving(false); }
-  };
-
-  const handleClear = () => {
-    updateSettings({ systemPrompt: '' });
-    setSystemPrompt('');
-  };
-
-  const handleCreatePresetGlossary = async (preset: typeof PRESETS[0]) => {
-    setCreatingPreset(preset.key);
-    try {
-      const token = localStorage.getItem('token');
-      if (!token) return;
-      const headers: Record<string, string> = {
-        'Content-Type': 'application/json',
-        Authorization: `Bearer ${token}`,
-      };
-
-      // Import the template as a new glossary via the API
-      const params = new URLSearchParams({ template_id: preset.templateId });
-      const res = await fetch(`${API_BASE}/api/v1/glossaries/import?${params.toString()}`, {
-        method: 'POST',
-        headers,
-      });
-
-      if (res.ok) {
-        const result = await res.json();
-        const glossary = result.data;
-        toast({
-          title: t('context.presets.created'),
-          description: t('context.presets.createdDesc', {
-            name: glossary?.name ?? preset.title,
-            count: String(glossary?.terms?.length ?? 0),
-          }),
-        });
-      } else {
-        toast({
-          variant: 'destructive',
-          title: t('glossaries.toast.error'),
-          description: t('glossaries.toast.errorCreate'),
-        });
-      }
-    } catch {
-      toast({
-        variant: 'destructive',
-        title: t('glossaries.toast.error'),
-        description: t('glossaries.toast.errorImport'),
-      });
-    } finally {
-      setCreatingPreset(null);
-    }
-  };
-
-  if (!isPro) {
-    return (
-      <div className="flex flex-col items-center justify-center min-h-[60vh] gap-6 p-6">
-        <div className="w-20 h-20 bg-brand-dark dark:bg-white/10 rounded-[32px] flex items-center justify-center text-brand-accent shadow-2xl">
-          <Crown className="w-10 h-10" />
-        </div>
-        <div className="text-center space-y-2 max-w-md">
-          <h1 className="text-3xl font-black uppercase tracking-tighter text-brand-dark dark:text-white">{t('context.proTitle')}</h1>
-          <p className="text-brand-dark/40 dark:text-white/40 font-medium">{t('context.proDesc')}</p>
-        </div>
-        <Link href="/pricing">
-          <button className="premium-button px-10 py-4 text-[11px] uppercase tracking-widest !rounded-2xl flex items-center gap-2">
-            <Crown size={14} /> {t('context.viewPlans')}
-          </button>
-        </Link>
-      </div>
-    );
-  }
-
-  return (
-    <div className="max-w-5xl mx-auto w-full p-6 lg:p-8">
-      {/* ── Editorial Header ───────────────────────────────────── */}
-      <div className="mb-12">
-        <span className="accent-pill mb-4 block w-fit italic">{t('context.presets.title')}</span>
-        <h1 className="text-5xl font-black uppercase tracking-tighter mb-4 leading-none text-brand-dark dark:text-white">
-          {t('context.title')}
-        </h1>
-        <p className="text-brand-dark/40 dark:text-white/40 font-medium max-w-2xl">{t('context.subtitle')}</p>
-      </div>
-
-      <div className="space-y-12">
-        {/* ── Professional Presets ──────────────────────────────── */}
-        <section className="editorial-card p-10 lg:p-12 bg-white dark:bg-[#141414] border-none shadow-editorial">
-          <div className="flex items-center gap-4 mb-8 text-brand-accent">
-            <Zap size={20} />
-            <h3 className="text-[11px] font-black uppercase tracking-[0.3em] text-brand-dark dark:text-white">
-              {t('context.presets.title')}
-            </h3>
-          </div>
-          <p className="text-sm text-brand-dark/40 dark:text-white/40 mb-12 font-medium">{t('context.presets.desc')}</p>
-
-          <div className="grid grid-cols-2 md:grid-cols-4 gap-6">
-            {PRESETS.map((p) => {
-              const Icon = p.icon;
-              const isCreating = creatingPreset === p.key;
-              return (
-                <button
-                  key={p.key}
-                  onClick={() => handleCreatePresetGlossary(p)}
-                  disabled={!!creatingPreset}
-                  className="p-6 bg-brand-muted dark:bg-white/5 hover:bg-brand-dark dark:hover:bg-brand-dark group transition-all rounded-[32px] text-center border border-black/5 dark:border-white/10 hover:shadow-2xl hover:-translate-y-1 disabled:opacity-50 disabled:cursor-not-allowed"
-                >
-                  <div className="flex justify-center mb-4 text-brand-dark group-hover:text-brand-accent group-hover:scale-125 transition-all">
-                    {isCreating ? (
-                      <Loader2 size={24} className="animate-spin" />
-                    ) : (
-                      <Icon size={24} />
-                    )}
-                  </div>
-                  <h4 className="text-[11px] font-black uppercase tracking-tight text-brand-dark dark:text-white group-hover:text-white mb-2">
-                    {p.title}
-                  </h4>
-                  <p className="text-[8px] text-brand-dark/30 dark:text-white/30 group-hover:text-white/40 font-bold uppercase tracking-widest leading-relaxed">
-                    {p.desc}
-                  </p>
-                  <span className="inline-flex items-center gap-1 mt-3 px-3 py-1 rounded-full bg-brand-accent/10 text-brand-accent text-[8px] font-black uppercase tracking-widest opacity-0 group-hover:opacity-100 transition-opacity">
-                    <BookOpen size={10} />
-                    {t('context.presets.createGlossary')}
-                  </span>
-                </button>
-              );
-            })}
-          </div>
-
-          <p className="mt-8 text-[9px] text-brand-dark/20 dark:text-white/20 font-black uppercase tracking-widest italic border-t border-black/5 dark:border-white/5 pt-6">
-            {t('context.presets.hint')}
-          </p>
-        </section>
-
-        {/* ── Context Instructions ──────────────────────────────── */}
-        <section className="editorial-card p-10 lg:p-12 bg-white dark:bg-[#141414] border-none shadow-editorial">
-          <div className="flex items-center gap-4 mb-8 text-brand-accent">
-            <MessageSquare size={20} />
-            <h3 className="text-[11px] font-black uppercase tracking-[0.3em] text-brand-dark dark:text-white">
-              {t('context.instructions.title')}
-            </h3>
-          </div>
-          <p className="text-sm text-brand-dark/40 dark:text-white/40 mb-10 font-medium">{t('context.instructions.desc')}</p>
-          <textarea
-            value={systemPrompt}
-            onChange={e => setSystemPrompt(e.target.value)}
-            placeholder={t('context.instructions.placeholder')}
-            className="w-full h-48 p-8 bg-brand-muted dark:bg-white/5 rounded-[32px] border border-black/5 dark:border-white/10 text-sm focus:ring-2 focus:ring-brand-accent/20 focus:border-brand-accent/30 transition-all outline-none resize-y"
-          />
-          <div className="flex justify-end mt-6 gap-4">
-            <button
-              onClick={handleClear}
-              className="px-8 py-3 bg-brand-muted dark:bg-white/5 text-brand-dark/40 dark:text-white/40 rounded-xl text-[9px] font-black uppercase tracking-widest hover:text-brand-dark dark:hover:text-white transition-all"
-            >
-              <Trash2 size={12} className="inline mr-2" />{t('context.clearAll')}
-            </button>
-            <button
-              onClick={handleSave}
-              disabled={isSaving}
-              className="premium-button px-10 py-3 text-[9px] uppercase tracking-widest !rounded-xl flex items-center gap-3 disabled:opacity-50"
-            >
-              {isSaving ? <Loader2 size={14} className="animate-spin" /> : <Save size={14} />}
-              {isSaving ? t('context.saving') : t('context.save')}
-            </button>
-          </div>
-        </section>
-
-        {/* ── Glossary link ────────────────────────────────────── */}
-        <section className="editorial-card p-10 lg:p-12 bg-white dark:bg-[#141414] border-none shadow-editorial flex flex-col md:flex-row items-start md:items-center justify-between gap-6">
-          <div className="flex items-center gap-6">
-            <div className="w-14 h-14 bg-brand-muted dark:bg-white/10 rounded-2xl flex items-center justify-center text-brand-accent shrink-0">
-              <BookOpen size={28} />
-            </div>
-            <div>
-              <h3 className="text-2xl font-black uppercase tracking-tight text-brand-dark dark:text-white">
-                {t('context.glossary.title')}
-              </h3>
-              <p className="text-brand-dark/30 dark:text-white/30 text-[10px] font-black uppercase tracking-widest mt-2 leading-relaxed">
-                {t('context.glossary.desc')}
-              </p>
-            </div>
-          </div>
-          <Link href="/dashboard/glossaries">
-            <button className="premium-button px-10 py-4 text-[10px] uppercase tracking-widest !rounded-2xl flex items-center gap-3">
-              <BookOpen size={14} />
-              {t('context.glossary.manage')}
-            </button>
-          </Link>
-        </section>
-      </div>
-    </div>
-  );
+    router.replace('/dashboard/glossaries');
+  }, [router]);
+  return null;
 }

frontend/src/app/dashboard/glossaries/page.tsx

@@ -16,6 +16,7 @@ import { CreateGlossaryDialog } from './CreateGlossaryDialog';
 import { EditGlossaryDialog } from './EditGlossaryDialog';
 import { DeleteGlossaryDialog } from './DeleteGlossaryDialog';
 import { useToast } from '@/components/ui/toast';
+import { SUPPORTED_LANGUAGES } from './types';
 import { useTranslationStore } from '@/lib/store';
 import { API_BASE } from '@/lib/config';
 
@@ -353,6 +354,9 @@ export default function GlossariesPage() {
                 <h3 className="text-2xl font-black uppercase tracking-tight mb-2 text-brand-dark dark:text-white truncate">
                   {glossary.name}
                 </h3>
+                <p className="text-[10px] text-brand-dark/30 dark:text-white/30 font-bold uppercase tracking-widest mb-4">
+                  {SUPPORTED_LANGUAGES.find(l => l.code === glossary.source_language)?.flag ?? ''} {SUPPORTED_LANGUAGES.find(l => l.code === glossary.source_language)?.label ?? glossary.source_language}
+                </p>
                 <div className="flex justify-between items-center pt-8 border-t border-black/5 dark:border-white/10">
                   <span className="text-[9px] text-brand-dark/30 dark:text-white/30 font-black uppercase tracking-widest flex items-center gap-1.5">
                     <Hash size={10} />

frontend/src/app/dashboard/translate/GlossarySelector.tsx

@@ -1,7 +1,7 @@
 'use client';
 
-import { useState, useEffect } from 'react';
-import { BookText, ChevronDown } from 'lucide-react';
+import { useState, useEffect, useCallback } from 'react';
+import { BookText, Plus, Loader2, Lock, Check } from 'lucide-react';
 import { API_BASE } from '@/lib/config';
 import { useI18n } from '@/lib/i18n';
 import { cn } from '@/lib/utils';
@@ -14,112 +14,245 @@ interface GlossaryOption {
   terms_count: number;
 }
 
+interface TemplateOption {
+  id: string;
+  name: string;
+  description: string;
+  source_lang: string;
+  target_lang: string;
+  terms_count: number;
+}
+
 interface GlossarySelectorProps {
+  sourceLang: string;
+  targetLang: string;
+  isPro: boolean;
   glossaryId: string | null;
   onChange: (id: string | null) => void;
   disabled?: boolean;
 }
 
-export function GlossarySelector({ glossaryId, onChange, disabled }: GlossarySelectorProps) {
+export function GlossarySelector({ sourceLang, targetLang, isPro, glossaryId, onChange, disabled }: GlossarySelectorProps) {
   const { t } = useI18n();
   const [glossaries, setGlossaries] = useState<GlossaryOption[]>([]);
-  const [isOpen, setIsOpen] = useState(false);
-  const [isLoading, setIsLoading] = useState(true);
+  const [templates, setTemplates] = useState<TemplateOption[]>([]);
+  const [isLoadingGlossaries, setIsLoadingGlossaries] = useState(true);
+  const [isLoadingTemplates, setIsLoadingTemplates] = useState(true);
+  const [importingId, setImportingId] = useState<string | null>(null);
 
-  useEffect(() => {
-    const fetchGlossaries = async () => {
-      try {
-        const token = localStorage.getItem('token');
-        const headers: Record<string, string> = {};
-        if (token) headers['Authorization'] = `Bearer ${token}`;
-
-        const res = await fetch(`${API_BASE}/api/v1/glossaries?per_page=100`, { headers });
-        if (res.ok) {
-          const data = await res.json();
-          setGlossaries(data.data || []);
-        }
-      } catch {
-        // ignore
-      } finally {
-        setIsLoading(false);
+  const fetchGlossaries = useCallback(async () => {
+    try {
+      const token = localStorage.getItem('token');
+      const headers: Record<string, string> = {};
+      if (token) headers['Authorization'] = `Bearer ${token}`;
+      const res = await fetch(`${API_BASE}/api/v1/glossaries?per_page=100`, { headers });
+      if (res.ok) {
+        const data = await res.json();
+        setGlossaries(data.data || []);
       }
-    };
-    fetchGlossaries();
+    } catch {
+      // ignore
+    } finally {
+      setIsLoadingGlossaries(false);
+    }
   }, []);
 
-  const selected = glossaries.find(g => g.id === glossaryId);
-  const sourceFlag = SUPPORTED_LANGUAGES.find(l => l.code === selected?.source_language)?.flag ?? '';
+  const fetchTemplates = useCallback(async () => {
+    try {
+      const token = localStorage.getItem('token');
+      const headers: Record<string, string> = {};
+      if (token) headers['Authorization'] = `Bearer ${token}`;
+      const res = await fetch(`${API_BASE}/api/v1/glossaries/templates/list`, { headers });
+      if (res.ok) {
+        const data = await res.json();
+        setTemplates(data.data || []);
+      }
+    } catch {
+      // ignore
+    } finally {
+      setIsLoadingTemplates(false);
+    }
+  }, []);
 
-  if (isLoading || glossaries.length === 0) return null;
+  useEffect(() => { fetchGlossaries(); }, [fetchGlossaries]);
+  useEffect(() => { fetchTemplates(); }, [fetchTemplates]);
+
+  const handleImportTemplate = async (template: TemplateOption) => {
+    const token = localStorage.getItem('token');
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+    if (token) headers['Authorization'] = `Bearer ${token}`;
+
+    setImportingId(template.id);
+    try {
+      const res = await fetch(`${API_BASE}/api/v1/glossaries/import`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ template_id: template.id }),
+      });
+      if (res.ok) {
+        const data = await res.json();
+        const newId = data.data?.id;
+        await fetchGlossaries();
+        if (newId) onChange(newId);
+      }
+    } catch {
+      // ignore
+    } finally {
+      setImportingId(null);
+    }
+  };
+
+  const sourceFlag = SUPPORTED_LANGUAGES.find(l => l.code === sourceLang)?.flag ?? '';
+  const targetFlag = SUPPORTED_LANGUAGES.find(l => l.code === targetLang)?.flag ?? '';
+
+  // Filter glossaries by source language (show all if auto)
+  const filteredGlossaries = sourceLang === 'auto'
+    ? glossaries
+    : glossaries.filter(g => g.source_language === sourceLang);
+
+  const selected = glossaries.find(g => g.id === glossaryId);
 
   return (
-    <div className="space-y-3">
+    <div className="space-y-4">
       <label className="text-[9px] font-black text-brand-dark/40 dark:text-white/40 uppercase tracking-[0.2em] block">
         <BookText size={10} className="inline mr-1.5 text-brand-accent" />
-        {t('translate.glossary.title')}
+        {t('translate.glossary.title')} <span className="normal-case tracking-normal font-normal text-brand-dark/25 dark:text-white/25">({sourceFlag}→{targetFlag})</span>
       </label>
 
-      <div className="relative">
-        <button
-          onClick={() => !disabled && setIsOpen(!isOpen)}
-          disabled={disabled}
-          className={cn(
-            "w-full px-5 py-4 bg-brand-muted dark:bg-white/10 rounded-2xl text-[10px] font-black uppercase tracking-widest border border-black/5 dark:border-white/10 flex items-center justify-between gap-3 transition-all",
-            isOpen && "ring-2 ring-brand-accent/20 border-brand-accent/30",
-            disabled && "opacity-50 cursor-not-allowed"
-          )}
-        >
-          <span className={cn(
-            "truncate",
-            selected ? "text-brand-dark dark:text-white" : "text-brand-dark/30 dark:text-white/30"
-          )}>
-            {selected ? (
-              <>{sourceFlag} {selected.name} <span className="text-brand-dark/30 dark:text-white/30 font-normal normal-case">({selected.terms_count} {t('translate.glossary.terms')})</span></>
-            ) : (
-              t('translate.glossary.select')
-            )}
+      {!isPro ? (
+        <div className="px-5 py-4 bg-brand-muted/50 dark:bg-white/5 rounded-2xl border border-black/5 dark:border-white/10 flex items-center gap-3 opacity-70">
+          <Lock size={12} className="text-brand-dark/30 dark:text-white/30" />
+          <span className="text-[10px] font-bold text-brand-dark/40 dark:text-white/40">
+            {t('translate.glossary.proOnly')}
           </span>
-          <ChevronDown size={14} className={cn(
-            "text-brand-accent shrink-0 transition-transform",
-            isOpen && "rotate-180"
-          )} />
-        </button>
+          <span className="ml-auto px-2 py-0.5 bg-brand-accent/10 text-brand-accent text-[8px] font-black uppercase tracking-widest rounded">
+            Pro
+          </span>
+        </div>
+      ) : (
+        <div className="space-y-3">
+          {/* Selected glossary indicator */}
+          {selected && (
+            <div className="px-5 py-4 bg-brand-accent/5 dark:bg-brand-accent/10 border border-brand-accent/20 rounded-2xl flex items-center gap-3">
+              <Check size={14} className="text-brand-accent shrink-0" />
+              <span className="text-[10px] font-black uppercase tracking-widest text-brand-dark dark:text-white truncate">
+                {selected.name}
+              </span>
+              <span className="text-[9px] text-brand-dark/30 dark:text-white/30 font-normal normal-case ml-auto shrink-0">
+                ({selected.terms_count} {t('translate.glossary.terms')})
+              </span>
+              <button
+                onClick={() => onChange(null)}
+                disabled={disabled}
+                className="text-[9px] text-brand-dark/30 dark:text-white/30 hover:text-brand-dark dark:hover:text-white transition-colors ml-2"
+              >
+                ✕
+              </button>
+            </div>
+          )}
 
-        {isOpen && (
-          <div className="absolute z-50 top-full left-0 right-0 mt-2 bg-white dark:bg-[#1a1a1a] rounded-2xl border border-black/10 dark:border-white/10 shadow-xl max-h-64 overflow-y-auto">
-            {/* None option */}
-            <button
-              onClick={() => { onChange(null); setIsOpen(false); }}
-              className={cn(
-                "w-full px-5 py-3 text-left text-[10px] font-black uppercase tracking-widest hover:bg-brand-muted dark:hover:bg-white/5 transition-colors",
-                !glossaryId ? "text-brand-accent" : "text-brand-dark/30 dark:text-white/30"
-              )}
-            >
-              {t('translate.glossary.none')}
-            </button>
+          {/* My glossaries */}
+          {!isLoadingGlossaries && filteredGlossaries.length > 0 && (
+            <div className="space-y-1">
+              <span className="text-[8px] font-black text-brand-dark/25 dark:text-white/25 uppercase tracking-[0.2em] pl-1">
+                {t('translate.glossary.myGlossaries') || 'Mes glossaires'}
+              </span>
+              {filteredGlossaries.map(g => {
+                const flag = SUPPORTED_LANGUAGES.find(l => l.code === g.source_language)?.flag ?? '';
+                return (
+                  <button
+                    key={g.id}
+                    onClick={() => onChange(g.id === glossaryId ? null : g.id)}
+                    disabled={disabled}
+                    className={cn(
+                      "w-full px-4 py-3 text-left text-[10px] font-black uppercase tracking-widest rounded-xl transition-all flex items-center gap-2",
+                      g.id === glossaryId
+                        ? "bg-brand-accent/10 text-brand-accent border border-brand-accent/20"
+                        : "bg-brand-muted/50 dark:bg-white/5 text-brand-dark/60 dark:text-white/60 hover:bg-brand-accent/5 hover:text-brand-dark dark:hover:text-white border border-transparent",
+                      disabled && "opacity-50 cursor-not-allowed"
+                    )}
+                  >
+                    <span>{flag}</span>
+                    <span className="truncate">{g.name}</span>
+                    <span className="ml-auto text-brand-dark/25 dark:text-white/25 font-normal normal-case shrink-0">
+                      {g.terms_count} {t('translate.glossary.terms')}
+                    </span>
+                  </button>
+                );
+              })}
+            </div>
+          )}
 
-            {glossaries.map((g) => {
-              const flag = SUPPORTED_LANGUAGES.find(l => l.code === g.source_language)?.flag ?? '';
-              return (
-                <button
-                  key={g.id}
-                  onClick={() => { onChange(g.id); setIsOpen(false); }}
-                  className={cn(
-                    "w-full px-5 py-3 text-left text-[10px] font-black uppercase tracking-widest hover:bg-brand-muted dark:hover:bg-white/5 transition-colors border-t border-black/5 dark:border-white/5",
-                    glossaryId === g.id ? "text-brand-accent" : "text-brand-dark dark:text-white"
-                  )}
-                >
-                  <span className="mr-2">{flag}</span>
-                  {g.name}
-                  <span className="ml-2 text-brand-dark/30 dark:text-white/30 font-normal normal-case">
-                    ({g.terms_count} {t('translate.glossary.terms')})
-                  </span>
-                </button>
-              );
-            })}
-          </div>
-        )}
-      </div>
+          {/* Templates */}
+          {!isLoadingTemplates && templates.length > 0 && (
+            <div className="space-y-2 pt-2 border-t border-black/5 dark:border-white/5">
+              <span className="text-[8px] font-black text-brand-dark/25 dark:text-white/25 uppercase tracking-[0.2em] pl-1">
+                {t('translate.glossary.fromTemplate') || 'Créer depuis un template'}
+              </span>
+              <div className="grid grid-cols-2 gap-2">
+                {templates.map(tmpl => {
+                  const isImporting = importingId === tmpl.id;
+                  const alreadyExists = glossaries.some(
+                    g => g.name.toLowerCase().includes(tmpl.name.toLowerCase().split('/')[0].trim())
+                  );
+                  return (
+                    <button
+                      key={tmpl.id}
+                      onClick={() => !alreadyExists && !isImporting && handleImportTemplate(tmpl)}
+                      disabled={disabled || isImporting || alreadyExists}
+                      className={cn(
+                        "px-3 py-2.5 text-left rounded-xl transition-all flex items-center gap-2 border",
+                        alreadyExists
+                          ? "bg-brand-muted/30 dark:bg-white/5 border-black/5 dark:border-white/5 opacity-40 cursor-default"
+                          : isImporting
+                          ? "bg-brand-accent/5 border-brand-accent/20 cursor-wait"
+                          : "bg-brand-muted/50 dark:bg-white/5 border-transparent hover:border-brand-accent/20 hover:bg-brand-accent/5 cursor-pointer",
+                        disabled && "opacity-50 cursor-not-allowed"
+                      )}
+                    >
+                      {isImporting ? (
+                        <Loader2 size={12} className="text-brand-accent animate-spin shrink-0" />
+                      ) : alreadyExists ? (
+                        <Check size={12} className="text-brand-dark/30 dark:text-white/30 shrink-0" />
+                      ) : (
+                        <Plus size={12} className="text-brand-accent shrink-0" />
+                      )}
+                      <span className={cn(
+                        "text-[9px] font-black uppercase tracking-widest truncate",
+                        alreadyExists
+                          ? "text-brand-dark/30 dark:text-white/30"
+                          : "text-brand-dark/60 dark:text-white/60"
+                      )}>
+                        {tmpl.name.split('/')[0].trim()}
+                      </span>
+                    </button>
+                  );
+                })}
+              </div>
+            </div>
+          )}
+
+          {/* Loading */}
+          {(isLoadingGlossaries || isLoadingTemplates) && (
+            <div className="flex items-center gap-2 px-4 py-3 text-[10px] text-brand-dark/30 dark:text-white/30">
+              <Loader2 size={12} className="animate-spin" />
+              {t('translate.glossary.loading') || 'Chargement...'}
+            </div>
+          )}
+
+          {/* Empty state */}
+          {!isLoadingGlossaries && filteredGlossaries.length === 0 && !selected && (
+            <p className="text-[10px] text-brand-dark/25 dark:text-white/25 pl-1 italic">
+              {sourceLang !== 'auto'
+                ? `${t('translate.glossary.noGlossaryForPair') || 'Aucun glossaire pour'} ${sourceFlag}→${targetFlag}`
+                : (t('translate.glossary.noGlossaries') || 'Aucun glossaire')
+              }
+            </p>
+          )}
+        </div>
+      )}
     </div>
   );
 }

frontend/src/app/dashboard/translate/page.tsx

@@ -402,13 +402,14 @@ export default function TranslatePage() {
                       isPro={config.isPro}
                     />
 
-                    {config.isPro && (
-                      <GlossarySelector
-                        glossaryId={config.glossaryId}
-                        onChange={config.setGlossaryId}
-                        disabled={submit.isSubmitting}
-                      />
-                    )}
+                    <GlossarySelector
+                      sourceLang={config.sourceLang}
+                      targetLang={config.targetLang}
+                      isPro={config.isPro}
+                      glossaryId={config.glossaryId}
+                      onChange={config.setGlossaryId}
+                      disabled={submit.isSubmitting}
+                    />
 
                     {/* PDF mode selector */}
                     {isPdf && (

frontend/src/app/dashboard/translate/useTranslationConfig.ts

@@ -79,6 +79,11 @@ export function useTranslationConfig(hasFile: boolean): UseTranslationConfigRetu
     }
   }, [settings.defaultTargetLanguage]); // eslint-disable-line react-hooks/exhaustive-deps
 
+  // Reset glossary selection when source language changes
+  useEffect(() => {
+    setGlossaryId(null);
+  }, [sourceLang]); // eslint-disable-line react-hooks/exhaustive-deps
+
   // Fetch available (admin-configured) providers
   useEffect(() => {
     const controller = new AbortController();

frontend/src/lib/i18n.tsx

@@ -721,6 +721,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Select a glossary",
     "translate.glossary.none": "None",
     "translate.glossary.terms": "terms",
+    "translate.glossary.proOnly": "Upgrade to Pro to use glossaries",
+    "translate.glossary.myGlossaries": "My glossaries",
+    "translate.glossary.fromTemplate": "Create from template",
+    "translate.glossary.noGlossaryForPair": "No glossary for",
+    "translate.glossary.noGlossaries": "No glossaries yet",
+    "translate.glossary.loading": "Loading...",
     "context.presets.createGlossary": "Create glossary",
     "context.presets.created": "Glossary created",
     "context.presets.createdDesc": "The glossary \"{name}\" has been created with {count} terms.",
@@ -1508,6 +1514,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Sélectionner un glossaire",
     "translate.glossary.none": "Aucun",
     "translate.glossary.terms": "termes",
+    "translate.glossary.proOnly": "Passez à Pro pour utiliser les glossaires",
+    "translate.glossary.myGlossaries": "Mes glossaires",
+    "translate.glossary.fromTemplate": "Créer depuis un template",
+    "translate.glossary.noGlossaryForPair": "Aucun glossaire pour",
+    "translate.glossary.noGlossaries": "Aucun glossaire",
+    "translate.glossary.loading": "Chargement...",
     "context.presets.createGlossary": "Créer le glossaire",
     "context.presets.created": "Glossaire créé",
     "context.presets.createdDesc": "Le glossaire \"{name}\" a été créé avec {count} termes.",
@@ -2241,6 +2253,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Seleccionar glosario",
     "translate.glossary.none": "Ninguno",
     "translate.glossary.terms": "términos",
+    "translate.glossary.proOnly": "Actualiza a Pro para usar glosarios",
+    "translate.glossary.myGlossaries": "Mis glosarios",
+    "translate.glossary.fromTemplate": "Crear desde plantilla",
+    "translate.glossary.noGlossaryForPair": "Sin glosario para",
+    "translate.glossary.noGlossaries": "Sin glosarios",
+    "translate.glossary.loading": "Cargando...",
     "context.presets.createGlossary": "Crear glosario",
     "context.presets.created": "Glosario creado",
     "context.presets.createdDesc": "El glosario \"{name}\" ha sido creado con {count} términos.",
@@ -2972,6 +2990,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Glossar auswählen",
     "translate.glossary.none": "Keins",
     "translate.glossary.terms": "Begriffe",
+    "translate.glossary.proOnly": "Upgraden Sie auf Pro für Glossare",
+    "translate.glossary.myGlossaries": "Meine Glossare",
+    "translate.glossary.fromTemplate": "Aus Vorlage erstellen",
+    "translate.glossary.noGlossaryForPair": "Kein Glossar für",
+    "translate.glossary.noGlossaries": "Keine Glossare",
+    "translate.glossary.loading": "Laden...",
     "context.presets.createGlossary": "Glossar erstellen",
     "context.presets.created": "Glossar erstellt",
     "context.presets.createdDesc": "Das Glossar \"{name}\" wurde mit {count} Begriffen erstellt.",
@@ -3703,6 +3727,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Selecionar glossário",
     "translate.glossary.none": "Nenhum",
     "translate.glossary.terms": "termos",
+    "translate.glossary.proOnly": "Atualize para Pro para usar glossários",
+    "translate.glossary.myGlossaries": "Meus glossários",
+    "translate.glossary.fromTemplate": "Criar do modelo",
+    "translate.glossary.noGlossaryForPair": "Sem glossário para",
+    "translate.glossary.noGlossaries": "Sem glossários",
+    "translate.glossary.loading": "Carregando...",
     "context.presets.createGlossary": "Criar glossário",
     "context.presets.created": "Glossário criado",
     "context.presets.createdDesc": "O glossário \"{name}\" foi criado com {count} termos.",
@@ -4434,6 +4464,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Seleziona glossario",
     "translate.glossary.none": "Nessuno",
     "translate.glossary.terms": "termini",
+    "translate.glossary.proOnly": "Passa a Pro per usare i glossari",
+    "translate.glossary.myGlossaries": "I miei glossari",
+    "translate.glossary.fromTemplate": "Crea da modello",
+    "translate.glossary.noGlossaryForPair": "Nessun glossario per",
+    "translate.glossary.noGlossaries": "Nessun glossario",
+    "translate.glossary.loading": "Caricamento...",
     "context.presets.createGlossary": "Crea glossario",
     "context.presets.created": "Glossario creato",
     "context.presets.createdDesc": "Il glossario \"{name}\" è stato creato con {count} termini.",
@@ -5165,6 +5201,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Woordenlijst selecteren",
     "translate.glossary.none": "Geen",
     "translate.glossary.terms": "termen",
+    "translate.glossary.proOnly": "Upgrade naar Pro voor woordenlijsten",
+    "translate.glossary.myGlossaries": "Mijn woordenlijsten",
+    "translate.glossary.fromTemplate": "Van sjabloon maken",
+    "translate.glossary.noGlossaryForPair": "Geen woordenlijst voor",
+    "translate.glossary.noGlossaries": "Geen woordenlijsten",
+    "translate.glossary.loading": "Laden...",
     "context.presets.createGlossary": "Woordenlijst maken",
     "context.presets.created": "Woordenlijst gemaakt",
     "context.presets.createdDesc": "De woordenlijst \"{name}\" is gemaakt met {count} termen.",
@@ -5898,6 +5940,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "Выбрать глоссарий",
     "translate.glossary.none": "Нет",
     "translate.glossary.terms": "терминов",
+    "translate.glossary.proOnly": "Обновитесь до Pro для использования глоссариев",
+    "translate.glossary.myGlossaries": "Мои глоссарии",
+    "translate.glossary.fromTemplate": "Создать из шаблона",
+    "translate.glossary.noGlossaryForPair": "Нет глоссария для",
+    "translate.glossary.noGlossaries": "Нет глоссариев",
+    "translate.glossary.loading": "Загрузка...",
     "context.presets.createGlossary": "Создать глоссарий",
     "context.presets.created": "Глоссарий создан",
     "context.presets.createdDesc": "Глоссарий \"{name}\" создан с {count} терминами.",
@@ -6628,6 +6676,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "用語集を選択",
     "translate.glossary.none": "なし",
     "translate.glossary.terms": "件",
+    "translate.glossary.proOnly": "Proにアップグレードして用語集を使用",
+    "translate.glossary.myGlossaries": "マイ用語集",
+    "translate.glossary.fromTemplate": "テンプレートから作成",
+    "translate.glossary.noGlossaryForPair": "用語集なし",
+    "translate.glossary.noGlossaries": "用語集なし",
+    "translate.glossary.loading": "読み込み中...",
     "context.presets.createGlossary": "用語集を作成",
     "context.presets.created": "用語集を作成しました",
     "context.presets.createdDesc": "用語集「{name}」を{count}件の用語で作成しました。",
@@ -7358,6 +7412,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "용어집 선택",
     "translate.glossary.none": "없음",
     "translate.glossary.terms": "개",
+    "translate.glossary.proOnly": "Pro로 업그레이드하여 용어집 사용",
+    "translate.glossary.myGlossaries": "내 용어집",
+    "translate.glossary.fromTemplate": "템플릿에서 만들기",
+    "translate.glossary.noGlossaryForPair": "용어집 없음",
+    "translate.glossary.noGlossaries": "용어집 없음",
+    "translate.glossary.loading": "로딩 중...",
     "context.presets.createGlossary": "용어집 만들기",
     "context.presets.created": "용어집 생성됨",
     "context.presets.createdDesc": "용어집 \"{name}\"이(가) {count}개의 용어로 생성되었습니다.",
@@ -8046,6 +8106,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "选择术语表",
     "translate.glossary.none": "无",
     "translate.glossary.terms": "个术语",
+    "translate.glossary.proOnly": "升级到Pro以使用术语表",
+    "translate.glossary.myGlossaries": "我的术语表",
+    "translate.glossary.fromTemplate": "从模板创建",
+    "translate.glossary.noGlossaryForPair": "无术语表",
+    "translate.glossary.noGlossaries": "无术语表",
+    "translate.glossary.loading": "加载中...",
     "context.presets.createGlossary": "创建术语表",
     "context.presets.created": "术语表已创建",
     "context.presets.createdDesc": "术语表 \"{name}\" 已创建，包含 {count} 个术语。",
@@ -8734,6 +8800,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "اختر مسرداً",
     "translate.glossary.none": "بدون",
     "translate.glossary.terms": "مصطلحات",
+    "translate.glossary.proOnly": "قم بالترقية إلى Pro لاستخدام المصطلحات",
+    "translate.glossary.myGlossaries": "مصطلحاتي",
+    "translate.glossary.fromTemplate": "إنشاء من قالب",
+    "translate.glossary.noGlossaryForPair": "لا مصطلحات لـ",
+    "translate.glossary.noGlossaries": "لا مصطلحات",
+    "translate.glossary.loading": "جاري التحميل...",
     "context.presets.createGlossary": "إنشاء مسرد",
     "context.presets.created": "تم إنشاء المسرد",
     "context.presets.createdDesc": "تم إنشاء المسرد \"{name}\" بـ {count} مصطلحات.",
@@ -9458,6 +9530,12 @@ const messages: Record<Locale, Record<string, string>> = {
     "translate.glossary.select": "انتخاب واژه‌نامه",
     "translate.glossary.none": "هیچکدام",
     "translate.glossary.terms": "واژه",
+    "translate.glossary.proOnly": "ارتقا به Pro برای استفاده از واژه‌نامه",
+    "translate.glossary.myGlossaries": "واژه‌نامه‌های من",
+    "translate.glossary.fromTemplate": "ایجاد از قالب",
+    "translate.glossary.noGlossaryForPair": "واژه‌نامه‌ای برای",
+    "translate.glossary.noGlossaries": "واژه‌نامه‌ای نیست",
+    "translate.glossary.loading": "در حال بارگذاری...",
     "context.presets.createGlossary": "ایجاد واژه‌نامه",
     "context.presets.created": "واژه‌نامه ایجاد شد",
     "context.presets.createdDesc": "واژه‌نامه \"{name}\" با {count} واژه ایجاد شد.",