fix(metadata): recover prompts through scheduled guidance

This reverts commit 51fe7aa07e.

README.md

@@ -56,34 +56,28 @@ Insomnia Art Designs, megakirbs, Brennok, 2018cfh, W+K+White, wackop, Takkan, Ca
 
 ## Release Notes
 
+### v1.0.2
+
+* **Model Download History Tracking** - LoRA Manager now keeps a history of downloaded model versions, allowing it to recognize whether a version has been downloaded before, even if it is no longer currently present in your library.
+* **Skip Previously Downloaded Model Versions** - Added a new setting, `Skip previously downloaded model versions`, to help avoid downloading model versions you have already downloaded in the past.
+* **LoRA Stack Combiner Trigger Words Fix** - Fixed an issue where trigger word updates from `LORA_STACK` inputs were not propagated correctly through the LoRA Stack Combiner node.
+* **CivitAI Example Image Compatibility** - Improved support for CivitAI CDN subdomains so example images load more reliably.
+
 ### v1.0.1
 
 * **Batch Recipe Import** - Import recipes from multiple URLs or directories simultaneously with optimized concurrency.
-
 * **Bulk Download Missing LoRAs** - New bulk action for recipes: select multiple recipes and download all missing LoRAs for the selected recipes in one operation.
-
 * **Import-Only Recipe Option** - Save recipe metadata without downloading missing LoRAs, allowing you to save interesting recipes for later and download dependencies when needed.
-
 * **Editable Recipe Prompts** - Edit recipe prompts directly in the recipe detail modal.
-
 * **Checkpoint Loader LM Node** - Behaves like ComfyUI's built-in Load Checkpoint node, with the added ability to load checkpoints from Extra Folder Paths.
-
 * **UNET Loader LM Node** - Behaves like ComfyUI's built-in Load Diffusion Model node, with support for loading from Extra Folder Paths and GGUF format (requires ComfyUI-GGUF custom node).
-
 * **LoRA Stack Combiner Node** - Merge two LoRA stacks into one. For example: use separate Randomizers for character and style LoRAs, then combine before applying.
-
 * **LoRA Pool Regex Filtering** - Filter which LoRAs enter the pool using custom regex patterns for include/exclude rules.
-
 * **Dynamic Base Model Types** - Base model types are now fetched dynamically from Civitai API, keeping them synchronized with the latest available models.
-
 * **Prompt Autocomplete Enhancements** - Tab key acceptance, configurable behavior, and improved multi-word tag matching.
-
 * **Download Base Model Exclusions** - Exclude specific base models from download operations when you only want certain model types.
-
 * **Mature Blur Threshold Setting** - Configure blur levels (`PG13` / `R` / `X` / `XXX`, default `R+`) for mature content previews.
-
 * **Experimental: Nunchaku Qwen LoRA Support** - Experimental support for loading and applying LoRAs to Nunchaku quantized Qwen-Image models.
-
 * **Bug Fixes & UX Improvements** - Various fixes for a smoother workflow.
 
 ### v1.0.0

locales/de.json

@@ -263,7 +263,9 @@
             "videoSettings": "Video-Einstellungen",
             "layoutSettings": "Layout-Einstellungen",
             "misc": "Verschiedenes",
+            "backup": "Backups",
             "folderSettings": "Standard-Roots",
+            "recipeSettings": "Rezepte",
             "extraFolderPaths": "Zusätzliche Ordnerpfade",
             "downloadPathTemplates": "Download-Pfad-Vorlagen",
             "priorityTags": "Prioritäts-Tags",
@@ -323,6 +325,32 @@
                 "saveFailed": "Übersprungene Pfade konnten nicht gespeichert werden: {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "Automatische Backups",
+            "autoEnabledHelp": "Erstellt einmal täglich einen lokalen Schnappschuss und behält die neuesten Schnappschüsse gemäß der Aufbewahrungsrichtlinie.",
+            "retention": "Aufbewahrungsanzahl",
+            "retentionHelp": "Wie viele automatische Schnappschüsse behalten werden, bevor ältere entfernt werden.",
+            "management": "Backup-Verwaltung",
+            "managementHelp": "Exportiere deinen aktuellen Benutzerstatus oder stelle ihn aus einem Backup-Archiv wieder her.",
+            "scopeHelp": "Sichert deine Einstellungen, den Downloadverlauf und den Status der Modellaktualisierung. Modelldateien und neu erzeugbare Caches sind nicht enthalten.",
+            "locationSummary": "Aktueller Backup-Speicherort",
+            "openFolderButton": "Backup-Ordner öffnen",
+            "openFolderSuccess": "Backup-Ordner geöffnet",
+            "openFolderFailed": "Backup-Ordner konnte nicht geöffnet werden",
+            "locationCopied": "Backup-Pfad in die Zwischenablage kopiert: {{path}}",
+            "locationClipboardFallback": "Backup-Pfad: {{path}}",
+            "exportButton": "Backup exportieren",
+            "exportSuccess": "Backup erfolgreich exportiert.",
+            "exportFailed": "Backup konnte nicht exportiert werden: {message}",
+            "importButton": "Backup importieren",
+            "importConfirm": "Dieses Backup importieren und den lokalen Benutzerstatus überschreiben?",
+            "importSuccess": "Backup erfolgreich importiert.",
+            "importFailed": "Backup konnte nicht importiert werden: {message}",
+            "latestSnapshot": "Neuester Schnappschuss",
+            "latestAutoSnapshot": "Neuester automatischer Schnappschuss",
+            "snapshotCount": "Gespeicherte Schnappschüsse",
+            "noneAvailable": "Noch keine Schnappschüsse vorhanden"
+        },
         "downloadSkipBaseModels": {
             "label": "Downloads für Basismodelle überspringen",
             "help": "Gilt für alle Download-Abläufe. Hier können nur unterstützte Basismodelle ausgewählt werden.",
@@ -341,6 +369,10 @@
                 "saveFailed": "Ausgeschlossene Basismodelle konnten nicht gespeichert werden: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "Bereits heruntergeladene Modellversionen überspringen",
+            "help": "Wenn aktiviert, überspringt LoRA Manager den Download einer Modellversion, wenn der Download-Verlaufsdienst diese spezifische Version als bereits heruntergeladen erfasst hat. Gilt für alle Download-Abläufe."
+        },
         "layoutSettings": {
             "displayDensity": "Anzeige-Dichte",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "Legen Sie den Standard-Diffusion-Modell-(UNET)-Stammordner für Downloads, Importe und Verschiebungen fest",
             "defaultEmbeddingRoot": "Embedding-Stammordner",
             "defaultEmbeddingRootHelp": "Legen Sie den Standard-Embedding-Stammordner für Downloads, Importe und Verschiebungen fest",
+            "recipesPath": "Rezepte-Speicherpfad",
+            "recipesPathHelp": "Optionales benutzerdefiniertes Verzeichnis für gespeicherte Rezepte. Leer lassen, um den recipes-Ordner im ersten LoRA-Stammverzeichnis zu verwenden.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "Rezepte-Speicher wird verschoben...",
             "noDefault": "Kein Standard"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "In {otherType}-Ordner verschieben",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "An Workflow senden"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "Fehler beim Speichern der Basis-Modell-Zuordnungen: {message}",
             "downloadTemplatesUpdated": "Download-Pfad-Vorlagen aktualisiert",
             "downloadTemplatesFailed": "Fehler beim Speichern der Download-Pfad-Vorlagen: {message}",
+            "recipesPathUpdated": "Rezepte-Speicherpfad aktualisiert",
+            "recipesPathSaveFailed": "Fehler beim Aktualisieren des Rezepte-Speicherpfads: {message}",
             "settingsUpdated": "Einstellungen aktualisiert: {setting}",
             "compactModeToggled": "Kompakt-Modus {state}",
             "settingSaveFailed": "Fehler beim Speichern der Einstellung: {message}",

locales/en.json

@@ -263,7 +263,9 @@
             "videoSettings": "Video Settings",
             "layoutSettings": "Layout Settings",
             "misc": "Miscellaneous",
+            "backup": "Backups",
             "folderSettings": "Default Roots",
+            "recipeSettings": "Recipes",
             "extraFolderPaths": "Extra Folder Paths",
             "downloadPathTemplates": "Download Path Templates",
             "priorityTags": "Priority Tags",
@@ -323,9 +325,35 @@
                 "saveFailed": "Unable to save skip paths: {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "Automatic backups",
+            "autoEnabledHelp": "Create a local snapshot once per day and keep the latest snapshots according to the retention policy.",
+            "retention": "Retention count",
+            "retentionHelp": "How many automatic snapshots to keep before older ones are pruned.",
+            "management": "Backup management",
+            "managementHelp": "Export your current user state or restore it from a backup archive.",
+            "scopeHelp": "Backs up your settings, download history, and model update state. It does not include model files or rebuildable caches.",
+            "locationSummary": "Current backup location",
+            "openFolderButton": "Open backup folder",
+            "openFolderSuccess": "Opened backup folder",
+            "openFolderFailed": "Failed to open backup folder",
+            "locationCopied": "Backup path copied to clipboard: {{path}}",
+            "locationClipboardFallback": "Backup path: {{path}}",
+            "exportButton": "Export backup",
+            "exportSuccess": "Backup exported successfully.",
+            "exportFailed": "Failed to export backup: {message}",
+            "importButton": "Import backup",
+            "importConfirm": "Import this backup and overwrite local user state?",
+            "importSuccess": "Backup imported successfully.",
+            "importFailed": "Failed to import backup: {message}",
+            "latestSnapshot": "Latest snapshot",
+            "latestAutoSnapshot": "Latest automatic snapshot",
+            "snapshotCount": "Saved snapshots",
+            "noneAvailable": "No snapshots yet"
+        },
         "downloadSkipBaseModels": {
             "label": "Skip downloads for base models",
-            "help": "When a model version uses one of these base models, LoRA Manager will skip the download before any file transfer starts. Applies to all download flows. Only supported base models can be selected here.",
+            "help": "When enabled, versions using the selected base models will be skipped.",
             "searchPlaceholder": "Filter base models...",
             "empty": "No base models match the current search.",
             "summary": {
@@ -341,6 +369,10 @@
                 "saveFailed": "Unable to save excluded base models: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "Skip previously downloaded model versions",
+            "help": "When enabled, versions downloaded before will be skipped."
+        },
         "layoutSettings": {
             "displayDensity": "Display Density",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "Set default diffusion model (UNET) root directory for downloads, imports and moves",
             "defaultEmbeddingRoot": "Embedding Root",
             "defaultEmbeddingRootHelp": "Set default embedding root directory for downloads, imports and moves",
+            "recipesPath": "Recipes Storage Path",
+            "recipesPathHelp": "Optional custom directory for stored recipes. Leave empty to use the first LoRA root's recipes folder.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "Migrating recipes storage...",
             "noDefault": "No Default"
         },
         "extraFolderPaths": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "Failed to save base model mappings: {message}",
             "downloadTemplatesUpdated": "Download path templates updated",
             "downloadTemplatesFailed": "Failed to save download path templates: {message}",
+            "recipesPathUpdated": "Recipes storage path updated",
+            "recipesPathSaveFailed": "Failed to update recipes storage path: {message}",
             "settingsUpdated": "Settings updated: {setting}",
             "compactModeToggled": "Compact Mode {state}",
             "settingSaveFailed": "Failed to save setting: {message}",

locales/es.json

@@ -263,7 +263,9 @@
             "videoSettings": "Configuración de video",
             "layoutSettings": "Configuración de diseño",
             "misc": "Varios",
+            "backup": "Copias de seguridad",
             "folderSettings": "Raíces predeterminadas",
+            "recipeSettings": "Recetas",
             "extraFolderPaths": "Rutas de carpetas adicionales",
             "downloadPathTemplates": "Plantillas de rutas de descarga",
             "priorityTags": "Etiquetas prioritarias",
@@ -323,6 +325,32 @@
                 "saveFailed": "No se pudieron guardar las rutas a omitir: {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "Copias de seguridad automáticas",
+            "autoEnabledHelp": "Crea una instantánea local una vez al día y conserva las más recientes según la política de retención.",
+            "retention": "Cantidad de retención",
+            "retentionHelp": "Cuántas instantáneas automáticas conservar antes de eliminar las antiguas.",
+            "management": "Gestión de copias",
+            "managementHelp": "Exporta tu estado de usuario actual o restáuralo desde un archivo de copia de seguridad.",
+            "scopeHelp": "Incluye tu configuración, el historial de descargas y el estado de actualización de los modelos. No incluye los archivos de modelo ni las cachés que se pueden regenerar.",
+            "locationSummary": "Ubicación actual de la copia",
+            "openFolderButton": "Abrir carpeta de copias",
+            "openFolderSuccess": "Carpeta de copias abierta",
+            "openFolderFailed": "No se pudo abrir la carpeta de copias",
+            "locationCopied": "Ruta de la copia copiada al portapapeles: {{path}}",
+            "locationClipboardFallback": "Ruta de la copia: {{path}}",
+            "exportButton": "Exportar copia",
+            "exportSuccess": "Copia exportada correctamente.",
+            "exportFailed": "No se pudo exportar la copia: {message}",
+            "importButton": "Importar copia",
+            "importConfirm": "¿Importar esta copia y sobrescribir el estado local del usuario?",
+            "importSuccess": "Copia importada correctamente.",
+            "importFailed": "No se pudo importar la copia: {message}",
+            "latestSnapshot": "Última instantánea",
+            "latestAutoSnapshot": "Última instantánea automática",
+            "snapshotCount": "Instantáneas guardadas",
+            "noneAvailable": "Aún no hay instantáneas"
+        },
         "downloadSkipBaseModels": {
             "label": "Omitir descargas para modelos base",
             "help": "Se aplica a todos los flujos de descarga. Aquí solo se pueden seleccionar modelos base compatibles.",
@@ -341,6 +369,10 @@
                 "saveFailed": "No se pudieron guardar los modelos base excluidos: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "Omitir versiones de modelos previamente descargadas",
+            "help": "Cuando está habilitado, LoRA Manager omitirá la descarga de una versión de modelo si el servicio de historial de descargas registra esa versión exacta como ya descargada. Aplica a todos los flujos de descarga."
+        },
         "layoutSettings": {
             "displayDensity": "Densidad de visualización",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "Establecer el directorio raíz predeterminado de Diffusion Model (UNET) para descargas, importaciones y movimientos",
             "defaultEmbeddingRoot": "Raíz de embedding",
             "defaultEmbeddingRootHelp": "Establecer el directorio raíz predeterminado de embedding para descargas, importaciones y movimientos",
+            "recipesPath": "Ruta de almacenamiento de recetas",
+            "recipesPathHelp": "Directorio personalizado opcional para las recetas guardadas. Déjalo vacío para usar la carpeta recipes del primer directorio raíz de LoRA.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "Migrando el almacenamiento de recetas...",
             "noDefault": "Sin predeterminado"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "Mover a la carpeta {otherType}",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "Enviar al flujo de trabajo"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "Error al guardar mapeos de modelo base: {message}",
             "downloadTemplatesUpdated": "Plantillas de rutas de descarga actualizadas",
             "downloadTemplatesFailed": "Error al guardar plantillas de rutas de descarga: {message}",
+            "recipesPathUpdated": "Ruta de almacenamiento de recetas actualizada",
+            "recipesPathSaveFailed": "Error al actualizar la ruta de almacenamiento de recetas: {message}",
             "settingsUpdated": "Configuración actualizada: {setting}",
             "compactModeToggled": "Modo compacto {state}",
             "settingSaveFailed": "Error al guardar configuración: {message}",

locales/fr.json

@@ -263,7 +263,9 @@
             "videoSettings": "Paramètres vidéo",
             "layoutSettings": "Paramètres d'affichage",
             "misc": "Divers",
+            "backup": "Sauvegardes",
             "folderSettings": "Racines par défaut",
+            "recipeSettings": "Recipes",
             "extraFolderPaths": "Chemins de dossiers supplémentaires",
             "downloadPathTemplates": "Modèles de chemin de téléchargement",
             "priorityTags": "Étiquettes prioritaires",
@@ -323,6 +325,32 @@
                 "saveFailed": "Impossible d'enregistrer les chemins à ignorer : {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "Sauvegardes automatiques",
+            "autoEnabledHelp": "Crée un instantané local une fois par jour et conserve les plus récents selon la politique de rétention.",
+            "retention": "Nombre de rétention",
+            "retentionHelp": "Combien d'instantanés automatiques conserver avant de supprimer les plus anciens.",
+            "management": "Gestion des sauvegardes",
+            "managementHelp": "Exporte l'état actuel de l'utilisateur ou restaure-le depuis une archive de sauvegarde.",
+            "scopeHelp": "Inclut vos paramètres, l'historique des téléchargements et l'état des mises à jour des modèles. Les fichiers de modèle et les caches régénérables ne sont pas inclus.",
+            "locationSummary": "Emplacement actuel des sauvegardes",
+            "openFolderButton": "Ouvrir le dossier de sauvegarde",
+            "openFolderSuccess": "Dossier de sauvegarde ouvert",
+            "openFolderFailed": "Impossible d'ouvrir le dossier de sauvegarde",
+            "locationCopied": "Chemin de sauvegarde copié dans le presse-papiers : {{path}}",
+            "locationClipboardFallback": "Chemin de sauvegarde : {{path}}",
+            "exportButton": "Exporter la sauvegarde",
+            "exportSuccess": "Sauvegarde exportée avec succès.",
+            "exportFailed": "Échec de l'export de la sauvegarde : {message}",
+            "importButton": "Importer la sauvegarde",
+            "importConfirm": "Importer cette sauvegarde et écraser l'état local de l'utilisateur ?",
+            "importSuccess": "Sauvegarde importée avec succès.",
+            "importFailed": "Échec de l'import de la sauvegarde : {message}",
+            "latestSnapshot": "Dernier instantané",
+            "latestAutoSnapshot": "Dernier instantané automatique",
+            "snapshotCount": "Instantanés enregistrés",
+            "noneAvailable": "Aucun instantané pour le moment"
+        },
         "downloadSkipBaseModels": {
             "label": "Ignorer les téléchargements pour certains modèles de base",
             "help": "S’applique à tous les flux de téléchargement. Seuls les modèles de base pris en charge peuvent être sélectionnés ici.",
@@ -341,6 +369,10 @@
                 "saveFailed": "Impossible d’enregistrer les modèles de base exclus : {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "Ignorer les versions de modèles précédemment téléchargées",
+            "help": "Lorsque activé, LoRA Manager ignorera le téléchargement d'une version de modèle si le service d'historique des téléchargements enregistre cette version exacte comme déjà téléchargée. S'applique à tous les flux de téléchargement."
+        },
         "layoutSettings": {
             "displayDensity": "Densité d'affichage",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "Définir le répertoire racine Diffusion Model (UNET) par défaut pour les téléchargements, imports et déplacements",
             "defaultEmbeddingRoot": "Racine Embedding",
             "defaultEmbeddingRootHelp": "Définir le répertoire racine embedding par défaut pour les téléchargements, imports et déplacements",
+            "recipesPath": "Recipes Storage Path",
+            "recipesPathHelp": "Optional custom directory for stored recipes. Leave empty to use the first LoRA root's recipes folder.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "Migrating recipes storage...",
             "noDefault": "Aucun par défaut"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "Déplacer vers le dossier {otherType}",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "Envoyer vers le workflow"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "Échec de la sauvegarde des mappages de modèle de base : {message}",
             "downloadTemplatesUpdated": "Modèles de chemin de téléchargement mis à jour",
             "downloadTemplatesFailed": "Échec de la sauvegarde des modèles de chemin de téléchargement : {message}",
+            "recipesPathUpdated": "Recipes storage path updated",
+            "recipesPathSaveFailed": "Failed to update recipes storage path: {message}",
             "settingsUpdated": "Paramètres mis à jour : {setting}",
             "compactModeToggled": "Mode compact {state}",
             "settingSaveFailed": "Échec de la sauvegarde du paramètre : {message}",

locales/he.json

@@ -263,7 +263,9 @@
             "videoSettings": "הגדרות וידאו",
             "layoutSettings": "הגדרות פריסה",
             "misc": "שונות",
+            "backup": "גיבויים",
             "folderSettings": "תיקיות ברירת מחדל",
+            "recipeSettings": "מתכונים",
             "extraFolderPaths": "נתיבי תיקיות נוספים",
             "downloadPathTemplates": "תבניות נתיב הורדה",
             "priorityTags": "תגיות עדיפות",
@@ -323,6 +325,32 @@
                 "saveFailed": "לא ניתן לשמור נתיבי דילוג: {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "גיבויים אוטומטיים",
+            "autoEnabledHelp": "יוצר צילום מצב מקומי פעם ביום ושומר את הצילומים האחרונים לפי מדיניות השמירה.",
+            "retention": "כמות שמירה",
+            "retentionHelp": "כמה צילומי מצב אוטומטיים לשמור לפני שמסירים ישנים.",
+            "management": "ניהול גיבויים",
+            "managementHelp": "ייצא את מצב המשתמש הנוכחי או שחזר אותו מארכיון גיבוי.",
+            "scopeHelp": "כולל את ההגדרות שלך, היסטוריית ההורדות ומצב עדכוני המודלים. אינו כולל קובצי מודל או מטמונים שניתן לשחזר.",
+            "locationSummary": "מיקום הגיבוי הנוכחי",
+            "openFolderButton": "פתח את תיקיית הגיבויים",
+            "openFolderSuccess": "תיקיית הגיבויים נפתחה",
+            "openFolderFailed": "לא ניתן היה לפתוח את תיקיית הגיבויים",
+            "locationCopied": "נתיב הגיבוי הועתק ללוח: {{path}}",
+            "locationClipboardFallback": "נתיב הגיבוי: {{path}}",
+            "exportButton": "ייצא גיבוי",
+            "exportSuccess": "הגיבוי יוצא בהצלחה.",
+            "exportFailed": "נכשל ייצוא הגיבוי: {message}",
+            "importButton": "ייבא גיבוי",
+            "importConfirm": "לייבא את הגיבוי הזה ולדרוס את מצב המשתמש המקומי?",
+            "importSuccess": "הגיבוי יובא בהצלחה.",
+            "importFailed": "נכשל ייבוא הגיבוי: {message}",
+            "latestSnapshot": "צילום המצב האחרון",
+            "latestAutoSnapshot": "צילום המצב האוטומטי האחרון",
+            "snapshotCount": "צילומי מצב שמורים",
+            "noneAvailable": "עדיין אין צילומי מצב"
+        },
         "downloadSkipBaseModels": {
             "label": "דלג על הורדות עבור מודלי בסיס",
             "help": "חל על כל תהליכי ההורדה. ניתן לבחור כאן רק מודלי בסיס נתמכים.",
@@ -341,6 +369,10 @@
                 "saveFailed": "לא ניתן לשמור את מודלי הבסיס המוחרגים: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "דלג על גרסאות מודלים שהורדו בעבר",
+            "help": "כאשר מופעל, LoRA Manager ידלג על הורדת גרסת מודל אם שירות היסטוריית ההורדות רושם את הגרסה המדויקת הזו ככבר שהורדה. חל על כל תהליכי ההורדה."
+        },
         "layoutSettings": {
             "displayDensity": "צפיפות תצוגה",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של Diffusion Model (UNET) להורדות, ייבוא והעברות",
             "defaultEmbeddingRoot": "תיקיית שורש Embedding",
             "defaultEmbeddingRootHelp": "הגדר את ספריית השורש המוגדרת כברירת מחדל של embedding להורדות, ייבוא והעברות",
+            "recipesPath": "נתיב אחסון מתכונים",
+            "recipesPathHelp": "ספרייה מותאמת אישית אופציונלית למתכונים שנשמרו. השאר ריק כדי להשתמש בתיקיית recipes של שורש LoRA הראשון.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "מעביר את אחסון המתכונים...",
             "noDefault": "אין ברירת מחדל"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "העבר לתיקיית {otherType}",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "שלח ל-workflow"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "שמירת מיפויי מודל בסיס נכשלה: {message}",
             "downloadTemplatesUpdated": "תבניות נתיב הורדה עודכנו",
             "downloadTemplatesFailed": "שמירת תבניות נתיב הורדה נכשלה: {message}",
+            "recipesPathUpdated": "נתיב אחסון המתכונים עודכן",
+            "recipesPathSaveFailed": "עדכון נתיב אחסון המתכונים נכשל: {message}",
             "settingsUpdated": "הגדרות עודכנו: {setting}",
             "compactModeToggled": "מצב קומפקטי {state}",
             "settingSaveFailed": "שמירת ההגדרה נכשלה: {message}",

locales/ja.json

@@ -263,7 +263,9 @@
             "videoSettings": "動画設定",
             "layoutSettings": "レイアウト設定",
             "misc": "その他",
+            "backup": "バックアップ",
             "folderSettings": "デフォルトルート",
+            "recipeSettings": "レシピ",
             "extraFolderPaths": "追加フォルダーパス",
             "downloadPathTemplates": "ダウンロードパステンプレート",
             "priorityTags": "優先タグ",
@@ -323,6 +325,32 @@
                 "saveFailed": "スキップパスの保存に失敗しました：{message}"
             }
         },
+        "backup": {
+            "autoEnabled": "自動バックアップ",
+            "autoEnabledHelp": "1日1回ローカルのスナップショットを作成し、保持ポリシーに従って最新のものを残します。",
+            "retention": "保持数",
+            "retentionHelp": "古いものを削除する前に、何件の自動スナップショットを保持するかを指定します。",
+            "management": "バックアップ管理",
+            "managementHelp": "現在のユーザー状態をエクスポートするか、バックアップアーカイブから復元します。",
+            "scopeHelp": "設定、ダウンロード履歴、モデル更新の状態をバックアップします。モデルファイルや再生成できるキャッシュは含まれません。",
+            "locationSummary": "現在のバックアップ場所",
+            "openFolderButton": "バックアップフォルダを開く",
+            "openFolderSuccess": "バックアップフォルダを開きました",
+            "openFolderFailed": "バックアップフォルダを開けませんでした",
+            "locationCopied": "バックアップパスをクリップボードにコピーしました: {{path}}",
+            "locationClipboardFallback": "バックアップパス: {{path}}",
+            "exportButton": "バックアップをエクスポート",
+            "exportSuccess": "バックアップを正常にエクスポートしました。",
+            "exportFailed": "バックアップのエクスポートに失敗しました: {message}",
+            "importButton": "バックアップをインポート",
+            "importConfirm": "このバックアップをインポートして、ローカルのユーザー状態を上書きしますか?",
+            "importSuccess": "バックアップを正常にインポートしました。",
+            "importFailed": "バックアップのインポートに失敗しました: {message}",
+            "latestSnapshot": "最新のスナップショット",
+            "latestAutoSnapshot": "最新の自動スナップショット",
+            "snapshotCount": "保存済みスナップショット",
+            "noneAvailable": "まだスナップショットはありません"
+        },
         "downloadSkipBaseModels": {
             "label": "ベースモデルのダウンロードをスキップ",
             "help": "すべてのダウンロードフローに適用されます。ここでは対応しているベースモデルのみ選択できます。",
@@ -341,6 +369,10 @@
                 "saveFailed": "除外するベースモデルを保存できませんでした: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "以前にダウンロードしたモデルバージョンをスキップ",
+            "help": "有効にすると、ダウンロード履歴サービスがそのバージョンが既にダウンロード済みと記録している場合、LoRA Managerはそのモデルバージョンのダウンロードをスキップします。すべてのダウンロードフローに適用されます。"
+        },
         "layoutSettings": {
             "displayDensity": "表示密度",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "ダウンロード、インポート、移動用のデフォルトDiffusion Model (UNET)ルートディレクトリを設定",
             "defaultEmbeddingRoot": "Embeddingルート",
             "defaultEmbeddingRootHelp": "ダウンロード、インポート、移動用のデフォルトembeddingルートディレクトリを設定",
+            "recipesPath": "レシピ保存先",
+            "recipesPathHelp": "保存済みレシピ用の任意のカスタムディレクトリです。空欄にすると最初のLoRAルートのrecipesフォルダーを使用します。",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "レシピ保存先を移動中...",
             "noDefault": "デフォルトなし"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "{otherType} フォルダに移動",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "ワークフローに送信"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "ベースモデルマッピングの保存に失敗しました：{message}",
             "downloadTemplatesUpdated": "ダウンロードパステンプレートが更新されました",
             "downloadTemplatesFailed": "ダウンロードパステンプレートの保存に失敗しました：{message}",
+            "recipesPathUpdated": "レシピ保存先を更新しました",
+            "recipesPathSaveFailed": "レシピ保存先の更新に失敗しました: {message}",
             "settingsUpdated": "設定が更新されました：{setting}",
             "compactModeToggled": "コンパクトモード {state}",
             "settingSaveFailed": "設定の保存に失敗しました：{message}",

locales/ko.json

@@ -263,7 +263,9 @@
             "videoSettings": "비디오 설정",
             "layoutSettings": "레이아웃 설정",
             "misc": "기타",
+            "backup": "백업",
             "folderSettings": "기본 루트",
+            "recipeSettings": "레시피",
             "extraFolderPaths": "추가 폴다 경로",
             "downloadPathTemplates": "다운로드 경로 템플릿",
             "priorityTags": "우선순위 태그",
@@ -323,6 +325,32 @@
                 "saveFailed": "건너뛰기 경로를 저장할 수 없습니다: {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "자동 백업",
+            "autoEnabledHelp": "하루에 한 번 로컬 스냅샷을 만들고 보존 정책에 따라 최신 스냅샷을 유지합니다.",
+            "retention": "보존 개수",
+            "retentionHelp": "오래된 자동 스냅샷을 삭제하기 전에 몇 개를 유지할지 지정합니다.",
+            "management": "백업 관리",
+            "managementHelp": "현재 사용자 상태를 내보내거나 백업 아카이브에서 복원합니다.",
+            "scopeHelp": "설정, 다운로드 기록, 모델 업데이트 상태를 백업합니다. 모델 파일과 다시 생성할 수 있는 캐시는 포함되지 않습니다.",
+            "locationSummary": "현재 백업 위치",
+            "openFolderButton": "백업 폴더 열기",
+            "openFolderSuccess": "백업 폴더를 열었습니다",
+            "openFolderFailed": "백업 폴더를 열지 못했습니다",
+            "locationCopied": "백업 경로를 클립보드에 복사했습니다: {{path}}",
+            "locationClipboardFallback": "백업 경로: {{path}}",
+            "exportButton": "백업 내보내기",
+            "exportSuccess": "백업을 성공적으로 내보냈습니다.",
+            "exportFailed": "백업 내보내기에 실패했습니다: {message}",
+            "importButton": "백업 가져오기",
+            "importConfirm": "이 백업을 가져와서 로컬 사용자 상태를 덮어쓰시겠습니까?",
+            "importSuccess": "백업을 성공적으로 가져왔습니다.",
+            "importFailed": "백업 가져오기에 실패했습니다: {message}",
+            "latestSnapshot": "최근 스냅샷",
+            "latestAutoSnapshot": "최근 자동 스냅샷",
+            "snapshotCount": "저장된 스냅샷",
+            "noneAvailable": "아직 스냅샷이 없습니다"
+        },
         "downloadSkipBaseModels": {
             "label": "기본 모델 다운로드 건너뛰기",
             "help": "모든 다운로드 흐름에 적용됩니다. 여기서는 지원되는 기본 모델만 선택할 수 있습니다.",
@@ -341,6 +369,10 @@
                 "saveFailed": "제외된 기본 모델을 저장할 수 없습니다: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "이전에 다운로드한 모델 버전 건너뛰기",
+            "help": "활성화하면 다운로드 기록 서비스가 해당 버전이 이미 다운로드되었음을 기록한 경우 LoRA Manager는 해당 모델 버전 다운로드를 건너뜁니다. 모든 다운로드 플로우에 적용됩니다."
+        },
         "layoutSettings": {
             "displayDensity": "표시 밀도",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Diffusion Model (UNET) 루트 디렉토리를 설정합니다",
             "defaultEmbeddingRoot": "Embedding 루트",
             "defaultEmbeddingRootHelp": "다운로드, 가져오기 및 이동을 위한 기본 Embedding 루트 디렉토리를 설정합니다",
+            "recipesPath": "레시피 저장 경로",
+            "recipesPathHelp": "저장된 레시피를 위한 선택적 사용자 지정 디렉터리입니다. 비워 두면 첫 번째 LoRA 루트의 recipes 폴더를 사용합니다.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "레시피 저장 경로를 이동 중...",
             "noDefault": "기본값 없음"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "{otherType} 폴더로 이동",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "워크플로우로 전송"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "베이스 모델 매핑 저장 실패: {message}",
             "downloadTemplatesUpdated": "다운로드 경로 템플릿이 업데이트되었습니다",
             "downloadTemplatesFailed": "다운로드 경로 템플릿 저장 실패: {message}",
+            "recipesPathUpdated": "레시피 저장 경로가 업데이트되었습니다",
+            "recipesPathSaveFailed": "레시피 저장 경로 업데이트 실패: {message}",
             "settingsUpdated": "설정 업데이트됨: {setting}",
             "compactModeToggled": "컴팩트 모드 {state}",
             "settingSaveFailed": "설정 저장 실패: {message}",

locales/ru.json

@@ -263,7 +263,9 @@
             "videoSettings": "Настройки видео",
             "layoutSettings": "Настройки макета",
             "misc": "Разное",
+            "backup": "Резервные копии",
             "folderSettings": "Корневые папки",
+            "recipeSettings": "Рецепты",
             "extraFolderPaths": "Дополнительные пути к папкам",
             "downloadPathTemplates": "Шаблоны путей загрузки",
             "priorityTags": "Приоритетные теги",
@@ -323,6 +325,32 @@
                 "saveFailed": "Не удалось сохранить пути для пропуска: {message}"
             }
         },
+        "backup": {
+            "autoEnabled": "Автоматические резервные копии",
+            "autoEnabledHelp": "Создаёт локальный снимок раз в день и хранит последние снимки согласно политике хранения.",
+            "retention": "Количество хранения",
+            "retentionHelp": "Сколько автоматических снимков сохранять перед удалением старых.",
+            "management": "Управление резервными копиями",
+            "managementHelp": "Экспортируйте текущее состояние пользователя или восстановите его из архива резервной копии.",
+            "scopeHelp": "Резервная копия включает ваши настройки, историю загрузок и состояние обновлений моделей. Файлы моделей и пересоздаваемые кэши не входят.",
+            "locationSummary": "Текущее расположение резервных копий",
+            "openFolderButton": "Открыть папку резервных копий",
+            "openFolderSuccess": "Папка резервных копий открыта",
+            "openFolderFailed": "Не удалось открыть папку резервных копий",
+            "locationCopied": "Путь к резервной копии скопирован в буфер обмена: {{path}}",
+            "locationClipboardFallback": "Путь к резервной копии: {{path}}",
+            "exportButton": "Экспортировать резервную копию",
+            "exportSuccess": "Резервная копия успешно экспортирована.",
+            "exportFailed": "Не удалось экспортировать резервную копию: {message}",
+            "importButton": "Импортировать резервную копию",
+            "importConfirm": "Импортировать эту резервную копию и перезаписать локальное состояние пользователя?",
+            "importSuccess": "Резервная копия успешно импортирована.",
+            "importFailed": "Не удалось импортировать резервную копию: {message}",
+            "latestSnapshot": "Последний снимок",
+            "latestAutoSnapshot": "Последний автоматический снимок",
+            "snapshotCount": "Сохранённые снимки",
+            "noneAvailable": "Снимков пока нет"
+        },
         "downloadSkipBaseModels": {
             "label": "Пропускать загрузки для базовых моделей",
             "help": "Применяется ко всем сценариям загрузки. Здесь можно выбрать только поддерживаемые базовые модели.",
@@ -341,6 +369,10 @@
                 "saveFailed": "Не удалось сохранить исключённые базовые модели: {message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "Пропускать ранее загруженные версии моделей",
+            "help": "Если включено, LoRA Manager будет пропускать загрузку версии модели, если сервис истории загрузок записал, что эта конкретная версия уже загружена. Применяется ко всем потокам загрузки."
+        },
         "layoutSettings": {
             "displayDensity": "Плотность отображения",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "Установить корневую папку Diffusion Model (UNET) по умолчанию для загрузок, импорта и перемещений",
             "defaultEmbeddingRoot": "Корневая папка Embedding",
             "defaultEmbeddingRootHelp": "Установить корневую папку embedding по умолчанию для загрузок, импорта и перемещений",
+            "recipesPath": "Путь хранения рецептов",
+            "recipesPathHelp": "Дополнительный пользовательский каталог для сохранённых рецептов. Оставьте пустым, чтобы использовать папку recipes в первом корне LoRA.",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "Перенос хранилища рецептов...",
             "noDefault": "Не задано"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "Переместить в папку {otherType}",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "Отправить в workflow"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "Не удалось сохранить сопоставления базовых моделей: {message}",
             "downloadTemplatesUpdated": "Шаблоны путей загрузки обновлены",
             "downloadTemplatesFailed": "Не удалось сохранить шаблоны путей загрузки: {message}",
+            "recipesPathUpdated": "Путь хранения рецептов обновлён",
+            "recipesPathSaveFailed": "Не удалось обновить путь хранения рецептов: {message}",
             "settingsUpdated": "Настройки обновлены: {setting}",
             "compactModeToggled": "Компактный режим {state}",
             "settingSaveFailed": "Не удалось сохранить настройку: {message}",

locales/zh-CN.json

@@ -263,7 +263,9 @@
             "videoSettings": "视频设置",
             "layoutSettings": "布局设置",
             "misc": "其他",
+            "backup": "备份",
             "folderSettings": "默认根目录",
+            "recipeSettings": "配方",
             "extraFolderPaths": "额外文件夹路径",
             "downloadPathTemplates": "下载路径模板",
             "priorityTags": "优先标签",
@@ -323,6 +325,32 @@
                 "saveFailed": "无法保存跳过路径：{message}"
             }
         },
+        "backup": {
+            "autoEnabled": "自动备份",
+            "autoEnabledHelp": "每天创建一次本地快照，并按保留策略保留最新快照。",
+            "retention": "保留数量",
+            "retentionHelp": "在删除旧快照之前，要保留多少个自动快照。",
+            "management": "备份管理",
+            "managementHelp": "导出当前用户状态，或从备份归档中恢复。",
+            "scopeHelp": "备份你的设置、下载历史和模型更新状态。不包含模型文件或可重建的缓存。",
+            "locationSummary": "当前备份位置",
+            "openFolderButton": "打开备份文件夹",
+            "openFolderSuccess": "已打开备份文件夹",
+            "openFolderFailed": "无法打开备份文件夹",
+            "locationCopied": "备份路径已复制到剪贴板：{{path}}",
+            "locationClipboardFallback": "备份路径：{{path}}",
+            "exportButton": "导出备份",
+            "exportSuccess": "备份导出成功。",
+            "exportFailed": "备份导出失败：{message}",
+            "importButton": "导入备份",
+            "importConfirm": "导入此备份并覆盖本地用户状态吗？",
+            "importSuccess": "备份导入成功。",
+            "importFailed": "备份导入失败：{message}",
+            "latestSnapshot": "最近快照",
+            "latestAutoSnapshot": "最近自动快照",
+            "snapshotCount": "已保存快照",
+            "noneAvailable": "还没有快照"
+        },
         "downloadSkipBaseModels": {
             "label": "跳过这些基础模型的下载",
             "help": "适用于所有下载流程。这里只能选择受支持的基础模型。",
@@ -341,6 +369,10 @@
                 "saveFailed": "无法保存已排除的基础模型：{message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "跳过已下载的模型版本",
+            "help": "启用后，如果下载历史服务记录显示该版本已下载，LoRA Manager 将跳过下载该模型版本。适用于所有下载流程。"
+        },
         "layoutSettings": {
             "displayDensity": "显示密度",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "设置下载、导入和移动时的默认 Diffusion Model (UNET) 根目录",
             "defaultEmbeddingRoot": "Embedding 根目录",
             "defaultEmbeddingRootHelp": "设置下载、导入和移动时的默认 Embedding 根目录",
+            "recipesPath": "配方存储路径",
+            "recipesPathHelp": "已保存配方的可选自定义目录。留空则使用第一个 LoRA 根目录下的 recipes 文件夹。",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "正在迁移配方存储...",
             "noDefault": "无默认"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "移动到 {otherType} 文件夹",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "发送到工作流"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "保存基础模型映射失败：{message}",
             "downloadTemplatesUpdated": "下载路径模板已更新",
             "downloadTemplatesFailed": "保存下载路径模板失败：{message}",
+            "recipesPathUpdated": "配方存储路径已更新",
+            "recipesPathSaveFailed": "更新配方存储路径失败：{message}",
             "settingsUpdated": "设置已更新：{setting}",
             "compactModeToggled": "紧凑模式 {state}",
             "settingSaveFailed": "保存设置失败：{message}",

locales/zh-TW.json

@@ -263,7 +263,9 @@
             "videoSettings": "影片設定",
             "layoutSettings": "版面設定",
             "misc": "其他",
+            "backup": "備份",
             "folderSettings": "預設根目錄",
+            "recipeSettings": "配方",
             "extraFolderPaths": "額外資料夾路徑",
             "downloadPathTemplates": "下載路徑範本",
             "priorityTags": "優先標籤",
@@ -323,6 +325,32 @@
                 "saveFailed": "無法儲存跳過路徑：{message}"
             }
         },
+        "backup": {
+            "autoEnabled": "自動備份",
+            "autoEnabledHelp": "每天建立一次本地快照，並依保留政策保留最新快照。",
+            "retention": "保留數量",
+            "retentionHelp": "在刪除舊快照之前，要保留多少自動快照。",
+            "management": "備份管理",
+            "managementHelp": "匯出目前的使用者狀態，或從備份封存中還原。",
+            "scopeHelp": "備份你的設定、下載歷史與模型更新狀態。不包含模型檔案或可重建的快取。",
+            "locationSummary": "目前備份位置",
+            "openFolderButton": "開啟備份資料夾",
+            "openFolderSuccess": "已開啟備份資料夾",
+            "openFolderFailed": "無法開啟備份資料夾",
+            "locationCopied": "備份路徑已複製到剪貼簿：{{path}}",
+            "locationClipboardFallback": "備份路徑：{{path}}",
+            "exportButton": "匯出備份",
+            "exportSuccess": "備份匯出成功。",
+            "exportFailed": "備份匯出失敗：{message}",
+            "importButton": "匯入備份",
+            "importConfirm": "要匯入此備份並覆寫本機使用者狀態嗎？",
+            "importSuccess": "備份匯入成功。",
+            "importFailed": "備份匯入失敗：{message}",
+            "latestSnapshot": "最近快照",
+            "latestAutoSnapshot": "最近自動快照",
+            "snapshotCount": "已儲存快照",
+            "noneAvailable": "目前還沒有快照"
+        },
         "downloadSkipBaseModels": {
             "label": "跳過這些基礎模型的下載",
             "help": "適用於所有下載流程。這裡只能選擇受支援的基礎模型。",
@@ -341,6 +369,10 @@
                 "saveFailed": "無法儲存已排除的基礎模型：{message}"
             }
         },
+        "skipPreviouslyDownloadedModelVersions": {
+            "label": "跳過已下載的模型版本",
+            "help": "啟用後，如果下載歷史服務記錄顯示該版本已下載，LoRA Manager 將跳過下載該模型版本。適用於所有下載流程。"
+        },
         "layoutSettings": {
             "displayDensity": "顯示密度",
             "displayDensityOptions": {
@@ -389,6 +421,10 @@
             "defaultUnetRootHelp": "設定下載、匯入和移動時的預設 Diffusion Model (UNET) 根目錄",
             "defaultEmbeddingRoot": "Embedding 根目錄",
             "defaultEmbeddingRootHelp": "設定下載、匯入和移動時的預設 Embedding 根目錄",
+            "recipesPath": "配方儲存路徑",
+            "recipesPathHelp": "已儲存配方的可選自訂目錄。留空則使用第一個 LoRA 根目錄下的 recipes 資料夾。",
+            "recipesPathPlaceholder": "/path/to/recipes",
+            "recipesPathMigrating": "正在遷移配方儲存...",
             "noDefault": "未設定預設"
         },
         "extraFolderPaths": {
@@ -827,7 +863,7 @@
         },
         "contextMenu": {
             "moveToOtherTypeFolder": "移動到 {otherType} 資料夾",
-            "sendToWorkflow": "[TODO: Translate] Send to Workflow"
+            "sendToWorkflow": "傳送到工作流"
         }
     },
     "embeddings": {
@@ -1625,6 +1661,8 @@
             "mappingSaveFailed": "儲存基礎模型對應失敗：{message}",
             "downloadTemplatesUpdated": "下載路徑範本已更新",
             "downloadTemplatesFailed": "儲存下載路徑範本失敗：{message}",
+            "recipesPathUpdated": "配方儲存路徑已更新",
+            "recipesPathSaveFailed": "更新配方儲存路徑失敗：{message}",
             "settingsUpdated": "設定已更新：{setting}",
             "compactModeToggled": "緊湊模式已{state}",
             "settingSaveFailed": "儲存設定失敗：{message}",

py/config.py

@@ -134,6 +134,7 @@ class Config:
         self.extra_checkpoints_roots: List[str] = []
         self.extra_unet_roots: List[str] = []
         self.extra_embeddings_roots: List[str] = []
+        self.recipes_path: str = ""
         # Scan symbolic links during initialization
         self._initialize_symlink_mappings()
 
@@ -652,6 +653,8 @@ class Config:
             preview_roots.update(self._expand_preview_root(root))
         for root in self.extra_embeddings_roots or []:
             preview_roots.update(self._expand_preview_root(root))
+        if self.recipes_path:
+            preview_roots.update(self._expand_preview_root(self.recipes_path))
 
         for target, link in self._path_mappings.items():
             preview_roots.update(self._expand_preview_root(target))
@@ -911,9 +914,11 @@ class Config:
         self,
         folder_paths: Mapping[str, Iterable[str]],
         extra_folder_paths: Optional[Mapping[str, Iterable[str]]] = None,
+        recipes_path: str = "",
     ) -> None:
         self._path_mappings.clear()
         self._preview_root_paths = set()
+        self.recipes_path = recipes_path if isinstance(recipes_path, str) else ""
 
         lora_paths = folder_paths.get("loras", []) or []
         checkpoint_paths = folder_paths.get("checkpoints", []) or []
@@ -1169,7 +1174,12 @@ class Config:
         if not isinstance(extra_folder_paths, Mapping):
             extra_folder_paths = None
 
-        self._apply_library_paths(folder_paths, extra_folder_paths)
+        recipes_path = (
+            str(library_config.get("recipes_path", ""))
+            if isinstance(library_config, Mapping)
+            else ""
+        )
+        self._apply_library_paths(folder_paths, extra_folder_paths, recipes_path)
 
         logger.info(
             "Applied library settings with %d lora roots (%d extra), %d checkpoint roots (%d extra), and %d embedding roots (%d extra)",

py/lora_manager.py

@@ -222,6 +222,7 @@ class LoraManager:
 
             # Register DownloadManager with ServiceRegistry
             await ServiceRegistry.get_download_manager()
+            await ServiceRegistry.get_backup_service()
 
             from .services.metadata_service import initialize_metadata_providers
 

py/metadata_collector/metadata_processor.py

@@ -595,6 +595,15 @@ class MetadataProcessor:
                     if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
                         params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")
                 else:
-                    positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
+                    # Generic guider nodes often expose separate positive/negative inputs.
+                    positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "positive", max_depth=10)
+                    if not positive_node_id:
+                        positive_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
                     if positive_node_id and positive_node_id in metadata.get(PROMPTS, {}):
                         params["prompt"] = metadata[PROMPTS][positive_node_id].get("text", "")
+
+                    negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "negative", max_depth=10)
+                    if not negative_node_id:
+                        negative_node_id = MetadataProcessor.trace_node_input(prompt, guider_node_id, "conditioning", max_depth=10)
+                    if negative_node_id and negative_node_id in metadata.get(PROMPTS, {}):
+                        params["negative_prompt"] = metadata[PROMPTS][negative_node_id].get("text", "")

py/metadata_collector/node_extractors.py

@@ -1,4 +1,6 @@
+import json
 import os
+import re
 
 from .constants import MODELS, PROMPTS, SAMPLING, LORAS, SIZE, IMAGES, IS_SAMPLER
 
@@ -427,6 +429,75 @@ class ImageSizeExtractor(NodeMetadataExtractor):
             "node_id": node_id
         }
 
+class RgthreePowerLoraLoaderExtractor(NodeMetadataExtractor):
+    """Extract LoRA metadata from rgthree Power Lora Loader.
+
+    The node passes LoRAs as dynamic kwargs: LORA_1, LORA_2, ... each containing
+    {'on': bool, 'lora': filename, 'strength': float, 'strengthTwo': float}.
+    """
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs:
+            return
+
+        active_loras = []
+        for key, value in inputs.items():
+            if not key.upper().startswith('LORA_'):
+                continue
+            if not isinstance(value, dict):
+                continue
+            if not value.get('on') or not value.get('lora'):
+                continue
+            lora_name = os.path.splitext(os.path.basename(value['lora']))[0]
+            active_loras.append({
+                "name": lora_name,
+                "strength": round(float(value.get('strength', 1.0)), 2)
+            })
+
+        if active_loras:
+            metadata[LORAS][node_id] = {
+                "lora_list": active_loras,
+                "node_id": node_id
+            }
+
+
+class TensorRTLoaderExtractor(NodeMetadataExtractor):
+    """Extract checkpoint metadata from TensorRT Loader.
+
+    extract() parses the engine filename from 'unet_name' as a best-effort
+    fallback (strips profile suffix after '_$' and counter suffix).
+
+    update() checks if the output MODEL has attachments["source_model"]
+    set by the node (NubeBuster fork) and overrides with the real name.
+    Vanilla TRT doesn't set this — the filename parse stands.
+    """
+    @staticmethod
+    def extract(node_id, inputs, outputs, metadata):
+        if not inputs or "unet_name" not in inputs:
+            return
+        unet_name = inputs.get("unet_name")
+        # Strip path and extension, then drop the $_profile suffix
+        model_name = os.path.splitext(os.path.basename(unet_name))[0]
+        if "_$" in model_name:
+            model_name = model_name[:model_name.index("_$")]
+        # Strip counter suffix (e.g. _00001_) left by ComfyUI's save path
+        model_name = re.sub(r'_\d+_?$', '', model_name)
+        _store_checkpoint_metadata(metadata, node_id, model_name)
+
+    @staticmethod
+    def update(node_id, outputs, metadata):
+        if not outputs or not isinstance(outputs, list) or len(outputs) == 0:
+            return
+        first_output = outputs[0]
+        if not isinstance(first_output, tuple) or len(first_output) < 1:
+            return
+        model = first_output[0]
+        # NubeBuster fork sets attachments["source_model"] on the ModelPatcher
+        source_model = getattr(model, 'attachments', {}).get("source_model")
+        if source_model:
+            _store_checkpoint_metadata(metadata, node_id, source_model)
+
+
 class LoraLoaderManagerExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -577,8 +648,6 @@ class SamplerCustomAdvancedExtractor(BaseSamplerExtractor):
         # Extract latent dimensions
         BaseSamplerExtractor.extract_latent_dimensions(node_id, inputs, metadata)
 
-import json
-
 class CLIPTextEncodeFluxExtractor(NodeMetadataExtractor):
     @staticmethod
     def extract(node_id, inputs, outputs, metadata):
@@ -715,8 +784,11 @@ NODE_EXTRACTORS = {
     "UnetLoaderGGUF": UNETLoaderExtractor,  # Updated to use dedicated extractor
     "LoraLoader": LoraLoaderExtractor,
     "LoraLoaderLM": LoraLoaderManagerExtractor,
+    "RgthreePowerLoraLoader": RgthreePowerLoraLoaderExtractor,
+    "TensorRTLoader": TensorRTLoaderExtractor,
     # Conditioning
     "CLIPTextEncode": CLIPTextEncodeExtractor,
+    "CLIPTextEncodeAttentionBias": CLIPTextEncodeExtractor,  # From https://github.com/silveroxides/ComfyUI_PromptAttention
     "PromptLM": CLIPTextEncodeExtractor,
     "CLIPTextEncodeFlux": CLIPTextEncodeFluxExtractor,  # Add CLIPTextEncodeFlux
     "WAS_Text_to_Conditioning": CLIPTextEncodeExtractor,

py/middleware/csp_middleware.py

@@ -4,15 +4,21 @@ from typing import Awaitable, Callable, Dict, List
 
 from aiohttp import web
 
+# Use wildcard for CivitAI to support their CDN subdomains (e.g., image-b2.civitai.com)
+# Security note: This is acceptable because:
+# 1. CSP img-src only controls image/video loading, not script execution
+# 2. All *.civitai.com subdomains are controlled by Civitai
+# 3. Explicit domain list would require constant updates as Civitai adds CDN nodes
 REMOTE_MEDIA_SOURCES = (
-    "https://image.civitai.com",
+    "https://*.civitai.com",
     "https://img.genur.art",
 )
 
 
 @web.middleware
 async def relax_csp_for_remote_media(
-    request: web.Request, handler: Callable[[web.Request], Awaitable[web.StreamResponse]]
+    request: web.Request,
+    handler: Callable[[web.Request], Awaitable[web.StreamResponse]],
 ) -> web.StreamResponse:
     """Allow LoRA Manager media previews to load from trusted remote domains.
 
@@ -43,7 +49,9 @@ async def relax_csp_for_remote_media(
             directive_order.append(name)
         directives[name] = values
 
-    def merge_sources(name: str, sources: List[str], defaults: List[str] | None = None) -> None:
+    def merge_sources(
+        name: str, sources: List[str], defaults: List[str] | None = None
+    ) -> None:
         existing = directives.get(name, list(defaults or []))
 
         for source in sources:

py/routes/handlers/misc_handlers.py

@@ -9,11 +9,14 @@ objects that can be composed by the route controller.
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import json
 import logging
 import os
 import subprocess
 import sys
+import tempfile
+import zipfile
 from dataclasses import dataclass
 from typing import Awaitable, Callable, Dict, Mapping, Protocol
 
@@ -130,6 +133,22 @@ class MetadataArchiveManagerProtocol(Protocol):
         ...
 
 
+class BackupServiceProtocol(Protocol):
+    async def create_snapshot(
+        self, *, snapshot_type: str = "manual", persist: bool = False
+    ) -> dict:  # pragma: no cover - protocol
+        ...
+
+    async def restore_snapshot(self, archive_path: str) -> dict:  # pragma: no cover - protocol
+        ...
+
+    def get_status(self) -> dict:  # pragma: no cover - protocol
+        ...
+
+    def get_available_snapshots(self) -> list[dict]:  # pragma: no cover - protocol
+        ...
+
+
 class NodeRegistry:
     """Thread-safe registry for tracking LoRA nodes in active workflows."""
 
@@ -746,11 +765,17 @@ class ModelExampleFilesHandler:
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
 
+async def _noop_backup_service() -> None:
+    return None
+
+
 @dataclass
 class ServiceRegistryAdapter:
     get_lora_scanner: Callable[[], Awaitable]
     get_checkpoint_scanner: Callable[[], Awaitable]
     get_embedding_scanner: Callable[[], Awaitable]
+    get_downloaded_version_history_service: Callable[[], Awaitable]
+    get_backup_service: Callable[[], Awaitable] = _noop_backup_service
 
 
 class ModelLibraryHandler:
@@ -764,6 +789,41 @@ class ModelLibraryHandler:
         self._service_registry = service_registry
         self._metadata_provider_factory = metadata_provider_factory
 
+    @staticmethod
+    def _normalize_model_type(model_type: str | None) -> str | None:
+        if not isinstance(model_type, str):
+            return None
+        normalized = model_type.strip().lower()
+        if normalized in {"lora", "locon", "dora"}:
+            return "lora"
+        if normalized == "checkpoint":
+            return "checkpoint"
+        if normalized in {"embedding", "textualinversion"}:
+            return "embedding"
+        return None
+
+    async def _get_scanner_for_type(self, model_type: str | None):
+        normalized_type = self._normalize_model_type(model_type)
+        if normalized_type == "lora":
+            return normalized_type, await self._service_registry.get_lora_scanner()
+        if normalized_type == "checkpoint":
+            return normalized_type, await self._service_registry.get_checkpoint_scanner()
+        if normalized_type == "embedding":
+            return normalized_type, await self._service_registry.get_embedding_scanner()
+        return None, None
+
+    async def _get_download_history_service(self):
+        return await self._service_registry.get_downloaded_version_history_service()
+
+    @staticmethod
+    def _with_downloaded_flag(versions: list[dict]) -> list[dict]:
+        enriched: list[dict] = []
+        for version in versions:
+            entry = dict(version)
+            entry.setdefault("hasBeenDownloaded", True)
+            enriched.append(entry)
+        return enriched
+
     async def check_model_exists(self, request: web.Request) -> web.Response:
         try:
             model_id_str = request.query.get("modelId")
@@ -819,11 +879,30 @@ class ModelLibraryHandler:
                     exists = True
                     model_type = "embedding"
 
+                history_service = await self._get_download_history_service()
+                has_been_downloaded = False
+                history_type = model_type
+                if history_type:
+                    has_been_downloaded = await history_service.has_been_downloaded(
+                        history_type,
+                        model_version_id,
+                    )
+                else:
+                    for candidate_type in ("lora", "checkpoint", "embedding"):
+                        if await history_service.has_been_downloaded(
+                            candidate_type,
+                            model_version_id,
+                        ):
+                            has_been_downloaded = True
+                            history_type = candidate_type
+                            break
+
                 return web.json_response(
                     {
                         "success": True,
                         "exists": exists,
-                        "modelType": model_type if exists else None,
+                        "modelType": model_type if exists else history_type,
+                        "hasBeenDownloaded": has_been_downloaded,
                     }
                 )
 
@@ -841,23 +920,166 @@ class ModelLibraryHandler:
 
             model_type = None
             versions = []
+            downloaded_version_ids = []
+            history_service = await self._get_download_history_service()
             if lora_versions:
                 model_type = "lora"
-                versions = lora_versions
+                versions = self._with_downloaded_flag(lora_versions)
+                downloaded_version_ids = await history_service.get_downloaded_version_ids(
+                    model_type,
+                    model_id,
+                )
             elif checkpoint_versions:
                 model_type = "checkpoint"
-                versions = checkpoint_versions
+                versions = self._with_downloaded_flag(checkpoint_versions)
+                downloaded_version_ids = await history_service.get_downloaded_version_ids(
+                    model_type,
+                    model_id,
+                )
             elif embedding_versions:
                 model_type = "embedding"
-                versions = embedding_versions
+                versions = self._with_downloaded_flag(embedding_versions)
+                downloaded_version_ids = await history_service.get_downloaded_version_ids(
+                    model_type,
+                    model_id,
+                )
+            else:
+                for candidate_type in ("lora", "checkpoint", "embedding"):
+                    candidate_downloaded_version_ids = (
+                        await history_service.get_downloaded_version_ids(
+                            candidate_type,
+                            model_id,
+                        )
+                    )
+                    if candidate_downloaded_version_ids:
+                        model_type = candidate_type
+                        downloaded_version_ids = candidate_downloaded_version_ids
+                        break
 
             return web.json_response(
-                {"success": True, "modelType": model_type, "versions": versions}
+                {
+                    "success": True,
+                    "modelType": model_type,
+                    "versions": versions,
+                    "downloadedVersionIds": downloaded_version_ids,
+                }
             )
         except Exception as exc:  # pragma: no cover - defensive logging
             logger.error("Failed to check model existence: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+    async def get_model_version_download_status(
+        self, request: web.Request
+    ) -> web.Response:
+        try:
+            model_type, _ = await self._get_scanner_for_type(request.query.get("modelType"))
+            if not model_type:
+                return web.json_response(
+                    {"success": False, "error": "Parameter modelType is required"},
+                    status=400,
+                )
+
+            model_version_id_str = request.query.get("modelVersionId")
+            if not model_version_id_str:
+                return web.json_response(
+                    {"success": False, "error": "Missing required parameter: modelVersionId"},
+                    status=400,
+                )
+            try:
+                model_version_id = int(model_version_id_str)
+            except ValueError:
+                return web.json_response(
+                    {"success": False, "error": "Parameter modelVersionId must be an integer"},
+                    status=400,
+                )
+
+            history_service = await self._get_download_history_service()
+            return web.json_response(
+                {
+                    "success": True,
+                    "modelType": model_type,
+                    "modelVersionId": model_version_id,
+                    "hasBeenDownloaded": await history_service.has_been_downloaded(
+                        model_type,
+                        model_version_id,
+                    ),
+                }
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error(
+                "Failed to get model version download status: %s",
+                exc,
+                exc_info=True,
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def set_model_version_download_status(
+        self, request: web.Request
+    ) -> web.Response:
+        try:
+            if request.method == "GET":
+                data = request.query
+            else:
+                data = await request.json()
+            model_type, _ = await self._get_scanner_for_type(data.get("modelType"))
+            if not model_type:
+                return web.json_response(
+                    {"success": False, "error": "Parameter modelType is required"},
+                    status=400,
+                )
+
+            try:
+                model_version_id = int(data.get("modelVersionId"))
+            except (TypeError, ValueError):
+                return web.json_response(
+                    {"success": False, "error": "Parameter modelVersionId must be an integer"},
+                    status=400,
+                )
+
+            downloaded = data.get("downloaded")
+            if isinstance(downloaded, str):
+                normalized_downloaded = downloaded.strip().lower()
+                if normalized_downloaded in {"true", "1"}:
+                    downloaded = True
+                elif normalized_downloaded in {"false", "0"}:
+                    downloaded = False
+
+            if not isinstance(downloaded, bool):
+                return web.json_response(
+                    {"success": False, "error": "Parameter downloaded must be a boolean"},
+                    status=400,
+                )
+
+            history_service = await self._get_download_history_service()
+            if downloaded:
+                model_id = data.get("modelId")
+                file_path = data.get("filePath")
+                await history_service.mark_downloaded(
+                    model_type,
+                    model_version_id,
+                    model_id=model_id,
+                    source="manual",
+                    file_path=file_path if isinstance(file_path, str) else None,
+                )
+            else:
+                await history_service.mark_not_downloaded(model_type, model_version_id)
+
+            return web.json_response(
+                {
+                    "success": True,
+                    "modelType": model_type,
+                    "modelVersionId": model_version_id,
+                    "hasBeenDownloaded": downloaded,
+                }
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error(
+                "Failed to set model version download status: %s",
+                exc,
+                exc_info=True,
+            )
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
     async def get_model_versions_status(self, request: web.Request) -> web.Response:
         try:
             model_id_str = request.query.get("modelId")
@@ -896,18 +1118,8 @@ class ModelLibraryHandler:
             model_name = response.get("name", "")
             model_type = response.get("type", "").lower()
 
-            scanner = None
-            normalized_type = None
-            if model_type in {"lora", "locon", "dora"}:
-                scanner = await self._service_registry.get_lora_scanner()
-                normalized_type = "lora"
-            elif model_type == "checkpoint":
-                scanner = await self._service_registry.get_checkpoint_scanner()
-                normalized_type = "checkpoint"
-            elif model_type == "textualinversion":
-                scanner = await self._service_registry.get_embedding_scanner()
-                normalized_type = "embedding"
-            else:
+            normalized_type, scanner = await self._get_scanner_for_type(model_type)
+            if not normalized_type:
                 return web.json_response(
                     {
                         "success": False,
@@ -925,8 +1137,14 @@ class ModelLibraryHandler:
                     status=503,
                 )
 
+            history_service = await self._get_download_history_service()
             local_versions = await scanner.get_model_versions_by_id(model_id)
             local_version_ids = {version["versionId"] for version in local_versions}
+            downloaded_version_ids = await history_service.get_downloaded_version_ids(
+                normalized_type,
+                model_id,
+            )
+            downloaded_version_id_set = set(downloaded_version_ids)
 
             enriched_versions = []
             for version in versions:
@@ -939,6 +1157,7 @@ class ModelLibraryHandler:
                         if version.get("images")
                         else None,
                         "inLibrary": version_id in local_version_ids,
+                        "hasBeenDownloaded": version_id in downloaded_version_id_set,
                     }
                 )
 
@@ -1007,6 +1226,33 @@ class ModelLibraryHandler:
             }
 
             versions: list[dict] = []
+            history_service = await self._get_download_history_service()
+            model_ids: list[int] = []
+            for model in models:
+                try:
+                    model_ids.append(int(model.get("id")))
+                except (TypeError, ValueError):
+                    continue
+
+            lora_downloaded = await history_service.get_downloaded_version_ids_bulk(
+                "lora",
+                model_ids,
+            )
+            checkpoint_downloaded = await history_service.get_downloaded_version_ids_bulk(
+                "checkpoint",
+                model_ids,
+            )
+            embedding_downloaded = await history_service.get_downloaded_version_ids_bulk(
+                "embedding",
+                model_ids,
+            )
+            downloaded_version_map: Dict[str, Dict[int, set[int]]] = {
+                "lora": lora_downloaded,
+                "locon": lora_downloaded,
+                "dora": lora_downloaded,
+                "checkpoint": checkpoint_downloaded,
+                "textualinversion": embedding_downloaded,
+            }
             for model in models:
                 if not isinstance(model, dict):
                     continue
@@ -1061,6 +1307,8 @@ class ModelLibraryHandler:
                     in_library = await scanner.check_model_version_exists(
                         version_id_int
                     )
+                    downloaded_versions = downloaded_version_map.get(model_type, {})
+                    downloaded_version_ids = downloaded_versions.get(model_id_int, set())
 
                     versions.append(
                         {
@@ -1073,6 +1321,7 @@ class ModelLibraryHandler:
                             "baseModel": version.get("baseModel"),
                             "thumbnailUrl": thumbnail_url,
                             "inLibrary": in_library,
+                            "hasBeenDownloaded": version_id_int in downloaded_version_ids,
                         }
                     )
 
@@ -1193,10 +1442,150 @@ class MetadataArchiveHandler:
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
 
+class BackupHandler:
+    """Handler for user-state backup export/import."""
+
+    def __init__(
+        self,
+        *,
+        backup_service_factory: Callable[[], Awaitable[BackupServiceProtocol]] = ServiceRegistry.get_backup_service,
+    ) -> None:
+        self._backup_service_factory = backup_service_factory
+
+    async def get_backup_status(self, request: web.Request) -> web.Response:
+        try:
+            service = await self._backup_service_factory()
+            return web.json_response(
+                {
+                    "success": True,
+                    "status": service.get_status(),
+                    "snapshots": service.get_available_snapshots(),
+                }
+            )
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error("Error getting backup status: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def export_backup(self, request: web.Request) -> web.Response:
+        try:
+            service = await self._backup_service_factory()
+            result = await service.create_snapshot(snapshot_type="manual", persist=False)
+            headers = {
+                "Content-Type": "application/zip",
+                "Content-Disposition": f'attachment; filename="{result["archive_name"]}"',
+            }
+            return web.Response(body=result["archive_bytes"], headers=headers)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error("Error exporting backup: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
+    async def import_backup(self, request: web.Request) -> web.Response:
+        temp_path: str | None = None
+        try:
+            fd, temp_path = tempfile.mkstemp(
+                suffix=".zip", prefix="lora-manager-backup-"
+            )
+            os.close(fd)
+
+            if request.content_type.startswith("multipart/"):
+                reader = await request.multipart()
+                field = await reader.next()
+                uploaded = False
+                while field is not None:
+                    if getattr(field, "filename", None):
+                        with open(temp_path, "wb") as handle:
+                            while True:
+                                chunk = await field.read_chunk()
+                                if not chunk:
+                                    break
+                                handle.write(chunk)
+                        uploaded = True
+                        break
+                    field = await reader.next()
+                if not uploaded:
+                    return web.json_response(
+                        {"success": False, "error": "Missing backup archive"},
+                        status=400,
+                    )
+            else:
+                body = await request.read()
+                if not body:
+                    return web.json_response(
+                        {"success": False, "error": "Missing backup archive"},
+                        status=400,
+                    )
+                with open(temp_path, "wb") as handle:
+                    handle.write(body)
+
+            if not temp_path or not os.path.exists(temp_path) or os.path.getsize(temp_path) == 0:
+                return web.json_response(
+                    {"success": False, "error": "Missing backup archive"},
+                    status=400,
+                )
+
+            service = await self._backup_service_factory()
+            result = await service.restore_snapshot(temp_path)
+            return web.json_response({"success": True, **result})
+        except (ValueError, zipfile.BadZipFile) as exc:
+            logger.error("Error importing backup: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=400)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error("Error importing backup: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+        finally:
+            if temp_path and os.path.exists(temp_path):
+                with contextlib.suppress(OSError):
+                    os.remove(temp_path)
+
+
 class FileSystemHandler:
     def __init__(self, settings_service=None) -> None:
         self._settings = settings_service or get_settings_manager()
 
+    async def _open_path(self, path: str) -> web.Response:
+        path = os.path.abspath(path)
+        if not os.path.isdir(path):
+            return web.json_response(
+                {"success": False, "error": "Folder does not exist"},
+                status=404,
+            )
+
+        if os.name == "nt":
+            subprocess.Popen(["explorer", path])
+        elif os.name == "posix":
+            if _is_docker():
+                return web.json_response(
+                    {
+                        "success": True,
+                        "message": "Running in Docker: Path available for copying",
+                        "path": path,
+                        "mode": "clipboard",
+                    }
+                )
+            if _is_wsl():
+                windows_path = _wsl_to_windows_path(path)
+                if windows_path:
+                    subprocess.Popen(["explorer.exe", windows_path])
+                else:
+                    logger.error(
+                        "Failed to convert WSL path to Windows path: %s", path
+                    )
+                    return web.json_response(
+                        {
+                            "success": False,
+                            "error": "Failed to open folder location: path conversion error",
+                        },
+                        status=500,
+                    )
+            elif sys.platform == "darwin":
+                subprocess.Popen(["open", path])
+            else:
+                subprocess.Popen(["xdg-open", path])
+
+        return web.json_response(
+            {"success": True, "message": f"Opened folder: {path}", "path": path}
+        )
+
     async def open_file_location(self, request: web.Request) -> web.Response:
         try:
             data = await request.json()
@@ -1311,6 +1700,20 @@ class FileSystemHandler:
             logger.error("Failed to open settings location: %s", exc, exc_info=True)
             return web.json_response({"success": False, "error": str(exc)}, status=500)
 
+    async def open_backup_location(self, request: web.Request) -> web.Response:
+        try:
+            settings_file = getattr(self._settings, "settings_file", None)
+            if not settings_file:
+                return web.json_response(
+                    {"success": False, "error": "Settings file not found"}, status=404
+                )
+
+            backup_dir = os.path.join(os.path.dirname(os.path.abspath(settings_file)), "backups")
+            return await self._open_path(backup_dir)
+        except Exception as exc:  # pragma: no cover - defensive logging
+            logger.error("Failed to open backup location: %s", exc, exc_info=True)
+            return web.json_response({"success": False, "error": str(exc)}, status=500)
+
 
 class CustomWordsHandler:
     """Handler for autocomplete via TagFTSIndex."""
@@ -1615,6 +2018,7 @@ class MiscHandlerSet:
         node_registry: NodeRegistryHandler,
         model_library: ModelLibraryHandler,
         metadata_archive: MetadataArchiveHandler,
+        backup: BackupHandler,
         filesystem: FileSystemHandler,
         custom_words: CustomWordsHandler,
         supporters: SupportersHandler,
@@ -1630,6 +2034,7 @@ class MiscHandlerSet:
         self.node_registry = node_registry
         self.model_library = model_library
         self.metadata_archive = metadata_archive
+        self.backup = backup
         self.filesystem = filesystem
         self.custom_words = custom_words
         self.supporters = supporters
@@ -1655,13 +2060,19 @@ class MiscHandlerSet:
             "update_node_widget": self.node_registry.update_node_widget,
             "get_registry": self.node_registry.get_registry,
             "check_model_exists": self.model_library.check_model_exists,
+            "get_model_version_download_status": self.model_library.get_model_version_download_status,
+            "set_model_version_download_status": self.model_library.set_model_version_download_status,
             "get_civitai_user_models": self.model_library.get_civitai_user_models,
             "download_metadata_archive": self.metadata_archive.download_metadata_archive,
             "remove_metadata_archive": self.metadata_archive.remove_metadata_archive,
             "get_metadata_archive_status": self.metadata_archive.get_metadata_archive_status,
+            "get_backup_status": self.backup.get_backup_status,
+            "export_backup": self.backup.export_backup,
+            "import_backup": self.backup.import_backup,
             "get_model_versions_status": self.model_library.get_model_versions_status,
             "open_file_location": self.filesystem.open_file_location,
             "open_settings_location": self.filesystem.open_settings_location,
+            "open_backup_location": self.filesystem.open_backup_location,
             "search_custom_words": self.custom_words.search_custom_words,
             "get_supporters": self.supporters.get_supporters,
             "get_example_workflows": self.example_workflows.get_example_workflows,
@@ -1679,4 +2090,6 @@ def build_service_registry_adapter() -> ServiceRegistryAdapter:
         get_lora_scanner=ServiceRegistry.get_lora_scanner,
         get_checkpoint_scanner=ServiceRegistry.get_checkpoint_scanner,
         get_embedding_scanner=ServiceRegistry.get_embedding_scanner,
+        get_downloaded_version_history_service=ServiceRegistry.get_downloaded_version_history_service,
+        get_backup_service=ServiceRegistry.get_backup_service,
     )

py/routes/misc_route_registrar.py

@@ -37,6 +37,21 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition("POST", "/api/lm/update-node-widget", "update_node_widget"),
     RouteDefinition("GET", "/api/lm/get-registry", "get_registry"),
     RouteDefinition("GET", "/api/lm/check-model-exists", "check_model_exists"),
+    RouteDefinition(
+        "GET",
+        "/api/lm/model-version-download-status",
+        "get_model_version_download_status",
+    ),
+    RouteDefinition(
+        "POST",
+        "/api/lm/model-version-download-status",
+        "set_model_version_download_status",
+    ),
+    RouteDefinition(
+        "GET",
+        "/api/lm/set-model-version-download-status",
+        "set_model_version_download_status",
+    ),
     RouteDefinition("GET", "/api/lm/civitai/user-models", "get_civitai_user_models"),
     RouteDefinition(
         "POST", "/api/lm/download-metadata-archive", "download_metadata_archive"
@@ -47,6 +62,10 @@ MISC_ROUTE_DEFINITIONS: tuple[RouteDefinition, ...] = (
     RouteDefinition(
         "GET", "/api/lm/metadata-archive-status", "get_metadata_archive_status"
     ),
+    RouteDefinition("GET", "/api/lm/backup/status", "get_backup_status"),
+    RouteDefinition("POST", "/api/lm/backup/export", "export_backup"),
+    RouteDefinition("POST", "/api/lm/backup/import", "import_backup"),
+    RouteDefinition("POST", "/api/lm/backup/open-location", "open_backup_location"),
     RouteDefinition(
         "GET", "/api/lm/model-versions-status", "get_model_versions_status"
     ),

py/routes/misc_routes.py

@@ -23,6 +23,7 @@ from .handlers.misc_handlers import (
     FileSystemHandler,
     HealthCheckHandler,
     LoraCodeHandler,
+    BackupHandler,
     MetadataArchiveHandler,
     MiscHandlerSet,
     ModelExampleFilesHandler,
@@ -116,6 +117,7 @@ class MiscRoutes:
             settings_service=self._settings,
             metadata_provider_updater=self._metadata_provider_updater,
         )
+        backup = BackupHandler()
         filesystem = FileSystemHandler(settings_service=self._settings)
         node_registry_handler = NodeRegistryHandler(
             node_registry=self._node_registry,
@@ -141,6 +143,7 @@ class MiscRoutes:
             node_registry=node_registry_handler,
             model_library=model_library,
             metadata_archive=metadata_archive,
+            backup=backup,
             filesystem=filesystem,
             custom_words=custom_words,
             supporters=supporters,

py/services/backup_service.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import hashlib
+import json
+import logging
+import os
+import shutil
+import tempfile
+import time
+import zipfile
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterable, Optional
+
+from ..utils.cache_paths import CacheType, get_cache_base_dir, get_cache_file_path
+from ..utils.settings_paths import get_settings_dir
+from .settings_manager import get_settings_manager
+
+logger = logging.getLogger(__name__)
+
+
+BACKUP_MANIFEST_VERSION = 1
+DEFAULT_BACKUP_RETENTION_COUNT = 5
+DEFAULT_BACKUP_INTERVAL_SECONDS = 24 * 60 * 60
+
+
+@dataclass(frozen=True)
+class BackupEntry:
+    kind: str
+    archive_path: str
+    target_path: str
+    sha256: str
+    size: int
+    mtime: float
+
+
+class BackupService:
+    """Create and restore user-state backup archives."""
+
+    _instance: "BackupService | None" = None
+    _instance_lock = asyncio.Lock()
+
+    def __init__(self, *, settings_manager=None, backup_dir: str | None = None) -> None:
+        self._settings = settings_manager or get_settings_manager()
+        self._backup_dir = Path(backup_dir or self._resolve_backup_dir())
+        self._backup_dir.mkdir(parents=True, exist_ok=True)
+        self._lock = asyncio.Lock()
+        self._auto_task: asyncio.Task[None] | None = None
+
+    @classmethod
+    async def get_instance(cls) -> "BackupService":
+        async with cls._instance_lock:
+            if cls._instance is None:
+                cls._instance = cls()
+            cls._instance._ensure_auto_snapshot_task()
+            return cls._instance
+
+    @staticmethod
+    def _resolve_backup_dir() -> str:
+        return os.path.join(get_settings_dir(create=True), "backups")
+
+    def get_backup_dir(self) -> str:
+        return str(self._backup_dir)
+
+    def _ensure_auto_snapshot_task(self) -> None:
+        if self._auto_task is not None and not self._auto_task.done():
+            return
+
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return
+
+        self._auto_task = loop.create_task(self._auto_backup_loop())
+
+    def _get_setting_bool(self, key: str, default: bool) -> bool:
+        try:
+            return bool(self._settings.get(key, default))
+        except Exception:
+            return default
+
+    def _get_setting_int(self, key: str, default: int) -> int:
+        try:
+            value = self._settings.get(key, default)
+            return max(1, int(value))
+        except Exception:
+            return default
+
+    def _settings_file_path(self) -> str:
+        settings_file = getattr(self._settings, "settings_file", None)
+        if settings_file:
+            return str(settings_file)
+        return os.path.join(get_settings_dir(create=True), "settings.json")
+
+    def _download_history_path(self) -> str:
+        base_dir = get_cache_base_dir(create=True)
+        history_dir = os.path.join(base_dir, "download_history")
+        os.makedirs(history_dir, exist_ok=True)
+        return os.path.join(history_dir, "downloaded_versions.sqlite")
+
+    def _model_update_dir(self) -> str:
+        return str(Path(get_cache_file_path(CacheType.MODEL_UPDATE, create_dir=True)).parent)
+
+    def _model_update_targets(self) -> list[tuple[str, str, str]]:
+        """Return (kind, archive_path, target_path) tuples for backup."""
+
+        targets: list[tuple[str, str, str]] = []
+
+        settings_path = self._settings_file_path()
+        targets.append(("settings", "settings/settings.json", settings_path))
+
+        history_path = self._download_history_path()
+        targets.append(
+            (
+                "download_history",
+                "cache/download_history/downloaded_versions.sqlite",
+                history_path,
+            )
+        )
+
+        symlink_path = get_cache_file_path(CacheType.SYMLINK, create_dir=True)
+        targets.append(
+            (
+                "symlink_map",
+                "cache/symlink/symlink_map.json",
+                symlink_path,
+            )
+        )
+
+        model_update_dir = Path(self._model_update_dir())
+        if model_update_dir.exists():
+            for sqlite_file in sorted(model_update_dir.glob("*.sqlite")):
+                targets.append(
+                    (
+                        "model_update",
+                        f"cache/model_update/{sqlite_file.name}",
+                        str(sqlite_file),
+                    )
+                )
+
+        return targets
+
+    @staticmethod
+    def _hash_file(path: str) -> tuple[str, int, float]:
+        digest = hashlib.sha256()
+        total = 0
+        with open(path, "rb") as handle:
+            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                total += len(chunk)
+                digest.update(chunk)
+        mtime = os.path.getmtime(path)
+        return digest.hexdigest(), total, mtime
+
+    def _build_manifest(self, entries: Iterable[BackupEntry], *, snapshot_type: str) -> dict[str, Any]:
+        created_at = datetime.now(timezone.utc).isoformat()
+        active_library = None
+        try:
+            active_library = self._settings.get_active_library_name()
+        except Exception:
+            active_library = None
+
+        return {
+            "manifest_version": BACKUP_MANIFEST_VERSION,
+            "created_at": created_at,
+            "snapshot_type": snapshot_type,
+            "active_library": active_library,
+            "files": [
+                {
+                    "kind": entry.kind,
+                    "archive_path": entry.archive_path,
+                    "target_path": entry.target_path,
+                    "sha256": entry.sha256,
+                    "size": entry.size,
+                    "mtime": entry.mtime,
+                }
+                for entry in entries
+            ],
+        }
+
+    def _write_archive(self, archive_path: str, entries: list[BackupEntry], manifest: dict[str, Any]) -> None:
+        with zipfile.ZipFile(
+            archive_path,
+            mode="w",
+            compression=zipfile.ZIP_DEFLATED,
+            compresslevel=6,
+        ) as zf:
+            zf.writestr(
+                "manifest.json",
+                json.dumps(manifest, indent=2, ensure_ascii=False).encode("utf-8"),
+            )
+            for entry in entries:
+                zf.write(entry.target_path, arcname=entry.archive_path)
+
+    async def create_snapshot(self, *, snapshot_type: str = "manual", persist: bool = False) -> dict[str, Any]:
+        """Create a backup archive.
+
+        If ``persist`` is true, the archive is stored in the backup directory
+        and retained according to the configured retention policy.
+        """
+
+        async with self._lock:
+            raw_targets = self._model_update_targets()
+            entries: list[BackupEntry] = []
+            for kind, archive_path, target_path in raw_targets:
+                if not os.path.exists(target_path):
+                    continue
+                sha256, size, mtime = self._hash_file(target_path)
+                entries.append(
+                    BackupEntry(
+                        kind=kind,
+                        archive_path=archive_path,
+                        target_path=target_path,
+                        sha256=sha256,
+                        size=size,
+                        mtime=mtime,
+                    )
+                )
+
+            if not entries:
+                raise FileNotFoundError("No backupable files were found")
+
+            manifest = self._build_manifest(entries, snapshot_type=snapshot_type)
+            archive_name = self._build_archive_name(snapshot_type=snapshot_type)
+            fd, temp_path = tempfile.mkstemp(suffix=".zip", dir=str(self._backup_dir))
+            os.close(fd)
+
+            try:
+                self._write_archive(temp_path, entries, manifest)
+                if persist:
+                    final_path = self._backup_dir / archive_name
+                    os.replace(temp_path, final_path)
+                    self._prune_snapshots()
+                    return {
+                        "archive_path": str(final_path),
+                        "archive_name": final_path.name,
+                        "manifest": manifest,
+                    }
+
+                with open(temp_path, "rb") as handle:
+                    data = handle.read()
+                return {
+                    "archive_name": archive_name,
+                    "archive_bytes": data,
+                    "manifest": manifest,
+                }
+            finally:
+                with contextlib.suppress(FileNotFoundError):
+                    os.remove(temp_path)
+
+    def _build_archive_name(self, *, snapshot_type: str) -> str:
+        timestamp = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+        return f"lora-manager-backup-{timestamp}-{snapshot_type}.zip"
+
+    def _prune_snapshots(self) -> None:
+        retention = self._get_setting_int(
+            "backup_retention_count", DEFAULT_BACKUP_RETENTION_COUNT
+        )
+        archives = sorted(
+            self._backup_dir.glob("lora-manager-backup-*-auto.zip"),
+            key=lambda path: path.stat().st_mtime,
+            reverse=True,
+        )
+        for path in archives[retention:]:
+            with contextlib.suppress(OSError):
+                path.unlink()
+
+    async def restore_snapshot(self, archive_path: str) -> dict[str, Any]:
+        """Restore backup contents from a ZIP archive."""
+
+        async with self._lock:
+            try:
+                zf = zipfile.ZipFile(archive_path, mode="r")
+            except zipfile.BadZipFile as exc:
+                raise ValueError("Backup archive is not a valid ZIP file") from exc
+
+            with zf:
+                try:
+                    manifest = json.loads(zf.read("manifest.json").decode("utf-8"))
+                except KeyError as exc:
+                    raise ValueError("Backup archive is missing manifest.json") from exc
+
+                if not isinstance(manifest, dict):
+                    raise ValueError("Backup manifest is invalid")
+                if manifest.get("manifest_version") != BACKUP_MANIFEST_VERSION:
+                    raise ValueError("Backup manifest version is not supported")
+
+                files = manifest.get("files", [])
+                if not isinstance(files, list):
+                    raise ValueError("Backup manifest file list is invalid")
+
+                extracted_paths: list[tuple[str, str]] = []
+                temp_dir = Path(tempfile.mkdtemp(prefix="lora-manager-restore-"))
+                try:
+                    for item in files:
+                        if not isinstance(item, dict):
+                            continue
+                        archive_member = item.get("archive_path")
+                        if not isinstance(archive_member, str) or not archive_member:
+                            continue
+                        archive_member_path = Path(archive_member)
+                        if archive_member_path.is_absolute() or ".." in archive_member_path.parts:
+                            raise ValueError(f"Invalid archive member path: {archive_member}")
+
+                        kind = item.get("kind")
+                        target_path = self._resolve_restore_target(kind, archive_member)
+                        if target_path is None:
+                            continue
+
+                        extracted_path = temp_dir / archive_member_path
+                        extracted_path.parent.mkdir(parents=True, exist_ok=True)
+                        with zf.open(archive_member) as source, open(
+                            extracted_path, "wb"
+                        ) as destination:
+                            shutil.copyfileobj(source, destination)
+
+                        expected_hash = item.get("sha256")
+                        if isinstance(expected_hash, str) and expected_hash:
+                            actual_hash, _, _ = self._hash_file(str(extracted_path))
+                            if actual_hash != expected_hash:
+                                raise ValueError(
+                                    f"Checksum mismatch for {archive_member}"
+                                )
+
+                        extracted_paths.append((str(extracted_path), target_path))
+
+                    for extracted_path, target_path in extracted_paths:
+                        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+                        os.replace(extracted_path, target_path)
+                finally:
+                    shutil.rmtree(temp_dir, ignore_errors=True)
+
+            return {
+                "success": True,
+                "restored_files": len(extracted_paths),
+                "snapshot_type": manifest.get("snapshot_type"),
+            }
+
+    def _resolve_restore_target(self, kind: Any, archive_member: str) -> str | None:
+        if kind == "settings":
+            return self._settings_file_path()
+        if kind == "download_history":
+            return self._download_history_path()
+        if kind == "symlink_map":
+            return get_cache_file_path(CacheType.SYMLINK, create_dir=True)
+        if kind == "model_update":
+            filename = os.path.basename(archive_member)
+            return str(Path(get_cache_file_path(CacheType.MODEL_UPDATE, create_dir=True)).parent / filename)
+        return None
+
+    async def create_auto_snapshot_if_due(self) -> Optional[dict[str, Any]]:
+        if not self._get_setting_bool("backup_auto_enabled", True):
+            return None
+
+        latest = self.get_latest_auto_snapshot()
+        now = time.time()
+        if latest and now - latest["mtime"] < DEFAULT_BACKUP_INTERVAL_SECONDS:
+            return None
+
+        return await self.create_snapshot(snapshot_type="auto", persist=True)
+
+    async def _auto_backup_loop(self) -> None:
+        while True:
+            try:
+                await self.create_auto_snapshot_if_due()
+                await asyncio.sleep(DEFAULT_BACKUP_INTERVAL_SECONDS)
+            except asyncio.CancelledError:
+                raise
+            except Exception as exc:  # pragma: no cover - defensive guard
+                logger.warning("Automatic backup snapshot failed: %s", exc, exc_info=True)
+                await asyncio.sleep(60)
+
+    def get_available_snapshots(self) -> list[dict[str, Any]]:
+        snapshots: list[dict[str, Any]] = []
+        for path in sorted(self._backup_dir.glob("lora-manager-backup-*.zip")):
+            try:
+                stat = path.stat()
+            except OSError:
+                continue
+            snapshots.append(
+                {
+                    "name": path.name,
+                    "path": str(path),
+                    "size": stat.st_size,
+                    "mtime": stat.st_mtime,
+                    "is_auto": path.name.endswith("-auto.zip"),
+                }
+            )
+        snapshots.sort(key=lambda item: item["mtime"], reverse=True)
+        return snapshots
+
+    def get_latest_auto_snapshot(self) -> Optional[dict[str, Any]]:
+        autos = [snapshot for snapshot in self.get_available_snapshots() if snapshot["is_auto"]]
+        if not autos:
+            return None
+        return autos[0]
+
+    def get_status(self) -> dict[str, Any]:
+        snapshots = self.get_available_snapshots()
+        return {
+            "backupDir": self.get_backup_dir(),
+            "enabled": self._get_setting_bool("backup_auto_enabled", True),
+            "retentionCount": self._get_setting_int(
+                "backup_retention_count", DEFAULT_BACKUP_RETENTION_COUNT
+            ),
+            "snapshotCount": len(snapshots),
+            "latestSnapshot": snapshots[0] if snapshots else None,
+            "latestAutoSnapshot": self.get_latest_auto_snapshot(),
+        }

py/services/download_manager.py

@@ -64,6 +64,19 @@ class DownloadManager:
         """Get the checkpoint scanner from registry"""
         return await ServiceRegistry.get_checkpoint_scanner()
 
+    async def _has_been_downloaded(self, model_type: str, model_version_id: int) -> bool:
+        try:
+            history_service = await ServiceRegistry.get_downloaded_version_history_service()
+            return await history_service.has_been_downloaded(model_type, model_version_id)
+        except Exception as exc:
+            logger.debug(
+                "Failed to read download history for %s version %s: %s",
+                model_type,
+                model_version_id,
+                exc,
+            )
+            return False
+
     async def download_from_civitai(
         self,
         model_id: int = None,
@@ -355,6 +368,57 @@ class DownloadManager:
                     "error": f'Model type "{model_type_from_info}" is not supported for download',
                 }
 
+            resolved_version_id = model_version_id
+            raw_version_id = version_info.get("id")
+            if resolved_version_id is None and raw_version_id is not None:
+                try:
+                    resolved_version_id = int(raw_version_id)
+                except (TypeError, ValueError):
+                    resolved_version_id = None
+
+            if (
+                get_settings_manager().get_skip_previously_downloaded_model_versions()
+                and resolved_version_id is not None
+                and await self._has_been_downloaded(model_type, resolved_version_id)
+            ):
+                file_name = ""
+                files = version_info.get("files")
+                if isinstance(files, list):
+                    primary_file = next(
+                        (
+                            file_info
+                            for file_info in files
+                            if isinstance(file_info, dict) and file_info.get("primary")
+                        ),
+                        None,
+                    )
+                    selected_file = primary_file
+                    if selected_file is None:
+                        selected_file = next(
+                            (file_info for file_info in files if isinstance(file_info, dict)),
+                            None,
+                        )
+                    if isinstance(selected_file, dict):
+                        raw_file_name = selected_file.get("name", "")
+                        if isinstance(raw_file_name, str):
+                            file_name = raw_file_name.strip()
+
+                message = (
+                    f"Skipped download for '{file_name or version_info.get('name') or f'model_version:{resolved_version_id}'}' "
+                    f"because version {resolved_version_id} was already downloaded before"
+                )
+                logger.info(message)
+                return {
+                    "success": True,
+                    "skipped": True,
+                    "status": "skipped",
+                    "reason": "previously_downloaded_version",
+                    "message": message,
+                    "model_version_id": resolved_version_id,
+                    "file_name": file_name,
+                    "download_id": download_id,
+                }
+
             excluded_base_models = get_settings_manager().get_download_skip_base_models()
             base_model_value = version_info.get("baseModel", "")
             if (
@@ -640,6 +704,13 @@ class DownloadManager:
                     or version_info.get("modelId")
                     or (version_info.get("model") or {}).get("id")
                 )
+                await self._record_downloaded_version_history(
+                    model_type,
+                    resolved_model_id,
+                    version_info,
+                    model_version_id,
+                    save_path,
+                )
                 await self._sync_downloaded_version(
                     model_type,
                     resolved_model_id,
@@ -669,6 +740,55 @@ class DownloadManager:
                 }
             return {"success": False, "error": str(e)}
 
+    async def _record_downloaded_version_history(
+        self,
+        model_type: str,
+        model_id_value,
+        version_info: Dict,
+        fallback_version_id=None,
+        file_path: str | None = None,
+    ) -> None:
+        try:
+            history_service = await ServiceRegistry.get_downloaded_version_history_service()
+        except Exception as exc:
+            logger.debug(
+                "Skipping download history sync; failed to acquire history service: %s",
+                exc,
+            )
+            return
+
+        if history_service is None:
+            return
+
+        resolved_model_id = model_id_value
+        if resolved_model_id is None:
+            resolved_model_id = version_info.get("modelId")
+        if resolved_model_id is None:
+            model_info = version_info.get("model")
+            if isinstance(model_info, dict):
+                resolved_model_id = model_info.get("id")
+
+        version_id = version_info.get("id")
+        if version_id is None:
+            version_id = fallback_version_id
+
+        try:
+            await history_service.mark_downloaded(
+                model_type,
+                int(version_id),
+                model_id=int(resolved_model_id) if resolved_model_id is not None else None,
+                source="download",
+                file_path=file_path,
+            )
+        except (TypeError, ValueError):
+            logger.debug(
+                "Skipping download history sync; invalid identifiers model=%s version=%s",
+                resolved_model_id,
+                version_id,
+            )
+        except Exception as exc:
+            logger.debug("Failed to sync download history for %s: %s", model_type, exc)
+
     async def _sync_downloaded_version(
         self,
         model_type: str,

py/services/downloaded_version_history_service.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import sqlite3
+import time
+from typing import Iterable, Mapping, Optional, Sequence
+
+from ..utils.cache_paths import get_cache_base_dir
+from .settings_manager import get_settings_manager
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_model_type(model_type: str | None) -> Optional[str]:
+    if not isinstance(model_type, str):
+        return None
+    normalized = model_type.strip().lower()
+    if normalized in {"lora", "locon", "dora"}:
+        return "lora"
+    if normalized == "checkpoint":
+        return "checkpoint"
+    if normalized in {"embedding", "textualinversion"}:
+        return "embedding"
+    return None
+
+
+def _normalize_int(value) -> Optional[int]:
+    try:
+        if value is None:
+            return None
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _resolve_database_path() -> str:
+    base_dir = get_cache_base_dir(create=True)
+    history_dir = os.path.join(base_dir, "download_history")
+    os.makedirs(history_dir, exist_ok=True)
+    return os.path.join(history_dir, "downloaded_versions.sqlite")
+
+
+class DownloadedVersionHistoryService:
+    _SCHEMA = """
+        CREATE TABLE IF NOT EXISTS downloaded_model_versions (
+            model_type TEXT NOT NULL,
+            version_id INTEGER NOT NULL,
+            model_id INTEGER,
+            first_seen_at REAL NOT NULL,
+            last_seen_at REAL NOT NULL,
+            source TEXT NOT NULL,
+            last_file_path TEXT,
+            last_library_name TEXT,
+            is_deleted_override INTEGER NOT NULL DEFAULT 0,
+            PRIMARY KEY (model_type, version_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_downloaded_model_versions_model
+            ON downloaded_model_versions(model_type, model_id);
+    """
+
+    def __init__(self, db_path: str | None = None, *, settings_manager=None) -> None:
+        self._db_path = db_path or _resolve_database_path()
+        self._settings = settings_manager or get_settings_manager()
+        self._lock = asyncio.Lock()
+        self._schema_initialized = False
+        self._ensure_directory()
+        self._initialize_schema()
+
+    def _ensure_directory(self) -> None:
+        directory = os.path.dirname(self._db_path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+
+    def _connect(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self._db_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _initialize_schema(self) -> None:
+        if self._schema_initialized:
+            return
+        with self._connect() as conn:
+            conn.executescript(self._SCHEMA)
+            conn.commit()
+        self._schema_initialized = True
+
+    def get_database_path(self) -> str:
+        return self._db_path
+
+    def _get_active_library_name(self) -> str | None:
+        try:
+            value = self._settings.get_active_library_name()
+        except Exception:
+            return None
+        return value or None
+
+    async def mark_downloaded(
+        self,
+        model_type: str,
+        version_id: int,
+        *,
+        model_id: int | None = None,
+        source: str = "manual",
+        file_path: str | None = None,
+        library_name: str | None = None,
+    ) -> None:
+        normalized_type = _normalize_model_type(model_type)
+        normalized_version_id = _normalize_int(version_id)
+        normalized_model_id = _normalize_int(model_id)
+        if normalized_type is None or normalized_version_id is None:
+            return
+
+        active_library_name = library_name or self._get_active_library_name()
+        timestamp = time.time()
+
+        async with self._lock:
+            with self._connect() as conn:
+                conn.execute(
+                    """
+                    INSERT INTO downloaded_model_versions (
+                        model_type, version_id, model_id, first_seen_at, last_seen_at,
+                        source, last_file_path, last_library_name, is_deleted_override
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0)
+                    ON CONFLICT(model_type, version_id) DO UPDATE SET
+                        model_id = COALESCE(excluded.model_id, downloaded_model_versions.model_id),
+                        last_seen_at = excluded.last_seen_at,
+                        source = excluded.source,
+                        last_file_path = COALESCE(excluded.last_file_path, downloaded_model_versions.last_file_path),
+                        last_library_name = COALESCE(excluded.last_library_name, downloaded_model_versions.last_library_name),
+                        is_deleted_override = 0
+                    """,
+                    (
+                        normalized_type,
+                        normalized_version_id,
+                        normalized_model_id,
+                        timestamp,
+                        timestamp,
+                        source,
+                        file_path,
+                        active_library_name,
+                    ),
+                )
+                conn.commit()
+
+    async def mark_downloaded_bulk(
+        self,
+        model_type: str,
+        records: Sequence[Mapping[str, object]],
+        *,
+        source: str = "scan",
+        library_name: str | None = None,
+    ) -> None:
+        normalized_type = _normalize_model_type(model_type)
+        if normalized_type is None or not records:
+            return
+
+        timestamp = time.time()
+        active_library_name = library_name or self._get_active_library_name()
+        payload: list[tuple[object, ...]] = []
+        for record in records:
+            version_id = _normalize_int(record.get("version_id"))
+            if version_id is None:
+                continue
+            payload.append(
+                (
+                    normalized_type,
+                    version_id,
+                    _normalize_int(record.get("model_id")),
+                    timestamp,
+                    timestamp,
+                    source,
+                    record.get("file_path"),
+                    active_library_name,
+                )
+            )
+
+        if not payload:
+            return
+
+        async with self._lock:
+            with self._connect() as conn:
+                conn.executemany(
+                    """
+                    INSERT INTO downloaded_model_versions (
+                        model_type, version_id, model_id, first_seen_at, last_seen_at,
+                        source, last_file_path, last_library_name, is_deleted_override
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0)
+                    ON CONFLICT(model_type, version_id) DO UPDATE SET
+                        model_id = COALESCE(excluded.model_id, downloaded_model_versions.model_id),
+                        last_seen_at = excluded.last_seen_at,
+                        source = excluded.source,
+                        last_file_path = COALESCE(excluded.last_file_path, downloaded_model_versions.last_file_path),
+                        last_library_name = COALESCE(excluded.last_library_name, downloaded_model_versions.last_library_name),
+                        is_deleted_override = 0
+                    """,
+                    payload,
+                )
+                conn.commit()
+
+    async def mark_not_downloaded(self, model_type: str, version_id: int) -> None:
+        normalized_type = _normalize_model_type(model_type)
+        normalized_version_id = _normalize_int(version_id)
+        if normalized_type is None or normalized_version_id is None:
+            return
+
+        timestamp = time.time()
+
+        async with self._lock:
+            with self._connect() as conn:
+                conn.execute(
+                    """
+                    INSERT INTO downloaded_model_versions (
+                        model_type, version_id, model_id, first_seen_at, last_seen_at,
+                        source, last_file_path, last_library_name, is_deleted_override
+                    ) VALUES (?, ?, NULL, ?, ?, 'manual', NULL, ?, 1)
+                    ON CONFLICT(model_type, version_id) DO UPDATE SET
+                        last_seen_at = excluded.last_seen_at,
+                        source = excluded.source,
+                        last_library_name = COALESCE(excluded.last_library_name, downloaded_model_versions.last_library_name),
+                        is_deleted_override = 1
+                    """,
+                    (
+                        normalized_type,
+                        normalized_version_id,
+                        timestamp,
+                        timestamp,
+                        self._get_active_library_name(),
+                    ),
+                )
+                conn.commit()
+
+    async def has_been_downloaded(self, model_type: str, version_id: int) -> bool:
+        normalized_type = _normalize_model_type(model_type)
+        normalized_version_id = _normalize_int(version_id)
+        if normalized_type is None or normalized_version_id is None:
+            return False
+
+        async with self._lock:
+            with self._connect() as conn:
+                row = conn.execute(
+                    """
+                    SELECT is_deleted_override
+                    FROM downloaded_model_versions
+                    WHERE model_type = ? AND version_id = ?
+                    """,
+                    (normalized_type, normalized_version_id),
+                ).fetchone()
+        return bool(row) and not bool(row["is_deleted_override"])
+
+    async def get_downloaded_version_ids(
+        self, model_type: str, model_id: int
+    ) -> list[int]:
+        normalized_type = _normalize_model_type(model_type)
+        normalized_model_id = _normalize_int(model_id)
+        if normalized_type is None or normalized_model_id is None:
+            return []
+
+        async with self._lock:
+            with self._connect() as conn:
+                rows = conn.execute(
+                    """
+                    SELECT version_id
+                    FROM downloaded_model_versions
+                    WHERE model_type = ? AND model_id = ? AND is_deleted_override = 0
+                    ORDER BY version_id ASC
+                    """,
+                    (normalized_type, normalized_model_id),
+                ).fetchall()
+        return [int(row["version_id"]) for row in rows]
+
+    async def get_downloaded_version_ids_bulk(
+        self, model_type: str, model_ids: Iterable[int]
+    ) -> dict[int, set[int]]:
+        normalized_type = _normalize_model_type(model_type)
+        if normalized_type is None:
+            return {}
+
+        normalized_model_ids = sorted(
+            {
+                value
+                for value in (_normalize_int(model_id) for model_id in model_ids)
+                if value is not None
+            }
+        )
+        if not normalized_model_ids:
+            return {}
+
+        placeholders = ", ".join(["?"] * len(normalized_model_ids))
+        params: list[object] = [normalized_type, *normalized_model_ids]
+
+        async with self._lock:
+            with self._connect() as conn:
+                rows = conn.execute(
+                    f"""
+                    SELECT model_id, version_id
+                    FROM downloaded_model_versions
+                    WHERE model_type = ?
+                      AND model_id IN ({placeholders})
+                      AND is_deleted_override = 0
+                    """,
+                    params,
+                ).fetchall()
+
+        result: dict[int, set[int]] = {}
+        for row in rows:
+            model_id = _normalize_int(row["model_id"])
+            version_id = _normalize_int(row["version_id"])
+            if model_id is None or version_id is None:
+                continue
+            result.setdefault(model_id, set()).add(version_id)
+        return result

py/services/model_scanner.py

@@ -411,6 +411,7 @@ class ModelScanner:
             if scan_result:
                 await self._apply_scan_result(scan_result)
                 await self._save_persistent_cache(scan_result)
+                await self._sync_download_history(scan_result.raw_data, source='scan')
 
             # Send final progress update
             await ws_manager.broadcast_init_progress({
@@ -516,6 +517,7 @@ class ModelScanner:
         )
 
         await self._apply_scan_result(scan_result)
+        await self._sync_download_history(adjusted_raw_data, source='scan')
 
         await ws_manager.broadcast_init_progress({
             'stage': 'loading_cache',
@@ -576,6 +578,7 @@ class ModelScanner:
             excluded_models=list(self._excluded_models)
         )
         await self._save_persistent_cache(snapshot)
+        await self._sync_download_history(snapshot.raw_data, source='scan')
     def _count_model_files(self) -> int:
         """Count all model files with supported extensions in all roots
         
@@ -704,6 +707,7 @@ class ModelScanner:
             scan_result = await self._gather_model_data()
             await self._apply_scan_result(scan_result)
             await self._save_persistent_cache(scan_result)
+            await self._sync_download_history(scan_result.raw_data, source='scan')
 
             logger.info(
                 f"{self.model_type.capitalize()} Scanner: Cache initialization completed in {time.time() - start_time:.2f} seconds, "
@@ -1101,6 +1105,49 @@ class ModelScanner:
 
         await self._cache.resort()
 
+    async def _sync_download_history(
+        self,
+        raw_data: List[Mapping[str, Any]],
+        *,
+        source: str,
+    ) -> None:
+        records: List[Dict[str, Any]] = []
+        for item in raw_data or []:
+            if not isinstance(item, Mapping):
+                continue
+            civitai = item.get('civitai')
+            if not isinstance(civitai, Mapping):
+                continue
+
+            version_id = civitai.get('id')
+            if version_id in (None, ''):
+                continue
+
+            records.append(
+                {
+                    'version_id': version_id,
+                    'model_id': civitai.get('modelId'),
+                    'file_path': item.get('file_path'),
+                }
+            )
+
+        if not records:
+            return
+
+        try:
+            history_service = await ServiceRegistry.get_downloaded_version_history_service()
+            await history_service.mark_downloaded_bulk(
+                self.model_type,
+                records,
+                source=source,
+            )
+        except Exception as exc:
+            logger.debug(
+                "%s Scanner: Failed to sync download history: %s",
+                self.model_type.capitalize(),
+                exc,
+            )
+
     async def _gather_model_data(
         self,
         *,

py/services/model_update_service.py

@@ -12,6 +12,7 @@ from typing import Any, Dict, Iterable, List, Mapping, Optional, Sequence
 
 from .errors import RateLimitError, ResourceNotFoundError
 from .settings_manager import get_settings_manager
+from ..utils.cache_paths import CacheType, resolve_cache_path_with_migration
 from ..utils.civitai_utils import rewrite_preview_url
 from ..utils.preview_selection import resolve_mature_threshold, select_preview_media
 
@@ -234,12 +235,52 @@ class ModelUpdateService:
             ON model_update_versions(model_id);
     """
 
-    def __init__(self, db_path: str, *, ttl_seconds: int = 24 * 60 * 60, settings_manager=None) -> None:
-        self._db_path = db_path
+    def __init__(
+        self,
+        db_path: str | None = None,
+        *,
+        ttl_seconds: int = 24 * 60 * 60,
+        settings_manager=None,
+    ) -> None:
+        self._settings = settings_manager or get_settings_manager()
+        self._library_name = self._get_active_library_name()
+        self._db_path = db_path or self._resolve_default_path(self._library_name)
         self._ttl_seconds = ttl_seconds
         self._lock = asyncio.Lock()
         self._schema_initialized = False
-        self._settings = settings_manager or get_settings_manager()
+        self._custom_db_path = db_path is not None
+        self._ensure_directory()
+        self._initialize_schema()
+
+    def _get_active_library_name(self) -> str:
+        try:
+            value = self._settings.get_active_library_name()
+        except Exception:
+            value = None
+        return value or "default"
+
+    def _resolve_default_path(self, library_name: str) -> str:
+        env_override = os.environ.get("LORA_MANAGER_MODEL_UPDATE_DB")
+        return resolve_cache_path_with_migration(
+            CacheType.MODEL_UPDATE,
+            library_name=library_name,
+            env_override=env_override,
+        )
+
+    def on_library_changed(self) -> None:
+        """Switch to the database for the active library."""
+
+        if self._custom_db_path:
+            return
+
+        library_name = self._get_active_library_name()
+        new_path = self._resolve_default_path(library_name)
+        if new_path == self._db_path:
+            return
+
+        self._library_name = library_name
+        self._db_path = new_path
+        self._schema_initialized = False
         self._ensure_directory()
         self._initialize_schema()
 
@@ -262,11 +303,114 @@ class ModelUpdateService:
                 conn.execute("PRAGMA foreign_keys = ON")
                 conn.executescript(self._SCHEMA)
                 self._apply_migrations(conn)
+                self._migrate_from_legacy_snapshot(conn)
             self._schema_initialized = True
         except Exception as exc:  # pragma: no cover - defensive guard
             logger.error("Failed to initialize update schema: %s", exc, exc_info=True)
             raise
 
+    def _migrate_from_legacy_snapshot(self, conn: sqlite3.Connection) -> None:
+        """Copy update tracking data out of the legacy model snapshot database."""
+
+        if self._custom_db_path:
+            return
+
+        try:
+            from .persistent_model_cache import get_persistent_cache
+
+            legacy_path = get_persistent_cache(self._library_name).get_database_path()
+        except Exception:
+            return
+
+        if not legacy_path or os.path.abspath(legacy_path) == os.path.abspath(self._db_path):
+            return
+        if not os.path.exists(legacy_path):
+            return
+
+        try:
+            existing_row = conn.execute(
+                "SELECT 1 FROM model_update_status LIMIT 1"
+            ).fetchone()
+            if existing_row:
+                return
+        except Exception:
+            return
+
+        try:
+            with sqlite3.connect(legacy_path, check_same_thread=False) as legacy_conn:
+                legacy_conn.row_factory = sqlite3.Row
+                status_rows = legacy_conn.execute(
+                    """
+                    SELECT model_id, model_type, last_checked_at, should_ignore_model
+                    FROM model_update_status
+                    """
+                ).fetchall()
+                if not status_rows:
+                    return
+
+                version_rows = legacy_conn.execute(
+                    """
+                    SELECT model_id, version_id, sort_index, name, base_model, released_at,
+                           size_bytes, preview_url, is_in_library, should_ignore,
+                           early_access_ends_at, is_early_access
+                    FROM model_update_versions
+                    ORDER BY model_id ASC, sort_index ASC, version_id ASC
+                    """
+                ).fetchall()
+
+                conn.execute("BEGIN")
+                conn.executemany(
+                    """
+                    INSERT OR REPLACE INTO model_update_status (
+                        model_id, model_type, last_checked_at, should_ignore_model
+                    ) VALUES (?, ?, ?, ?)
+                    """,
+                    [
+                        (
+                            int(row["model_id"]),
+                            row["model_type"],
+                            row["last_checked_at"],
+                            int(row["should_ignore_model"] or 0),
+                        )
+                        for row in status_rows
+                    ],
+                )
+                conn.executemany(
+                    """
+                    INSERT OR REPLACE INTO model_update_versions (
+                        model_id, version_id, sort_index, name, base_model, released_at,
+                        size_bytes, preview_url, is_in_library, should_ignore,
+                        early_access_ends_at, is_early_access
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    """,
+                    [
+                        (
+                            int(row["model_id"]),
+                            int(row["version_id"]),
+                            int(row["sort_index"] or 0),
+                            row["name"],
+                            row["base_model"],
+                            row["released_at"],
+                            row["size_bytes"],
+                            row["preview_url"],
+                            int(row["is_in_library"] or 0),
+                            int(row["should_ignore"] or 0),
+                            row["early_access_ends_at"],
+                            int(row["is_early_access"] or 0),
+                        )
+                        for row in version_rows
+                    ],
+                )
+                conn.commit()
+                logger.info(
+                    "Migrated model update tracking data from legacy snapshot DB for %s",
+                    self._library_name,
+                )
+        except sqlite3.OperationalError as exc:
+            logger.debug("Legacy model update migration skipped: %s", exc)
+        except Exception as exc:  # pragma: no cover - defensive guard
+            logger.warning("Failed to migrate model update data: %s", exc, exc_info=True)
+
     def _apply_migrations(self, conn: sqlite3.Connection) -> None:
         """Ensure legacy databases match the current schema without dropping data."""
 

py/services/recipe_scanner.py

@@ -18,6 +18,7 @@ from .service_registry import ServiceRegistry
 from .lora_scanner import LoraScanner
 from .metadata_service import get_default_metadata_provider
 from .checkpoint_scanner import CheckpointScanner
+from .settings_manager import get_settings_manager
 from .recipes.errors import RecipeNotFoundError
 from ..utils.utils import calculate_recipe_fingerprint, fuzzy_match
 from natsort import natsorted
@@ -1090,6 +1091,14 @@ class RecipeScanner:
     @property
     def recipes_dir(self) -> str:
         """Get path to recipes directory"""
+        custom_recipes_dir = get_settings_manager().get("recipes_path", "")
+        if isinstance(custom_recipes_dir, str) and custom_recipes_dir.strip():
+            recipes_dir = os.path.abspath(
+                os.path.normpath(os.path.expanduser(custom_recipes_dir.strip()))
+            )
+            os.makedirs(recipes_dir, exist_ok=True)
+            return recipes_dir
+
         if not config.loras_roots:
             return ""
 

py/services/service_registry.py

@@ -159,10 +159,51 @@ class ServiceRegistry:
                 return cls._services[service_name]
 
             from .model_update_service import ModelUpdateService
-            from .persistent_model_cache import get_persistent_cache
+            from .settings_manager import get_settings_manager
 
-            cache = get_persistent_cache()
-            service = ModelUpdateService(cache.get_database_path())
+            service = ModelUpdateService(settings_manager=get_settings_manager())
+            cls._services[service_name] = service
+            logger.debug(f"Created and registered {service_name}")
+            return service
+
+    @classmethod
+    async def get_downloaded_version_history_service(cls):
+        """Get or create the downloaded-version history service."""
+
+        service_name = "downloaded_version_history_service"
+
+        if service_name in cls._services:
+            return cls._services[service_name]
+
+        async with cls._get_lock(service_name):
+            if service_name in cls._services:
+                return cls._services[service_name]
+
+            from .downloaded_version_history_service import (
+                DownloadedVersionHistoryService,
+            )
+
+            service = DownloadedVersionHistoryService()
+            cls._services[service_name] = service
+            logger.debug(f"Created and registered {service_name}")
+            return service
+
+    @classmethod
+    async def get_backup_service(cls):
+        """Get or create the backup service."""
+
+        service_name = "backup_service"
+
+        if service_name in cls._services:
+            return cls._services[service_name]
+
+        async with cls._get_lock(service_name):
+            if service_name in cls._services:
+                return cls._services[service_name]
+
+            from .backup_service import BackupService
+
+            service = await BackupService.get_instance()
             cls._services[service_name] = service
             logger.debug(f"Created and registered {service_name}")
             return service
@@ -255,4 +296,4 @@ class ServiceRegistry:
         """Clear all registered services - mainly for testing"""
         cls._services.clear()
         cls._locks.clear()
-        logger.info("Cleared all registered services")
+        logger.info("Cleared all registered services")

py/services/settings_manager.py

@@ -3,6 +3,7 @@ import copy
 import json
 import os
 import shutil
+import tempfile
 import logging
 from pathlib import Path
 from datetime import datetime, timezone
@@ -70,6 +71,7 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "default_checkpoint_root": "",
     "default_unet_root": "",
     "default_embedding_root": "",
+    "recipes_path": "",
     "base_model_path_mappings": {},
     "download_path_templates": {},
     "folder_paths": {},
@@ -91,7 +93,10 @@ DEFAULT_SETTINGS: Dict[str, Any] = {
     "update_flag_strategy": "same_base",
     "auto_organize_exclusions": [],
     "metadata_refresh_skip_paths": [],
+    "skip_previously_downloaded_model_versions": False,
     "download_skip_base_models": [],
+    "backup_auto_enabled": True,
+    "backup_retention_count": 5,
 }
 
 
@@ -253,6 +258,7 @@ class SettingsManager:
                 default_checkpoint_root=merged.get("default_checkpoint_root"),
                 default_unet_root=merged.get("default_unet_root"),
                 default_embedding_root=merged.get("default_embedding_root"),
+                recipes_path=merged.get("recipes_path"),
             )
         }
         merged["active_library"] = library_name
@@ -314,6 +320,10 @@ class SettingsManager:
             self.settings["download_skip_base_models"] = []
             inserted_defaults = True
 
+        if "skip_previously_downloaded_model_versions" not in self.settings:
+            self.settings["skip_previously_downloaded_model_versions"] = False
+            inserted_defaults = True
+
         had_mature_level = "mature_blur_level" in self.settings
         raw_mature_level = self.settings.get("mature_blur_level")
         normalized_mature_level = self.normalize_mature_blur_level(raw_mature_level)
@@ -377,6 +387,7 @@ class SettingsManager:
                 ),
                 default_unet_root=self.settings.get("default_unet_root", ""),
                 default_embedding_root=self.settings.get("default_embedding_root", ""),
+                recipes_path=self.settings.get("recipes_path", ""),
             )
             libraries = {library_name: library_payload}
             self.settings["libraries"] = libraries
@@ -424,6 +435,7 @@ class SettingsManager:
                 default_checkpoint_root=data.get("default_checkpoint_root"),
                 default_unet_root=data.get("default_unet_root"),
                 default_embedding_root=data.get("default_embedding_root"),
+                recipes_path=data.get("recipes_path"),
                 metadata=data.get("metadata"),
                 base=data,
             )
@@ -470,6 +482,7 @@ class SettingsManager:
         self.settings["default_embedding_root"] = active_library.get(
             "default_embedding_root", ""
         )
+        self.settings["recipes_path"] = active_library.get("recipes_path", "")
 
         if save:
             self._save_settings()
@@ -486,6 +499,7 @@ class SettingsManager:
         default_checkpoint_root: Optional[str] = None,
         default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
+        recipes_path: Optional[str] = None,
         metadata: Optional[Mapping[str, Any]] = None,
         base: Optional[Mapping[str, Any]] = None,
     ) -> Dict[str, Any]:
@@ -524,6 +538,11 @@ class SettingsManager:
         else:
             payload.setdefault("default_embedding_root", "")
 
+        if recipes_path is not None:
+            payload["recipes_path"] = recipes_path
+        else:
+            payload.setdefault("recipes_path", "")
+
         if metadata:
             merged_meta = dict(payload.get("metadata", {}))
             merged_meta.update(metadata)
@@ -625,6 +644,7 @@ class SettingsManager:
         default_checkpoint_root: Optional[str] = None,
         default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
+        recipes_path: Optional[str] = None,
     ) -> bool:
         libraries = self.settings.get("libraries", {})
         active_name = self.settings.get("active_library")
@@ -674,6 +694,10 @@ class SettingsManager:
             library["default_embedding_root"] = default_embedding_root
             changed = True
 
+        if recipes_path is not None and library.get("recipes_path") != recipes_path:
+            library["recipes_path"] = recipes_path
+            changed = True
+
         if changed:
             library.setdefault("created_at", self._current_timestamp())
             library["updated_at"] = self._current_timestamp()
@@ -937,7 +961,9 @@ class SettingsManager:
             extra_folder_paths=defaults.get("extra_folder_paths", {}),
             default_lora_root=defaults.get("default_lora_root"),
             default_checkpoint_root=defaults.get("default_checkpoint_root"),
+            default_unet_root=defaults.get("default_unet_root"),
             default_embedding_root=defaults.get("default_embedding_root"),
+            recipes_path=defaults.get("recipes_path"),
         )
         defaults["libraries"] = {library_name: default_library}
         defaults["active_library"] = library_name
@@ -1090,6 +1116,17 @@ class SettingsManager:
             self._save_settings()
         return base_models
 
+    def get_skip_previously_downloaded_model_versions(self) -> bool:
+        value = self.settings.get("skip_previously_downloaded_model_versions", False)
+        if isinstance(value, bool):
+            return value
+        normalized = False
+        if isinstance(value, str):
+            normalized = value.strip().lower() in {"1", "true", "yes", "on"}
+        self.settings["skip_previously_downloaded_model_versions"] = normalized
+        self._save_settings()
+        return normalized
+
     def get_extra_folder_paths(self) -> Dict[str, List[str]]:
         """Get extra folder paths for the active library.
 
@@ -1220,6 +1257,193 @@ class SettingsManager:
         """Get setting value"""
         return self.settings.get(key, default)
 
+    def _normalize_recipes_path_value(self, value: Any) -> str:
+        """Return a normalized absolute recipes path or an empty string."""
+
+        if not isinstance(value, str):
+            value = "" if value is None else str(value)
+
+        stripped = value.strip()
+        if not stripped:
+            return ""
+
+        return os.path.abspath(os.path.normpath(os.path.expanduser(stripped)))
+
+    def _get_effective_recipes_dir(self, recipes_path: Optional[str] = None) -> str:
+        """Resolve the effective recipes directory for the active library."""
+
+        normalized_custom = self._normalize_recipes_path_value(
+            self.settings.get("recipes_path", "")
+            if recipes_path is None
+            else recipes_path
+        )
+        if normalized_custom:
+            return normalized_custom
+
+        folder_paths = self.settings.get("folder_paths", {})
+        configured_lora_roots = []
+        if isinstance(folder_paths, Mapping):
+            raw_lora_roots = folder_paths.get("loras", [])
+            if isinstance(raw_lora_roots, Sequence) and not isinstance(
+                raw_lora_roots, (str, bytes)
+            ):
+                configured_lora_roots = [
+                    path
+                    for path in raw_lora_roots
+                    if isinstance(path, str) and path.strip()
+                ]
+
+        if configured_lora_roots:
+            lora_root = sorted(configured_lora_roots, key=str.casefold)[0]
+            return os.path.abspath(os.path.join(lora_root, "recipes"))
+
+        config_lora_roots = [
+            path
+            for path in getattr(config, "loras_roots", []) or []
+            if isinstance(path, str) and path.strip()
+        ]
+        if not config_lora_roots:
+            return ""
+
+        return os.path.abspath(
+            os.path.join(sorted(config_lora_roots, key=str.casefold)[0], "recipes")
+        )
+
+    def _validate_recipes_storage_path(self, normalized_path: str) -> None:
+        """Ensure the recipes storage target is usable before saving it."""
+
+        if not normalized_path:
+            return
+
+        if os.path.exists(normalized_path) and not os.path.isdir(normalized_path):
+            raise ValueError("Recipes path must point to a directory")
+
+        try:
+            os.makedirs(normalized_path, exist_ok=True)
+        except Exception as exc:
+            raise ValueError(f"Unable to create recipes directory: {exc}") from exc
+
+        try:
+            fd, probe_path = tempfile.mkstemp(
+                prefix=".lora-manager-recipes-", dir=normalized_path
+            )
+            os.close(fd)
+            os.remove(probe_path)
+        except Exception as exc:
+            raise ValueError(f"Recipes path is not writable: {exc}") from exc
+
+    def _migrate_recipes_directory(self, source_dir: str, target_dir: str) -> None:
+        """Move existing recipe files to a new recipes root and rewrite JSON paths."""
+
+        source = os.path.abspath(os.path.normpath(source_dir)) if source_dir else ""
+        target = os.path.abspath(os.path.normpath(target_dir)) if target_dir else ""
+        if not source or not target or source == target:
+            return
+
+        if not os.path.exists(source):
+            os.makedirs(target, exist_ok=True)
+            return
+
+        if os.path.exists(target) and not os.path.isdir(target):
+            raise ValueError("Recipes path must point to a directory")
+
+        try:
+            common_root = os.path.commonpath([source, target])
+        except ValueError as exc:
+            raise ValueError("Invalid recipes path change") from exc
+
+        if common_root == source:
+            raise ValueError("Recipes path cannot be moved into a nested directory")
+
+        planned_recipe_updates: Dict[str, Dict[str, Any]] = {}
+        file_pairs: List[Tuple[str, str]] = []
+
+        for root, _, files in os.walk(source):
+            for filename in files:
+                source_path = os.path.normpath(os.path.join(root, filename))
+                relative_path = os.path.relpath(source_path, source)
+                target_path = os.path.normpath(os.path.join(target, relative_path))
+                file_pairs.append((source_path, target_path))
+
+                if not filename.endswith(".recipe.json"):
+                    continue
+
+                try:
+                    with open(source_path, "r", encoding="utf-8") as handle:
+                        payload = json.load(handle)
+                except Exception as exc:
+                    raise ValueError(
+                        f"Unable to read recipe metadata during migration: {source_path}: {exc}"
+                    ) from exc
+
+                if not isinstance(payload, dict):
+                    continue
+
+                file_path = payload.get("file_path")
+                if isinstance(file_path, str) and file_path.strip():
+                    normalized_file_path = os.path.abspath(
+                        os.path.normpath(os.path.expanduser(file_path))
+                    )
+                    source_candidates = [source]
+                    real_source = os.path.abspath(
+                        os.path.normpath(os.path.realpath(source_dir))
+                    )
+                    if real_source not in source_candidates:
+                        source_candidates.append(real_source)
+
+                    rewritten = False
+                    for source_candidate in source_candidates:
+                        try:
+                            file_common_root = os.path.commonpath(
+                                [normalized_file_path, source_candidate]
+                            )
+                        except ValueError:
+                            continue
+
+                        if file_common_root != source_candidate:
+                            continue
+
+                        image_relative_path = os.path.relpath(
+                            normalized_file_path, source_candidate
+                        )
+                        payload["file_path"] = os.path.normpath(
+                            os.path.join(target, image_relative_path)
+                        )
+                        rewritten = True
+                        break
+
+                    if not rewritten and source_candidates:
+                        logger.debug(
+                            "Skipping recipe file_path rewrite during migration for %s",
+                            normalized_file_path,
+                        )
+
+                planned_recipe_updates[target_path] = payload
+
+        for _, target_path in file_pairs:
+            if os.path.exists(target_path):
+                raise ValueError(
+                    f"Recipes path already contains conflicting file: {target_path}"
+                )
+
+        os.makedirs(target, exist_ok=True)
+
+        for source_path, target_path in file_pairs:
+            os.makedirs(os.path.dirname(target_path), exist_ok=True)
+            shutil.move(source_path, target_path)
+
+        for target_path, payload in planned_recipe_updates.items():
+            with open(target_path, "w", encoding="utf-8") as handle:
+                json.dump(payload, handle, indent=4, ensure_ascii=False)
+
+        for root, dirs, files in os.walk(source, topdown=False):
+            if dirs or files:
+                continue
+            try:
+                os.rmdir(root)
+            except OSError:
+                pass
+
     def set(self, key: str, value: Any) -> None:
         """Set setting value and save"""
         if key == "auto_organize_exclusions":
@@ -1230,6 +1454,12 @@ class SettingsManager:
             value = self.normalize_download_skip_base_models(value)
         elif key == "mature_blur_level":
             value = self.normalize_mature_blur_level(value)
+        elif key == "recipes_path":
+            current_recipes_dir = self._get_effective_recipes_dir()
+            value = self._normalize_recipes_path_value(value)
+            target_recipes_dir = self._get_effective_recipes_dir(value)
+            self._validate_recipes_storage_path(target_recipes_dir)
+            self._migrate_recipes_directory(current_recipes_dir, target_recipes_dir)
         self.settings[key] = value
         portable_switch_pending = False
         if key == "use_portable_settings" and isinstance(value, bool):
@@ -1247,9 +1477,13 @@ class SettingsManager:
             self._update_active_library_entry(default_unet_root=str(value))
         elif key == "default_embedding_root":
             self._update_active_library_entry(default_embedding_root=str(value))
+        elif key == "recipes_path":
+            self._update_active_library_entry(recipes_path=str(value))
         elif key == "model_name_display":
             self._notify_model_name_display_change(value)
         self._save_settings()
+        if key == "recipes_path":
+            self._notify_library_change(self.get_active_library_name())
         if portable_switch_pending:
             self._finalize_portable_switch()
 
@@ -1559,6 +1793,7 @@ class SettingsManager:
         default_checkpoint_root: Optional[str] = None,
         default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
+        recipes_path: Optional[str] = None,
         metadata: Optional[Mapping[str, Any]] = None,
         activate: bool = False,
     ) -> Dict[str, Any]:
@@ -1602,6 +1837,11 @@ class SettingsManager:
                 if default_embedding_root is not None
                 else existing.get("default_embedding_root")
             ),
+            recipes_path=(
+                recipes_path
+                if recipes_path is not None
+                else existing.get("recipes_path")
+            ),
             metadata=metadata if metadata is not None else existing.get("metadata"),
             base=existing,
         )
@@ -1629,6 +1869,7 @@ class SettingsManager:
         default_checkpoint_root: str = "",
         default_unet_root: str = "",
         default_embedding_root: str = "",
+        recipes_path: str = "",
         metadata: Optional[Mapping[str, Any]] = None,
         activate: bool = False,
     ) -> Dict[str, Any]:
@@ -1646,6 +1887,7 @@ class SettingsManager:
             default_checkpoint_root=default_checkpoint_root,
             default_unet_root=default_unet_root,
             default_embedding_root=default_embedding_root,
+            recipes_path=recipes_path,
             metadata=metadata,
             activate=activate,
         )
@@ -1705,6 +1947,7 @@ class SettingsManager:
         default_checkpoint_root: Optional[str] = None,
         default_unet_root: Optional[str] = None,
         default_embedding_root: Optional[str] = None,
+        recipes_path: Optional[str] = None,
     ) -> None:
         """Update folder paths for the active library."""
 
@@ -1717,6 +1960,7 @@ class SettingsManager:
             default_checkpoint_root=default_checkpoint_root,
             default_unet_root=default_unet_root,
             default_embedding_root=default_embedding_root,
+            recipes_path=recipes_path,
             activate=True,
         )
 
@@ -1741,6 +1985,7 @@ class SettingsManager:
                 "checkpoint_scanner",
                 "embedding_scanner",
                 "recipe_scanner",
+                "model_update_service",
             ):
                 service = ServiceRegistry.get_service_sync(service_name)
                 if service and hasattr(service, "on_library_changed"):

py/utils/cache_paths.py

@@ -11,6 +11,8 @@ Target structure:
         │   └── symlink_map.json
         ├── model/
         │   └── {library_name}.sqlite
+        ├── model_update/
+        │   └── {library_name}.sqlite
         ├── recipe/
         │   └── {library_name}.sqlite
         └── fts/
@@ -36,6 +38,7 @@ class CacheType(Enum):
     """Types of cache files managed by the cache path resolver."""
 
     MODEL = "model"
+    MODEL_UPDATE = "model_update"
     RECIPE = "recipe"
     RECIPE_FTS = "recipe_fts"
     TAG_FTS = "tag_fts"
@@ -45,6 +48,7 @@ class CacheType(Enum):
 # Subdirectory structure for each cache type
 _CACHE_SUBDIRS = {
     CacheType.MODEL: "model",
+    CacheType.MODEL_UPDATE: "model_update",
     CacheType.RECIPE: "recipe",
     CacheType.RECIPE_FTS: "fts",
     CacheType.TAG_FTS: "fts",
@@ -54,6 +58,7 @@ _CACHE_SUBDIRS = {
 # Filename patterns for each cache type
 _CACHE_FILENAMES = {
     CacheType.MODEL: "{library_name}.sqlite",
+    CacheType.MODEL_UPDATE: "{library_name}.sqlite",
     CacheType.RECIPE: "{library_name}.sqlite",
     CacheType.RECIPE_FTS: "recipe_fts.sqlite",
     CacheType.TAG_FTS: "tag_fts.sqlite",

py/utils/civitai_utils.py

@@ -22,7 +22,9 @@ def _normalize_commercial_values(value: Any) -> Sequence[str]:
 
     def _split_aggregate(value_str: str) -> list[str]:
         stripped = value_str.strip()
-        looks_aggregate = "," in stripped or (stripped.startswith("{") and stripped.endswith("}"))
+        looks_aggregate = "," in stripped or (
+            stripped.startswith("{") and stripped.endswith("}")
+        )
         if not looks_aggregate:
             return [value_str]
 
@@ -141,14 +143,18 @@ def build_license_flags(payload: Mapping[str, Any] | None) -> int:
     return flags
 
 
-def resolve_license_info(model_data: Mapping[str, Any] | None) -> tuple[Dict[str, Any], int]:
+def resolve_license_info(
+    model_data: Mapping[str, Any] | None,
+) -> tuple[Dict[str, Any], int]:
     """Return normalized license payload and its encoded bitset."""
 
     payload = resolve_license_payload(model_data)
     return payload, build_license_flags(payload)
 
 
-def rewrite_preview_url(source_url: str | None, media_type: str | None = None) -> tuple[str | None, bool]:
+def rewrite_preview_url(
+    source_url: str | None, media_type: str | None = None
+) -> tuple[str | None, bool]:
     """Rewrite Civitai preview URLs to use optimized renditions.
 
     Args:
@@ -168,7 +174,12 @@ def rewrite_preview_url(source_url: str | None, media_type: str | None = None) -
     except ValueError:
         return source_url, False
 
-    if parsed.netloc.lower() != "image.civitai.com":
+    hostname = parsed.hostname
+    if hostname is None:
+        return source_url, False
+
+    hostname = hostname.lower()
+    if hostname == "civitai.com" or not hostname.endswith(".civitai.com"):
         return source_url, False
 
     replacement = "/width=450,optimized=true"

py/utils/constants.py

@@ -101,6 +101,7 @@ DEFAULT_PRIORITY_TAG_CONFIG = {
 DIFFUSION_MODEL_BASE_MODELS = frozenset(
     [
         "ZImageTurbo",
+        "ZImageBase",
         "Wan Video 1.3B t2v",
         "Wan Video 14B t2v",
         "Wan Video 14B i2v 480p",

py/utils/usage_stats.py

@@ -291,6 +291,80 @@ class UsageStats:
         # Process loras
         if LORAS in metadata and isinstance(metadata[LORAS], dict):
             await self._process_loras(metadata[LORAS], today)
+
+    def _increment_usage_counter(self, category: str, stat_key: str, today_date: str) -> None:
+        """Increment usage counters for a resolved stats key."""
+        if stat_key not in self.stats[category]:
+            self.stats[category][stat_key] = {
+                "total": 0,
+                "history": {}
+            }
+
+        self.stats[category][stat_key]["total"] += 1
+
+        if today_date not in self.stats[category][stat_key]["history"]:
+            self.stats[category][stat_key]["history"][today_date] = 0
+        self.stats[category][stat_key]["history"][today_date] += 1
+
+    def _normalize_model_lookup_name(self, model_name: str) -> str:
+        """Normalize a model reference to its base filename without extension."""
+        return os.path.splitext(os.path.basename(model_name))[0]
+
+    async def _find_cached_checkpoint_entry(self, checkpoint_scanner, model_name: str):
+        """Best-effort lookup for a checkpoint cache entry by filename/model name."""
+        get_cached_data = getattr(checkpoint_scanner, "get_cached_data", None)
+        if not callable(get_cached_data):
+            return None
+
+        cache = await get_cached_data()
+        raw_data = getattr(cache, "raw_data", None)
+        if not isinstance(raw_data, list):
+            return None
+
+        normalized_name = self._normalize_model_lookup_name(model_name)
+        for entry in raw_data:
+            if not isinstance(entry, dict):
+                continue
+
+            for candidate_key in ("file_name", "model_name", "file_path"):
+                candidate_value = entry.get(candidate_key)
+                if not candidate_value or not isinstance(candidate_value, str):
+                    continue
+                if self._normalize_model_lookup_name(candidate_value) == normalized_name:
+                    return entry
+
+        return None
+
+    async def _resolve_checkpoint_hash(self, checkpoint_scanner, model_name: str):
+        """Resolve a checkpoint hash, calculating pending hashes on demand when needed."""
+        model_filename = self._normalize_model_lookup_name(model_name)
+        model_hash = checkpoint_scanner.get_hash_by_filename(model_filename)
+        if model_hash:
+            return model_hash
+
+        cached_entry = await self._find_cached_checkpoint_entry(checkpoint_scanner, model_name)
+        if not cached_entry:
+            logger.warning(f"No hash found for checkpoint '{model_filename}', skipping usage tracking")
+            return None
+
+        cached_hash = cached_entry.get("sha256")
+        if cached_hash:
+            return cached_hash
+
+        if cached_entry.get("hash_status") == "pending":
+            calculate_hash = getattr(checkpoint_scanner, "calculate_hash_for_model", None)
+            file_path = cached_entry.get("file_path")
+            if callable(calculate_hash) and file_path:
+                calculated_hash = await calculate_hash(file_path)
+                if calculated_hash:
+                    return calculated_hash
+                logger.warning(
+                    f"Failed to calculate pending hash for checkpoint '{model_filename}', skipping usage tracking"
+                )
+                return None
+
+        logger.warning(f"No hash found for checkpoint '{model_filename}', skipping usage tracking")
+        return None
     
     async def _process_checkpoints(self, models_data, today_date):
         """Process checkpoint models from metadata"""
@@ -311,27 +385,12 @@ class UsageStats:
                     model_name = model_info.get("name")
                     if not model_name:
                         continue
-                    
-                    # Clean up filename (remove extension if present)
-                    model_filename = os.path.splitext(os.path.basename(model_name))[0]
-                    
-                    # Get hash for this checkpoint
-                    model_hash = checkpoint_scanner.get_hash_by_filename(model_filename)
-                    if model_hash:
-                        # Update stats for this checkpoint with date tracking
-                        if model_hash not in self.stats["checkpoints"]:
-                            self.stats["checkpoints"][model_hash] = {
-                                "total": 0,
-                                "history": {}
-                            }
-                        
-                        # Increment total count
-                        self.stats["checkpoints"][model_hash]["total"] += 1
-                        
-                        # Increment today's count
-                        if today_date not in self.stats["checkpoints"][model_hash]["history"]:
-                            self.stats["checkpoints"][model_hash]["history"][today_date] = 0
-                        self.stats["checkpoints"][model_hash]["history"][today_date] += 1
+
+                    model_hash = await self._resolve_checkpoint_hash(checkpoint_scanner, model_name)
+                    if not model_hash:
+                        continue
+
+                    self._increment_usage_counter("checkpoints", model_hash, today_date)
         except Exception as e:
             logger.error(f"Error processing checkpoint usage: {e}", exc_info=True)
     
@@ -360,21 +419,11 @@ class UsageStats:
                     
                     # Get hash for this LoRA
                     lora_hash = lora_scanner.get_hash_by_filename(lora_name)
-                    if lora_hash:
-                        # Update stats for this LoRA with date tracking
-                        if lora_hash not in self.stats["loras"]:
-                            self.stats["loras"][lora_hash] = {
-                                "total": 0,
-                                "history": {}
-                            }
-                        
-                        # Increment total count
-                        self.stats["loras"][lora_hash]["total"] += 1
-                        
-                        # Increment today's count
-                        if today_date not in self.stats["loras"][lora_hash]["history"]:
-                            self.stats["loras"][lora_hash]["history"][today_date] = 0
-                        self.stats["loras"][lora_hash]["history"][today_date] += 1
+                    if not lora_hash:
+                        logger.warning(f"No hash found for LoRA '{lora_name}', skipping usage tracking")
+                        continue
+
+                    self._increment_usage_counter("loras", lora_hash, today_date)
         except Exception as e:
             logger.error(f"Error processing LoRA usage: {e}", exc_info=True)
     

pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "comfyui-lora-manager"
 description = "Revolutionize your workflow with the ultimate LoRA companion for ComfyUI!"
-version = "1.0.1"
+version = "1.0.2"
 license = {file = "LICENSE"}
 dependencies = [
     "aiohttp",

static/css/components/modal/_base.css

@@ -311,6 +311,161 @@ button:disabled,
     color: var(--lora-error, #ef4444);
 }
 
+.backup-status {
+    background: rgba(0, 0, 0, 0.03);
+    border: 1px solid rgba(0, 0, 0, 0.1);
+    border-radius: var(--border-radius-sm);
+    padding: var(--space-3);
+}
+
+[data-theme="dark"] .backup-status {
+    background: rgba(255, 255, 255, 0.03);
+    border: 1px solid var(--lora-border);
+}
+
+.backup-summary-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(160px, 1fr));
+    gap: var(--space-2);
+    margin-bottom: var(--space-3);
+}
+
+.backup-summary-card {
+    background: rgba(255, 255, 255, 0.5);
+    border: 1px solid rgba(0, 0, 0, 0.06);
+    border-radius: var(--border-radius-sm);
+    padding: var(--space-2);
+}
+
+[data-theme="dark"] .backup-summary-card {
+    background: rgba(255, 255, 255, 0.02);
+    border-color: rgba(255, 255, 255, 0.05);
+}
+
+.backup-summary-label {
+    color: var(--text-color);
+    font-size: 0.85rem;
+    opacity: 0.7;
+    margin-bottom: 6px;
+}
+
+.backup-summary-value {
+    color: var(--text-color);
+    font-size: 1.1rem;
+    font-weight: 600;
+    line-height: 1.3;
+    word-break: break-word;
+}
+
+.backup-summary-value.status-enabled {
+    color: var(--lora-success, #10b981);
+}
+
+.backup-summary-value.status-disabled {
+    color: var(--lora-error, #ef4444);
+}
+
+.backup-status-list {
+    display: flex;
+    flex-direction: column;
+    gap: var(--space-2);
+}
+
+.backup-status-row {
+    display: grid;
+    grid-template-columns: minmax(140px, 180px) 1fr;
+    gap: var(--space-2);
+    align-items: start;
+}
+
+.backup-status-label {
+    color: var(--text-color);
+    font-weight: 500;
+    opacity: 0.8;
+}
+
+.backup-status-content {
+    min-width: 0;
+}
+
+.backup-status-primary {
+    color: var(--text-color);
+    font-weight: 600;
+    line-height: 1.4;
+}
+
+.backup-status-secondary {
+    color: var(--text-color);
+    opacity: 0.72;
+    font-size: 0.88rem;
+    line-height: 1.4;
+    word-break: break-word;
+    margin-top: 2px;
+}
+
+.backup-location-details {
+    border: 1px solid rgba(0, 0, 0, 0.1);
+    border-radius: var(--border-radius-sm);
+    background: rgba(0, 0, 0, 0.02);
+}
+
+[data-theme="dark"] .backup-location-details {
+    border-color: var(--lora-border);
+    background: rgba(255, 255, 255, 0.02);
+}
+
+.backup-location-details summary {
+    cursor: pointer;
+    padding: var(--space-2) var(--space-3);
+    color: var(--text-color);
+    font-weight: 500;
+}
+
+.backup-location-panel {
+    display: grid;
+    grid-template-columns: minmax(0, 1fr) auto;
+    gap: var(--space-2);
+    align-items: center;
+    width: 100%;
+    max-width: 100%;
+    box-sizing: border-box;
+    padding: 0 var(--space-3) var(--space-3);
+}
+
+.backup-location-panel .text-btn {
+    justify-self: end;
+}
+
+.backup-location-path {
+    display: block;
+    min-width: 0;
+    max-width: 100%;
+    padding: 6px 8px;
+    border-radius: var(--border-radius-sm);
+    background: rgba(0, 0, 0, 0.05);
+    color: var(--text-color);
+    overflow-wrap: anywhere;
+    word-break: break-word;
+}
+
+[data-theme="dark"] .backup-location-path {
+    background: rgba(255, 255, 255, 0.05);
+}
+
+@media (max-width: 768px) {
+    .backup-status-row {
+        grid-template-columns: 1fr;
+    }
+
+    .backup-location-panel {
+        grid-template-columns: 1fr;
+    }
+
+    .backup-location-panel .text-btn {
+        justify-self: start;
+    }
+}
+
 /* Add styles for delete preview image */
 .delete-preview {
     max-width: 150px;

static/css/components/modal/settings-modal.css

@@ -102,6 +102,13 @@
     overflow-y: auto;
     padding: var(--space-3);
     scroll-behavior: smooth;
+    scrollbar-gutter: stable;
+}
+
+@supports not (scrollbar-gutter: stable) {
+    .settings-content {
+        overflow-y: scroll;
+    }
 }
 
 .settings-content .settings-form {

static/css/components/recipe-modal.css

@@ -1036,6 +1036,73 @@
     }
 }
 
+@media (max-height: 860px) {
+    #recipeModal .modal-content {
+        padding-top: var(--space-2);
+        padding-bottom: var(--space-2);
+    }
+
+    .recipe-modal-header {
+        padding-bottom: 6px;
+        margin-bottom: 8px;
+    }
+
+    .recipe-modal-header h2 {
+        font-size: 1.25em;
+        max-height: 2.5em;
+    }
+
+    .recipe-tags-container {
+        margin-bottom: 6px;
+    }
+
+    .recipe-top-section {
+        grid-template-columns: 1fr;
+        gap: var(--space-1);
+        margin-bottom: var(--space-1);
+    }
+
+    .recipe-preview-container {
+        display: none;
+    }
+
+    .recipe-gen-params {
+        height: auto;
+        max-height: 210px;
+    }
+
+    .recipe-gen-params h3 {
+        margin-bottom: var(--space-1);
+        font-size: 1.05em;
+    }
+
+    .gen-params-container {
+        gap: var(--space-1);
+    }
+
+    .param-content {
+        max-height: 90px;
+        padding: 10px;
+    }
+
+    .param-textarea {
+        min-height: 100px;
+    }
+
+    .other-params {
+        margin-top: 0;
+        gap: 6px;
+    }
+
+    .recipe-bottom-section {
+        padding-top: var(--space-1);
+    }
+
+    .recipe-section-header {
+        margin-bottom: var(--space-1);
+    }
+}
+
 .badge-container {
     position: relative;
     display: flex;

static/js/managers/SettingsManager.js

@@ -146,6 +146,10 @@ export class SettingsManager {
             backendSettings?.metadata_refresh_skip_paths ?? defaults.metadata_refresh_skip_paths
         );
 
+        merged.skip_previously_downloaded_model_versions =
+            backendSettings?.skip_previously_downloaded_model_versions
+            ?? defaults.skip_previously_downloaded_model_versions;
+
         merged.download_skip_base_models = this.normalizeDownloadSkipBaseModels(
             backendSettings?.download_skip_base_models ?? defaults.download_skip_base_models
         );
@@ -357,6 +361,13 @@ export class SettingsManager {
             });
         }
 
+        const openBackupLocationButton = document.getElementById('backupOpenLocationBtn');
+        if (openBackupLocationButton) {
+            openBackupLocationButton.addEventListener('click', () => {
+                this.openBackupLocation();
+            });
+        }
+
         ['lora', 'checkpoint', 'embedding'].forEach(modelType => {
             const customInput = document.getElementById(`${modelType}CustomTemplate`);
             if (customInput) {
@@ -738,6 +749,35 @@ export class SettingsManager {
         }
     }
 
+    async openBackupLocation() {
+        try {
+            const response = await fetch('/api/lm/backup/open-location', {
+                method: 'POST'
+            });
+
+            if (!response.ok) {
+                throw new Error(`Request failed with status ${response.status}`);
+            }
+
+            const data = await response.json();
+
+            if (data.mode === 'clipboard' && data.path) {
+                try {
+                    await navigator.clipboard.writeText(data.path);
+                    showToast('settings.backup.locationCopied', { path: data.path }, 'success');
+                } catch (clipboardErr) {
+                    console.warn('Clipboard API not available:', clipboardErr);
+                    showToast('settings.backup.locationClipboardFallback', { path: data.path }, 'info');
+                }
+            } else {
+                showToast('settings.backup.openFolderSuccess', {}, 'success');
+            }
+        } catch (error) {
+            console.error('Failed to open backup folder:', error);
+            showToast('settings.backup.openFolderFailed', {}, 'error');
+        }
+    }
+
     async loadSettingsToUI() {
         // Set frontend settings from state
         const blurMatureContentCheckbox = document.getElementById('blurMatureContent');
@@ -762,6 +802,11 @@ export class SettingsManager {
             usePortableCheckbox.checked = !!state.global.settings.use_portable_settings;
         }
 
+        const recipesPathInput = document.getElementById('recipesPath');
+        if (recipesPathInput) {
+            recipesPathInput.value = state.global.settings.recipes_path || '';
+        }
+
         const autoOrganizeExclusionsInput = document.getElementById('autoOrganizeExclusions');
         if (autoOrganizeExclusionsInput) {
             const patterns = this.normalizePatternList(state.global.settings.auto_organize_exclusions);
@@ -836,6 +881,12 @@ export class SettingsManager {
             hideEarlyAccessUpdatesCheckbox.checked = state.global.settings.hide_early_access_updates || false;
         }
 
+        const skipPreviouslyDownloadedModelVersionsCheckbox = document.getElementById('skipPreviouslyDownloadedModelVersions');
+        if (skipPreviouslyDownloadedModelVersionsCheckbox) {
+            skipPreviouslyDownloadedModelVersionsCheckbox.checked =
+                state.global.settings.skip_previously_downloaded_model_versions || false;
+        }
+
         // Set optimize example images setting
         const optimizeExampleImagesCheckbox = document.getElementById('optimizeExampleImages');
         if (optimizeExampleImagesCheckbox) {
@@ -863,6 +914,9 @@ export class SettingsManager {
         // Load metadata archive settings
         await this.loadMetadataArchiveSettings();
 
+        // Load backup settings
+        await this.loadBackupSettings();
+
         // Load base model path mappings
         this.loadBaseModelMappings();
 
@@ -1842,6 +1896,10 @@ export class SettingsManager {
                 await this.updateMetadataArchiveStatus();
             }
 
+            if (settingKey === 'backup_auto_enabled') {
+                await this.updateBackupStatus();
+            }
+
             showToast('toast.settings.settingsUpdated', { setting: settingKey.replace(/_/g, ' ') }, 'success');
 
             // Apply frontend settings immediately
@@ -1930,6 +1988,163 @@ export class SettingsManager {
         }
     }
 
+    async loadBackupSettings() {
+        const backupAutoEnabledCheckbox = document.getElementById('backupAutoEnabled');
+        if (backupAutoEnabledCheckbox) {
+            backupAutoEnabledCheckbox.checked = state.global.settings.backup_auto_enabled ?? true;
+        }
+
+        const backupRetentionCountInput = document.getElementById('backupRetentionCount');
+        if (backupRetentionCountInput) {
+            backupRetentionCountInput.value = state.global.settings.backup_retention_count ?? 5;
+        }
+
+        await this.updateBackupStatus();
+    }
+
+    async updateBackupStatus() {
+        try {
+            const response = await fetch('/api/lm/backup/status');
+            const data = await response.json();
+
+            const statusContainer = document.getElementById('backupStatus');
+            if (!statusContainer || !data.success) {
+                return;
+            }
+
+            const status = data.status || {};
+            const latestAutoSnapshot = status.latestAutoSnapshot;
+            const retentionCount = status.retentionCount ?? state.global.settings.backup_retention_count ?? 5;
+            const enabled = status.enabled ?? state.global.settings.backup_auto_enabled ?? true;
+            const backupDir = status.backupDir || '';
+            const backupLocationPath = document.getElementById('backupLocationPath');
+            if (backupLocationPath) {
+                backupLocationPath.textContent = backupDir;
+                backupLocationPath.title = backupDir;
+            }
+
+            const formatTimestamp = (timestamp) => {
+                if (!timestamp) {
+                    return translate('common.status.unknown', {}, 'Unknown');
+                }
+                return new Date(timestamp * 1000).toLocaleString();
+            };
+
+            const renderSnapshotDetail = (snapshot) => {
+                if (!snapshot) {
+                    return translate('settings.backup.noneAvailable', {}, 'No snapshots yet');
+                }
+
+                const size = typeof snapshot.size === 'number' ? ` (${this.formatFileSize(snapshot.size)})` : '';
+                return `${snapshot.name}${size}`;
+            };
+
+            statusContainer.innerHTML = `
+                <div class="backup-summary-grid">
+                    <div class="backup-summary-card">
+                        <div class="backup-summary-label">${translate('settings.backup.autoEnabled', {}, 'Automatic snapshots')}</div>
+                        <div class="backup-summary-value status-${enabled ? 'enabled' : 'disabled'}">
+                            ${enabled ? translate('common.status.enabled') : translate('common.status.disabled')}
+                        </div>
+                    </div>
+                    <div class="backup-summary-card">
+                        <div class="backup-summary-label">${translate('settings.backup.retention', {}, 'Retention')}</div>
+                        <div class="backup-summary-value">${retentionCount}</div>
+                    </div>
+                    <div class="backup-summary-card">
+                        <div class="backup-summary-label">${translate('settings.backup.snapshotCount', {}, 'Saved snapshots')}</div>
+                        <div class="backup-summary-value">${status.snapshotCount ?? 0}</div>
+                    </div>
+                </div>
+                <div class="backup-status-list">
+                    <div class="backup-status-row">
+                        <div class="backup-status-label">${translate('settings.backup.latestAutoSnapshot', {}, 'Latest auto snapshot')}</div>
+                        <div class="backup-status-content">
+                            <div class="backup-status-primary">${formatTimestamp(latestAutoSnapshot?.mtime)}</div>
+                            <div class="backup-status-secondary">${renderSnapshotDetail(latestAutoSnapshot)}</div>
+                        </div>
+                    </div>
+                </div>
+            `;
+        } catch (error) {
+            console.error('Error updating backup status:', error);
+        }
+    }
+
+    async exportBackup() {
+        try {
+            const response = await fetch('/api/lm/backup/export', {
+                method: 'POST',
+            });
+
+            if (!response.ok) {
+                throw new Error(`Request failed with status ${response.status}`);
+            }
+
+            const blob = await response.blob();
+            const contentDisposition = response.headers.get('Content-Disposition') || '';
+            const match = contentDisposition.match(/filename="([^"]+)"/);
+            const filename = match?.[1] || `lora-manager-backup-${Date.now()}.zip`;
+
+            const url = window.URL.createObjectURL(blob);
+            const link = document.createElement('a');
+            link.href = url;
+            link.download = filename;
+            document.body.appendChild(link);
+            link.click();
+            link.remove();
+            window.URL.revokeObjectURL(url);
+
+            showToast('settings.backup.exportSuccess', {}, 'success');
+        } catch (error) {
+            console.error('Failed to export backup:', error);
+            showToast('settings.backup.exportFailed', { message: error.message }, 'error');
+        }
+    }
+
+    triggerBackupImport() {
+        const input = document.getElementById('backupImportInput');
+        input?.click();
+    }
+
+    async handleBackupImportFile(input) {
+        if (!(input instanceof HTMLInputElement)) {
+            return;
+        }
+
+        const file = input.files?.[0];
+        input.value = '';
+        if (!file) {
+            return;
+        }
+
+        if (!confirm(translate('settings.backup.importConfirm', {}, 'Import this backup and overwrite local user state?'))) {
+            return;
+        }
+
+        try {
+            const formData = new FormData();
+            formData.append('archive', file);
+
+            const response = await fetch('/api/lm/backup/import', {
+                method: 'POST',
+                body: formData,
+            });
+
+            const data = await response.json();
+            if (!response.ok || data.success === false) {
+                throw new Error(data.error || `Request failed with status ${response.status}`);
+            }
+
+            showToast('settings.backup.importSuccess', {}, 'success');
+            await this.updateBackupStatus();
+            window.location.reload();
+        } catch (error) {
+            console.error('Failed to import backup:', error);
+            showToast('settings.backup.importFailed', { message: error.message }, 'error');
+        }
+    }
+
     async updateMetadataArchiveStatus() {
         try {
             const response = await fetch('/api/lm/metadata-archive-status');
@@ -2454,14 +2669,24 @@ export class SettingsManager {
         if (!element) return;
 
         const value = element.value.trim(); // Trim whitespace
+        const shouldShowLoading = settingKey === 'recipes_path';
 
         try {
             // Check if value has changed from existing value
-            const currentValue = state.global.settings[settingKey] || '';
-            if (value === currentValue) {
+            const currentValue = state.global.settings[settingKey];
+            const normalizedCurrentValue = currentValue === undefined || currentValue === null
+                ? ''
+                : String(currentValue).trim();
+            if (value === normalizedCurrentValue) {
                 return; // No change, exit early
             }
 
+            if (shouldShowLoading) {
+                state.loadingManager?.showSimpleLoading(
+                    translate('settings.folderSettings.recipesPathMigrating', {}, 'Migrating recipes...')
+                );
+            }
+
             // For username and password, handle empty values specially
             if ((settingKey === 'proxy_username' || settingKey === 'proxy_password') && value === '') {
                 // Remove from state instead of setting to empty string
@@ -2487,10 +2712,28 @@ export class SettingsManager {
                 await this.saveSetting(settingKey, value);
             }
 
-            showToast('toast.settings.settingsUpdated', { setting: settingKey.replace(/_/g, ' ') }, 'success');
+            if (shouldShowLoading) {
+                state.loadingManager?.hide();
+            }
+
+            if (settingKey === 'recipes_path') {
+                showToast('toast.settings.recipesPathUpdated', {}, 'success');
+            } else if (settingKey === 'backup_retention_count') {
+                await this.updateBackupStatus();
+                showToast('toast.settings.settingsUpdated', { setting: settingKey.replace(/_/g, ' ') }, 'success');
+            } else {
+                showToast('toast.settings.settingsUpdated', { setting: settingKey.replace(/_/g, ' ') }, 'success');
+            }
 
         } catch (error) {
-            showToast('toast.settings.settingSaveFailed', { message: error.message }, 'error');
+            if (shouldShowLoading) {
+                state.loadingManager?.hide();
+            }
+            if (settingKey === 'recipes_path') {
+                showToast('toast.settings.recipesPathSaveFailed', { message: error.message }, 'error');
+            } else {
+                showToast('toast.settings.settingSaveFailed', { message: error.message }, 'error');
+            }
         }
     }
 

static/js/state/index.js

@@ -18,6 +18,7 @@ const DEFAULT_SETTINGS_BASE = Object.freeze({
     default_lora_root: '',
     default_checkpoint_root: '',
     default_embedding_root: '',
+    recipes_path: '',
     base_model_path_mappings: {},
     download_path_templates: {},
     example_images_path: '',
@@ -38,7 +39,10 @@ const DEFAULT_SETTINGS_BASE = Object.freeze({
     hide_early_access_updates: false,
     auto_organize_exclusions: [],
     metadata_refresh_skip_paths: [],
+    skip_previously_downloaded_model_versions: false,
     download_skip_base_models: [],
+    backup_auto_enabled: true,
+    backup_retention_count: 5,
 });
 
 export function createDefaultSettings() {

static/js/utils/civitaiUtils.js

@@ -30,8 +30,9 @@ export function rewriteCivitaiUrl(sourceUrl, mediaType = null, mode = Optimizati
     try {
         const url = new URL(sourceUrl);
         
-        // Check if it's a CivitAI image domain
-        if (url.hostname.toLowerCase() !== 'image.civitai.com') {
+        // Check if it's a CivitAI CDN domain (supports all subdomains like image-b2.civitai.com)
+        const hostname = url.hostname.toLowerCase();
+        if (hostname === 'civitai.com' || !hostname.endsWith('.civitai.com')) {
             return [sourceUrl, false];
         }
 
@@ -112,7 +113,8 @@ export function isCivitaiUrl(url) {
     if (!url) return false;
     try {
         const parsed = new URL(url);
-        return parsed.hostname.toLowerCase() === 'image.civitai.com';
+        const hostname = parsed.hostname.toLowerCase();
+        return hostname.endsWith('.civitai.com') && hostname !== 'civitai.com';
     } catch (e) {
         return false;
     }

templates/components/modals/settings_modal.html

@@ -90,7 +90,7 @@
                                 </div>
                             </div>
                         </div>
-                        
+                       
                         <!-- API Configuration -->
                         <div class="setting-item api-key-item">
                             <div class="setting-row">
@@ -113,6 +113,96 @@
                                 </div>
                             </div>
                         </div>
+
+                        <!-- Backup -->
+                        <div class="settings-subsection">
+                            <div class="settings-subsection-header">
+                                <h4>{{ t('settings.sections.backup') }}</h4>
+                            </div>
+                            <div class="settings-help-text subtle">
+                                {{ t('settings.backup.scopeHelp') }}
+                            </div>
+                            <div class="setting-item">
+                                <div class="setting-row">
+                                    <div class="setting-info">
+                                        <label for="backupAutoEnabled">
+                                            {{ t('settings.backup.autoEnabled') }}
+                                            <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.backup.autoEnabledHelp') }}"></i>
+                                        </label>
+                                    </div>
+                                    <div class="setting-control">
+                                        <label class="toggle-switch">
+                                            <input type="checkbox" id="backupAutoEnabled"
+                                                   onchange="settingsManager.saveToggleSetting('backupAutoEnabled', 'backup_auto_enabled')">
+                                            <span class="toggle-slider"></span>
+                                        </label>
+                                    </div>
+                                </div>
+                            </div>
+                            <div class="setting-item">
+                                <div class="setting-row">
+                                    <div class="setting-info">
+                                        <label for="backupRetentionCount">
+                                            {{ t('settings.backup.retention') }}
+                                            <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.backup.retentionHelp') }}"></i>
+                                        </label>
+                                    </div>
+                                    <div class="setting-control">
+                                        <div class="text-input-wrapper">
+                                            <input
+                                                type="number"
+                                                id="backupRetentionCount"
+                                                min="1"
+                                                step="1"
+                                                onblur="settingsManager.saveInputSetting('backupRetentionCount', 'backup_retention_count')"
+                                                onkeydown="if(event.key === 'Enter') { this.blur(); }"
+                                            />
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                            <div class="setting-item">
+                                <div class="setting-row">
+                                    <div class="setting-info">
+                                        <label>
+                                            {{ t('settings.backup.management') }}
+                                            <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.backup.managementHelp') }}"></i>
+                                        </label>
+                                    </div>
+                                    <div class="setting-control">
+                                        <button type="button" class="secondary-btn" onclick="settingsManager.exportBackup()">
+                                            {{ t('settings.backup.exportButton') }}
+                                        </button>
+                                        <button type="button" class="secondary-btn" onclick="settingsManager.triggerBackupImport()" style="margin-left: 10px;">
+                                            {{ t('settings.backup.importButton') }}
+                                        </button>
+                                        <input
+                                            type="file"
+                                            id="backupImportInput"
+                                            accept=".zip,application/zip"
+                                            style="display: none;"
+                                            onchange="settingsManager.handleBackupImportFile(this)"
+                                        />
+                                    </div>
+                                </div>
+                            </div>
+                            <div class="setting-item">
+                                <details class="backup-location-details">
+                                    <summary>{{ t('settings.backup.locationSummary') }}</summary>
+                                    <div class="backup-location-panel">
+                                        <code id="backupLocationPath" class="backup-location-path"></code>
+                                        <button type="button" class="secondary-btn" id="backupOpenLocationBtn">
+                                            {{ t('settings.backup.openFolderButton') }}
+                                        </button>
+                                    </div>
+                                </details>
+                            </div>
+                            <div class="setting-item">
+                                <div class="backup-status" id="backupStatus">
+                                    <!-- Status will be populated by JavaScript -->
+                                </div>
+                            </div>
+                        </div>
                         
                         <!-- Proxy Settings -->
                         <div class="settings-subsection">
@@ -450,6 +540,7 @@
                                 </div>
                             </div>
                         </div>
+
                     </div>
                     
                     <!-- Section 3: Library -->
@@ -530,6 +621,32 @@
                                     </div>
                                 </div>
                             </div>
+
+                        </div>
+
+                        <!-- Recipe Settings -->
+                        <div class="settings-subsection">
+                            <div class="settings-subsection-header">
+                                <h4>{{ t('settings.sections.recipeSettings') }}</h4>
+                            </div>
+                            <div class="setting-item">
+                                <div class="setting-row">
+                                    <div class="setting-info">
+                                        <label for="recipesPath">
+                                        {{ t('settings.folderSettings.recipesPath') }}
+                                        <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.folderSettings.recipesPathHelp') }}"></i>
+                                    </label>
+                                    </div>
+                                    <div class="setting-control">
+                                        <div class="text-input-wrapper">
+                                            <input type="text" id="recipesPath"
+                                                   placeholder="{{ t('settings.folderSettings.recipesPathPlaceholder') }}"
+                                                   onblur="settingsManager.saveInputSetting('recipesPath', 'recipes_path')"
+                                                   onkeydown="if(event.key === 'Enter') { this.blur(); }" />
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
                         </div>
 
                         <!-- Extra Folder Paths -->
@@ -735,6 +852,24 @@
                                 </div>
                             </div>
 
+                            <div class="setting-item">
+                                <div class="setting-row">
+                                    <div class="setting-info">
+                                        <label for="skipPreviouslyDownloadedModelVersions">
+                                            {{ t('settings.skipPreviouslyDownloadedModelVersions.label') }}
+                                            <i class="fas fa-info-circle info-icon" data-tooltip="{{ t('settings.skipPreviouslyDownloadedModelVersions.help') }}"></i>
+                                        </label>
+                                    </div>
+                                    <div class="setting-control">
+                                        <label class="toggle-switch">
+                                            <input type="checkbox" id="skipPreviouslyDownloadedModelVersions"
+                                                   onchange="settingsManager.saveToggleSetting('skipPreviouslyDownloadedModelVersions', 'skip_previously_downloaded_model_versions')">
+                                            <span class="toggle-slider"></span>
+                                        </label>
+                                    </div>
+                                </div>
+                            </div>
+
                             <div class="setting-item">
                                 <div class="setting-row">
                                     <div class="setting-info">

tests/frontend/components/autocomplete.behavior.test.js

@@ -69,6 +69,9 @@ describe('AutoComplete widget interactions', () => {
       if (key === 'loramanager.autocomplete_append_comma') {
         return true;
       }
+      if (key === 'loramanager.autocomplete_auto_format') {
+        return true;
+      }
       if (key === 'loramanager.autocomplete_accept_key') {
         return 'both';
       }
@@ -188,6 +191,59 @@ describe('AutoComplete widget interactions', () => {
     expect(insertSelectionSpy).toHaveBeenCalledWith('example_completion');
   });
 
+  it('formats duplicate commas and extra spaces when the textarea loses focus', async () => {
+    const input = document.createElement('textarea');
+    input.value = 'foo   bar, , baz  ,,   qux';
+    document.body.append(input);
+
+    const inputListener = vi.fn();
+    input.addEventListener('input', inputListener);
+
+    const { AutoComplete } = await import(AUTOCOMPLETE_MODULE);
+    new AutoComplete(input,'prompt', { showPreview: false });
+
+    input.dispatchEvent(new Event('blur', { bubbles: true }));
+
+    expect(input.value).toBe('foo bar, baz, qux');
+    expect(inputListener).toHaveBeenCalledTimes(1);
+  });
+
+  it('skips blur formatting when autocomplete auto format is disabled', async () => {
+    settingGetMock.mockImplementation((key) => {
+      if (key === 'loramanager.autocomplete_append_comma') {
+        return true;
+      }
+      if (key === 'loramanager.autocomplete_auto_format') {
+        return false;
+      }
+      if (key === 'loramanager.autocomplete_accept_key') {
+        return 'both';
+      }
+      if (key === 'loramanager.prompt_tag_autocomplete') {
+        return true;
+      }
+      if (key === 'loramanager.tag_space_replacement') {
+        return false;
+      }
+      return undefined;
+    });
+
+    const input = document.createElement('textarea');
+    input.value = 'foo   bar, , baz  ,,   qux';
+    document.body.append(input);
+
+    const inputListener = vi.fn();
+    input.addEventListener('input', inputListener);
+
+    const { AutoComplete } = await import(AUTOCOMPLETE_MODULE);
+    new AutoComplete(input,'prompt', { showPreview: false });
+
+    input.dispatchEvent(new Event('blur', { bubbles: true }));
+
+    expect(input.value).toBe('foo   bar, , baz  ,,   qux');
+    expect(inputListener).not.toHaveBeenCalled();
+  });
+
   it('accepts the selected suggestion with Enter', async () => {
     caretHelperInstance.getBeforeCursor.mockReturnValue('example');
 
@@ -275,6 +331,9 @@ describe('AutoComplete widget interactions', () => {
       if (key === 'loramanager.autocomplete_append_comma') {
         return true;
       }
+      if (key === 'loramanager.autocomplete_auto_format') {
+        return true;
+      }
       if (key === 'loramanager.autocomplete_accept_key') {
         return 'tab_only';
       }
@@ -322,6 +381,9 @@ describe('AutoComplete widget interactions', () => {
       if (key === 'loramanager.autocomplete_append_comma') {
         return true;
       }
+      if (key === 'loramanager.autocomplete_auto_format') {
+        return true;
+      }
       if (key === 'loramanager.autocomplete_accept_key') {
         return 'enter_only';
       }

tests/frontend/managers/settingsManager.downloadSkipBaseModels.test.js

@@ -20,6 +20,7 @@ vi.mock('../../../static/js/state/index.js', () => {
         },
         createDefaultSettings: () => ({
             language: 'en',
+            skip_previously_downloaded_model_versions: false,
             download_skip_base_models: [],
         }),
     };
@@ -117,6 +118,7 @@ describe('SettingsManager download skip base models UI', () => {
         document.body.innerHTML = '';
         vi.clearAllMocks();
         state.global.settings = {
+            skip_previously_downloaded_model_versions: false,
             download_skip_base_models: [],
         };
     });
@@ -150,4 +152,31 @@ describe('SettingsManager download skip base models UI', () => {
         expect(document.querySelectorAll('#downloadSkipBaseModelsContainer input')).toHaveLength(0);
         expect(document.getElementById('downloadSkipBaseModelsEmpty').hidden).toBe(false);
     });
+
+    it('initializes the previously-downloaded-version toggle from settings', () => {
+        document.body.innerHTML = '<input id="skipPreviouslyDownloadedModelVersions" type="checkbox" />';
+        state.global.settings.skip_previously_downloaded_model_versions = true;
+        const manager = createManager();
+
+        manager.loadSettingsToUI();
+
+        expect(document.getElementById('skipPreviouslyDownloadedModelVersions').checked).toBe(true);
+    });
+
+    it('saves the previously-downloaded-version toggle with the expected setting key', async () => {
+        document.body.innerHTML = '<input id="skipPreviouslyDownloadedModelVersions" type="checkbox" checked />';
+        const manager = createManager();
+        manager.saveSetting = vi.fn().mockResolvedValue();
+        manager.applyFrontendSettings = vi.fn();
+
+        await manager.saveToggleSetting(
+            'skipPreviouslyDownloadedModelVersions',
+            'skip_previously_downloaded_model_versions',
+        );
+
+        expect(manager.saveSetting).toHaveBeenCalledWith(
+            'skip_previously_downloaded_model_versions',
+            true,
+        );
+    });
 });

tests/frontend/managers/settingsManager.library.test.js

@@ -205,4 +205,58 @@ describe('SettingsManager library controls', () => {
         expect(select.value).toBe('alpha');
         expect(activateSpy).not.toHaveBeenCalled();
     });
+
+    it('loads recipes_path into the settings input', async () => {
+        const manager = createManager();
+        const input = document.createElement('input');
+        input.id = 'recipesPath';
+        document.body.appendChild(input);
+
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({
+                success: true,
+                isAvailable: false,
+                isEnabled: false,
+                databaseSize: 0,
+            }),
+        });
+
+        state.global.settings = {
+            recipes_path: '/custom/recipes',
+        };
+
+        await manager.loadSettingsToUI();
+
+        expect(input.value).toBe('/custom/recipes');
+    });
+
+    it('shows loading while saving recipes_path', async () => {
+        const manager = createManager();
+        const input = document.createElement('input');
+        input.id = 'recipesPath';
+        input.value = '/custom/recipes';
+        document.body.appendChild(input);
+
+        state.global.settings = {
+            recipes_path: '',
+        };
+
+        global.fetch = vi.fn().mockResolvedValue({
+            ok: true,
+            json: async () => ({ success: true }),
+        });
+
+        await manager.saveInputSetting('recipesPath', 'recipes_path');
+
+        expect(state.loadingManager.showSimpleLoading).toHaveBeenCalledWith(
+            'Migrating recipes...'
+        );
+        expect(state.loadingManager.hide).toHaveBeenCalledTimes(1);
+        expect(showToast).toHaveBeenCalledWith(
+            'toast.settings.recipesPathUpdated',
+            {},
+            'success',
+        );
+    });
 });

tests/frontend/utils/civitaiUtils.test.js

@@ -94,6 +94,37 @@ describe('civitaiUtils', () => {
             expect(wasRewritten).toBe(false);
             expect(rewritten).toBe('not-a-valid-url');
         });
+
+        it('should rewrite URLs from CivitAI CDN subdomains', () => {
+            const originalUrl = 'https://image-b2.civitai.com/file/civitai-media-cache/original=true/sample.png';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image', OptimizationMode.THUMBNAIL);
+
+            expect(wasRewritten).toBe(true);
+            expect(rewritten).toBe('https://image-b2.civitai.com/file/civitai-media-cache/width=450,optimized=true/sample.png');
+        });
+
+        it('should handle URLs with explicit port numbers', () => {
+            const originalUrl = 'https://image.civitai.com:443/checkpoints/original=true/test.png';
+            const [rewritten, wasRewritten] = rewriteCivitaiUrl(originalUrl, 'image', OptimizationMode.THUMBNAIL);
+
+            expect(wasRewritten).toBe(true);
+            // JavaScript URL.toString() removes default HTTPS port (443)
+            expect(rewritten).toBe('https://image.civitai.com/checkpoints/width=450,optimized=true/test.png');
+        });
+
+        it('should handle case-insensitive hostnames', () => {
+            const testCases = [
+                'https://IMAGE.CIVITAI.COM/original=true/test.png',
+                'https://Image.Civitai.Com/original=true/test.png',
+                'https://image-b2.CIVITAI.com/original=true/test.png',
+            ];
+
+            for (const url of testCases) {
+                const [rewritten, wasRewritten] = rewriteCivitaiUrl(url, 'image', OptimizationMode.THUMBNAIL);
+                expect(wasRewritten).toBe(true);
+                expect(rewritten).toContain('width=450,optimized=true');
+            }
+        });
     });
 
     describe('getOptimizedUrl', () => {
@@ -157,6 +188,23 @@ describe('civitaiUtils', () => {
             expect(isCivitaiUrl('https://image.civitai.com/')).toBe(true);
         });
 
+        it('should return true for CivitAI CDN subdomains', () => {
+            expect(isCivitaiUrl('https://image-b2.civitai.com/file/test.png')).toBe(true);
+            expect(isCivitaiUrl('https://image-b3.civitai.com/test.jpg')).toBe(true);
+            expect(isCivitaiUrl('https://cdn.civitai.com/test.png')).toBe(true);
+        });
+
+        it('should return true for CivitAI URLs with explicit ports', () => {
+            expect(isCivitaiUrl('https://image.civitai.com:443/test.png')).toBe(true);
+            expect(isCivitaiUrl('https://image-b2.civitai.com:443/file/test.jpg')).toBe(true);
+        });
+
+        it('should handle case-insensitive hostnames', () => {
+            expect(isCivitaiUrl('https://IMAGE.CIVITAI.COM/test.png')).toBe(true);
+            expect(isCivitaiUrl('https://Image.Civitai.Com/test.png')).toBe(true);
+            expect(isCivitaiUrl('https://image-b2.CIVITAI.com/test.png')).toBe(true);
+        });
+
         it('should return false for non-CivitAI URLs', () => {
             expect(isCivitaiUrl('https://example.com/image.jpg')).toBe(false);
             expect(isCivitaiUrl('https://civitai.com/image.jpg')).toBe(false);

tests/frontend/utils/loraChainTraversal.test.js

@@ -0,0 +1,151 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { APP_MODULE, UTILS_MODULE } = vi.hoisted(() => ({
+  APP_MODULE: new URL("../../../scripts/app.js", import.meta.url).pathname,
+  UTILS_MODULE: new URL("../../../web/comfyui/utils.js", import.meta.url).pathname,
+}));
+
+vi.mock(APP_MODULE, () => ({
+  app: {
+    graph: null,
+    registerExtension: vi.fn(),
+    ui: {
+      settings: {
+        getSettingValue: vi.fn(),
+      },
+    },
+  },
+}));
+
+describe("LoRA chain traversal", () => {
+  let collectActiveLorasFromChain;
+
+  beforeEach(async () => {
+    vi.resetModules();
+    ({ collectActiveLorasFromChain } = await import(UTILS_MODULE));
+  });
+
+  function createGraph(nodes, links) {
+    const graph = {
+      _nodes: nodes,
+      links,
+      getNodeById(id) {
+        return nodes.find((node) => node.id === id) ?? null;
+      },
+    };
+
+    nodes.forEach((node) => {
+      node.graph = graph;
+    });
+
+    return graph;
+  }
+
+  it("aggregates active LoRAs through a combiner with multiple LORA_STACK inputs", () => {
+    const randomizerA = {
+      id: 1,
+      comfyClass: "Lora Randomizer (LoraManager)",
+      mode: 0,
+      widgets: [
+        {
+          name: "loras",
+          value: [
+            { name: "Alpha", active: true },
+            { name: "Ignored", active: false },
+          ],
+        },
+      ],
+      inputs: [],
+      outputs: [],
+    };
+    const randomizerB = {
+      id: 2,
+      comfyClass: "Lora Randomizer (LoraManager)",
+      mode: 0,
+      widgets: [
+        {
+          name: "loras",
+          value: [{ name: "Beta", active: true }],
+        },
+      ],
+      inputs: [],
+      outputs: [],
+    };
+    const combiner = {
+      id: 3,
+      comfyClass: "Lora Stack Combiner (LoraManager)",
+      mode: 0,
+      widgets: [],
+      inputs: [
+        { name: "lora_stack_a", type: "LORA_STACK", link: 11 },
+        { name: "lora_stack_b", type: "LORA_STACK", link: 12 },
+      ],
+      outputs: [],
+    };
+    const loader = {
+      id: 4,
+      comfyClass: "Lora Loader (LoraManager)",
+      mode: 0,
+      widgets: [],
+      inputs: [{ name: "lora_stack", type: "LORA_STACK", link: 13 }],
+      outputs: [],
+    };
+
+    createGraph(
+      [randomizerA, randomizerB, combiner, loader],
+      {
+        11: { origin_id: 1, target_id: 3 },
+        12: { origin_id: 2, target_id: 3 },
+        13: { origin_id: 3, target_id: 4 },
+      }
+    );
+
+    const result = collectActiveLorasFromChain(loader);
+
+    expect([...result]).toEqual(["Alpha", "Beta"]);
+  });
+
+  it("stops propagation when the combiner is inactive", () => {
+    const randomizer = {
+      id: 1,
+      comfyClass: "Lora Randomizer (LoraManager)",
+      mode: 0,
+      widgets: [
+        {
+          name: "loras",
+          value: [{ name: "Alpha", active: true }],
+        },
+      ],
+      inputs: [],
+      outputs: [],
+    };
+    const combiner = {
+      id: 2,
+      comfyClass: "Lora Stack Combiner (LoraManager)",
+      mode: 2,
+      widgets: [],
+      inputs: [{ name: "lora_stack_a", type: "LORA_STACK", link: 21 }],
+      outputs: [],
+    };
+    const loader = {
+      id: 3,
+      comfyClass: "Lora Loader (LoraManager)",
+      mode: 0,
+      widgets: [],
+      inputs: [{ name: "lora_stack", type: "LORA_STACK", link: 22 }],
+      outputs: [],
+    };
+
+    createGraph(
+      [randomizer, combiner, loader],
+      {
+        21: { origin_id: 1, target_id: 2 },
+        22: { origin_id: 2, target_id: 3 },
+      }
+    );
+
+    const result = collectActiveLorasFromChain(loader);
+
+    expect(result.size).toBe(0);
+  });
+});

tests/metadata_collector/test_metadata_collector.py

@@ -98,6 +98,199 @@ def test_metadata_processor_extracts_generation_params(populated_registry, monke
             assert isinstance(value, str)
 
 
+def test_attention_bias_clip_text_encode_prompts_are_collected(metadata_registry, monkeypatch):
+    import types
+
+    prompt_graph = {
+        "encode_pos": {
+            "class_type": "CLIPTextEncodeAttentionBias",
+            "inputs": {"text": "A <big dog=1.25> on a hill", "clip": ["clip", 0]},
+        },
+        "encode_neg": {
+            "class_type": "CLIPTextEncodeAttentionBias",
+            "inputs": {"text": "low quality", "clip": ["clip", 0]},
+        },
+        "sampler": {
+            "class_type": "KSampler",
+            "inputs": {
+                "seed": types.SimpleNamespace(seed=123),
+                "steps": 20,
+                "cfg": 7.0,
+                "sampler_name": "Euler",
+                "scheduler": "karras",
+                "denoise": 1.0,
+                "positive": ["encode_pos", 0],
+                "negative": ["encode_neg", 0],
+                "latent_image": {"samples": types.SimpleNamespace(shape=(1, 4, 16, 16))},
+            },
+        },
+    }
+    prompt = SimpleNamespace(original_prompt=prompt_graph)
+
+    pos_conditioning = object()
+    neg_conditioning = object()
+
+    monkeypatch.setattr(metadata_processor, "standalone_mode", False)
+
+    metadata_registry.start_collection("prompt-attention")
+    metadata_registry.set_current_prompt(prompt)
+
+    metadata_registry.record_node_execution(
+        "encode_pos",
+        "CLIPTextEncodeAttentionBias",
+        {"text": "A <big dog=1.25> on a hill"},
+        None,
+    )
+    metadata_registry.update_node_execution(
+        "encode_pos", "CLIPTextEncodeAttentionBias", [(pos_conditioning,)]
+    )
+    metadata_registry.record_node_execution(
+        "encode_neg",
+        "CLIPTextEncodeAttentionBias",
+        {"text": "low quality"},
+        None,
+    )
+    metadata_registry.update_node_execution(
+        "encode_neg", "CLIPTextEncodeAttentionBias", [(neg_conditioning,)]
+    )
+    metadata_registry.record_node_execution(
+        "sampler",
+        "KSampler",
+        {
+            "seed": types.SimpleNamespace(seed=123),
+            "positive": pos_conditioning,
+            "negative": neg_conditioning,
+            "latent_image": {"samples": types.SimpleNamespace(shape=(1, 4, 16, 16))},
+        },
+        None,
+    )
+
+    metadata = metadata_registry.get_metadata("prompt-attention")
+    sampler_data = metadata[SAMPLING]["sampler"]
+    prompt_results = MetadataProcessor.match_conditioning_to_prompts(metadata, "sampler")
+
+    assert metadata[PROMPTS]["encode_pos"]["text"] == "A <big dog=1.25> on a hill"
+    assert metadata[PROMPTS]["encode_neg"]["text"] == "low quality"
+    assert sampler_data["node_id"] == "sampler"
+    assert sampler_data["is_sampler"] is True
+    assert prompt_results["prompt"] == "A <big dog=1.25> on a hill"
+    assert prompt_results["negative_prompt"] == "low quality"
+
+
+def test_sampler_custom_advanced_recovers_prompt_text_through_guidance_nodes(metadata_registry, monkeypatch):
+    import types
+
+    prompt_graph = {
+        "encode_pos": {
+            "class_type": "CLIPTextEncodeAttentionBias",
+            "inputs": {
+                "text": "A low-angle, medium close-up portrait of her.",
+                "clip": ["clip", 0],
+            },
+        },
+        "encode_neg": {
+            "class_type": "CLIPTextEncodeAttentionBias",
+            "inputs": {
+                "text": " This low quality greyscale unfinished sketch is inaccurate and flawed. The image is very blurred and lacks detail with excessive chromatic aberrations and artifacts. The image is overly saturated with excessive bloom. It has a toony aesthetic with bold outlines and flat colors. ",
+                "clip": ["clip", 0],
+            },
+        },
+        "scheduled_cfg_guidance": {
+            "class_type": "ScheduledCFGGuidance",
+            "inputs": {
+                "model": ["model", 0],
+                "positive": ["encode_pos", 0],
+                "negative": ["encode_neg", 0],
+                "cfg": 2.6,
+                "start_percent": 0.0,
+                "end_percent": 0.62,
+            },
+        },
+        "sampler": {
+            "class_type": "SamplerCustomAdvanced",
+            "inputs": {
+                "noise": types.SimpleNamespace(seed=174),
+                "guider": ["scheduled_cfg_guidance", 0],
+                "sampler": ["sampler_select", 0],
+                "sigmas": ["scheduler", 0],
+                "latent_image": {"samples": types.SimpleNamespace(shape=(1, 4, 128, 128))},
+            },
+        },
+        "sampler_select": {
+            "class_type": "KSamplerSelect",
+            "inputs": {"sampler_name": "multistep/deis_2m"},
+        },
+        "scheduler": {
+            "class_type": "BasicScheduler",
+            "inputs": {"steps": 20, "scheduler": "power_shift", "denoise": 1.0},
+        },
+    }
+    prompt = SimpleNamespace(original_prompt=prompt_graph)
+
+    pos_conditioning = object()
+    neg_conditioning = object()
+
+    monkeypatch.setattr(metadata_processor, "standalone_mode", False)
+
+    metadata_registry.start_collection("prompt-guidance")
+    metadata_registry.set_current_prompt(prompt)
+
+    metadata_registry.record_node_execution(
+        "encode_pos",
+        "CLIPTextEncodeAttentionBias",
+        {"text": "A low-angle, medium close-up portrait of her."},
+        None,
+    )
+    metadata_registry.update_node_execution(
+        "encode_pos", "CLIPTextEncodeAttentionBias", [(pos_conditioning,)]
+    )
+    metadata_registry.record_node_execution(
+        "encode_neg",
+        "CLIPTextEncodeAttentionBias",
+        {
+            "text": " This low quality greyscale unfinished sketch is inaccurate and flawed. The image is very blurred and lacks detail with excessive chromatic aberrations and artifacts. The image is overly saturated with excessive bloom. It has a toony aesthetic with bold outlines and flat colors. ",
+        },
+        None,
+    )
+    metadata_registry.update_node_execution(
+        "encode_neg", "CLIPTextEncodeAttentionBias", [(neg_conditioning,)]
+    )
+    metadata_registry.record_node_execution(
+        "scheduled_cfg_guidance",
+        "ScheduledCFGGuidance",
+        {
+            "positive": pos_conditioning,
+            "negative": neg_conditioning,
+            "cfg": 2.6,
+        },
+        None,
+    )
+    metadata_registry.record_node_execution(
+        "sampler",
+        "SamplerCustomAdvanced",
+        {
+            "noise": types.SimpleNamespace(seed=174),
+            "guider": {
+                "positive": pos_conditioning,
+                "negative": neg_conditioning,
+            },
+            "sampler": ["sampler_select", 0],
+            "sigmas": ["scheduler", 0],
+            "latent_image": {"samples": types.SimpleNamespace(shape=(1, 4, 128, 128))},
+        },
+        None,
+    )
+
+    metadata = metadata_registry.get_metadata("prompt-guidance")
+    params = MetadataProcessor.extract_generation_params(metadata)
+
+    assert params["prompt"] == "A low-angle, medium close-up portrait of her."
+    assert (
+        params["negative_prompt"]
+        == " This low quality greyscale unfinished sketch is inaccurate and flawed. The image is very blurred and lacks detail with excessive chromatic aberrations and artifacts. The image is overly saturated with excessive bloom. It has a toony aesthetic with bold outlines and flat colors. "
+    )
+
+
 def test_metadata_registry_caches_and_rehydrates(populated_registry):
     registry = populated_registry["registry"]
     prompt = populated_registry["prompt"]

tests/middleware/test_csp_middleware.py

@@ -2,7 +2,10 @@ import pytest
 from aiohttp import web
 from aiohttp.test_utils import make_mocked_request
 
-from py.middleware.csp_middleware import REMOTE_MEDIA_SOURCES, relax_csp_for_remote_media
+from py.middleware.csp_middleware import (
+    REMOTE_MEDIA_SOURCES,
+    relax_csp_for_remote_media,
+)
 
 DEFAULT_CSP = (
     "default-src 'self'; "
@@ -40,7 +43,9 @@ async def _invoke_middleware(
 
 
 @pytest.mark.asyncio
-async def test_relax_csp_appends_remote_sources_and_preserves_existing_directives() -> None:
+async def test_relax_csp_appends_remote_sources_and_preserves_existing_directives() -> (
+    None
+):
     response = await _invoke_middleware("/some-path", web.Response())
     header_value = response.headers.get("Content-Security-Policy")
     assert header_value is not None
@@ -48,16 +53,17 @@ async def test_relax_csp_appends_remote_sources_and_preserves_existing_directive
     directives = _parse_directives(header_value)
 
     # Existing directives remain intact
-    assert directives["script-src"] == ["'self'", "'unsafe-inline'", "'unsafe-eval'", "blob:"]
+    assert directives["script-src"] == [
+        "'self'",
+        "'unsafe-inline'",
+        "'unsafe-eval'",
+        "blob:",
+    ]
     assert directives["img-src"][:3] == ["'self'", "data:", "blob:"]
 
     # Remote media hosts are added once to the relevant directives
     for source in REMOTE_MEDIA_SOURCES:
         assert source in directives["img-src"]
-
-    assert "media-src" in directives
-    assert directives["media-src"][0] == "'self'"
-    for source in REMOTE_MEDIA_SOURCES:
         assert source in directives["media-src"]
 
 

tests/routes/__snapshots__/test_api_snapshots.ambr

@@ -1,6 +1,8 @@
 # serializer version: 1
 # name: TestModelLibraryHandlerSnapshots.test_check_model_exists_empty_response
   dict({
+    'downloadedVersionIds': list([
+    ]),
     'modelType': None,
     'success': True,
     'versions': list([

tests/routes/test_api_snapshots.py

@@ -66,6 +66,27 @@ class FakePromptServer:
     instance = Instance()
 
 
+class FakeDownloadHistoryService:
+    async def has_been_downloaded(self, _model_type, _version_id):
+        return False
+
+    async def get_downloaded_version_ids(self, _model_type, _model_id):
+        return []
+
+    async def get_downloaded_version_ids_bulk(self, _model_type, _model_ids):
+        return {}
+
+    async def mark_downloaded(self, *_args, **_kwargs):
+        return None
+
+    async def mark_not_downloaded(self, *_args, **_kwargs):
+        return None
+
+
+async def fake_download_history_service_factory():
+    return FakeDownloadHistoryService()
+
+
 class TestSettingsHandlerSnapshots:
     """Snapshot tests for SettingsHandler responses."""
 
@@ -223,6 +244,7 @@ class TestModelLibraryHandlerSnapshots:
                 get_lora_scanner=scanner_factory,
                 get_checkpoint_scanner=scanner_factory,
                 get_embedding_scanner=scanner_factory,
+                get_downloaded_version_history_service=fake_download_history_service_factory,
             ),
             metadata_provider_factory=lambda: None,
         )

tests/routes/test_misc_routes.py

@@ -8,6 +8,8 @@ import pytest
 from aiohttp import web
 
 from py.routes.handlers.misc_handlers import (
+    BackupHandler,
+    FileSystemHandler,
     LoraCodeHandler,
     ModelLibraryHandler,
     NodeRegistry,
@@ -23,9 +25,10 @@ from py.routes.misc_routes import MiscRoutes
 
 
 class FakeRequest:
-    def __init__(self, *, json_data=None, query=None):
+    def __init__(self, *, json_data=None, query=None, method="POST"):
         self._json_data = json_data or {}
         self.query = query or {}
+        self.method = method
 
     async def json(self):
         return self._json_data
@@ -110,6 +113,106 @@ async def test_update_settings_rejects_missing_example_path(tmp_path):
     assert "Path does not exist" in payload["error"]
 
 
+class DummyBackupService:
+    def __init__(self):
+        self.restore_calls = []
+
+    async def create_snapshot(self, *, snapshot_type="manual", persist=False):
+        return {
+            "archive_name": "backup.zip",
+            "archive_bytes": b"zip-bytes",
+            "manifest": {"snapshot_type": snapshot_type},
+        }
+
+    async def restore_snapshot(self, archive_path):
+        self.restore_calls.append(archive_path)
+        return {"success": True, "restored_files": 3, "snapshot_type": "manual"}
+
+    def get_status(self):
+        return {
+            "backupDir": "/tmp/backups",
+            "enabled": True,
+            "retentionCount": 5,
+            "snapshotCount": 1,
+        }
+
+    def get_available_snapshots(self):
+        return [{"name": "backup.zip", "path": "/tmp/backup.zip", "size": 8, "mtime": 1.0, "is_auto": False}]
+
+
+@pytest.mark.asyncio
+async def test_backup_handler_returns_status_and_exports(monkeypatch):
+    service = DummyBackupService()
+
+    async def factory():
+        return service
+
+    handler = BackupHandler(backup_service_factory=factory)
+
+    status_response = await handler.get_backup_status(FakeRequest())
+    status_payload = json.loads(status_response.text)
+    assert status_payload["success"] is True
+    assert status_payload["status"]["backupDir"] == "/tmp/backups"
+    assert status_payload["status"]["enabled"] is True
+    assert status_payload["snapshots"][0]["name"] == "backup.zip"
+
+    export_response = await handler.export_backup(FakeRequest())
+    assert export_response.status == 200
+    assert export_response.body == b"zip-bytes"
+
+
+@pytest.mark.asyncio
+async def test_backup_handler_rejects_missing_import_archive():
+    service = DummyBackupService()
+
+    async def factory():
+        return service
+
+    handler = BackupHandler(backup_service_factory=factory)
+
+    class EmptyRequest:
+        content_type = "application/octet-stream"
+
+        async def read(self):
+            return b""
+
+    response = await handler.import_backup(EmptyRequest())
+    payload = json.loads(response.text)
+
+    assert response.status == 400
+    assert payload["success"] is False
+
+
+@pytest.mark.asyncio
+async def test_open_backup_location_uses_settings_directory(tmp_path, monkeypatch):
+    settings_dir = tmp_path / "settings"
+    settings_dir.mkdir(parents=True, exist_ok=True)
+    settings_file = settings_dir / "settings.json"
+    settings_file.write_text("{}", encoding="utf-8")
+    backup_dir = settings_dir / "backups"
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    handler = FileSystemHandler(settings_service=SimpleNamespace(settings_file=str(settings_file)))
+
+    calls = []
+
+    def fake_popen(args):
+        calls.append(args)
+        return MagicMock()
+
+    monkeypatch.setattr(subprocess, "Popen", fake_popen)
+    monkeypatch.setattr("py.routes.handlers.misc_handlers._is_docker", lambda: False)
+    monkeypatch.setattr("py.routes.handlers.misc_handlers._is_wsl", lambda: False)
+
+    response = await handler.open_backup_location(FakeRequest())
+    payload = json.loads(response.text)
+
+    assert response.status == 200
+    assert payload["success"] is True
+    assert payload["path"] == str(backup_dir)
+    assert calls == [["xdg-open", str(backup_dir)]]
+
+
 class RecordingRouter:
     def __init__(self):
         self.calls = []
@@ -438,6 +541,46 @@ async def fake_metadata_archive_manager_factory():
     return FakeMetadataArchiveManager()
 
 
+class FakeDownloadHistoryService:
+    def __init__(self, downloaded_by_type=None):
+        self.downloaded_by_type = downloaded_by_type or {}
+        self.marked_downloaded: list[tuple] = []
+        self.marked_not_downloaded: list[tuple] = []
+
+    async def has_been_downloaded(self, model_type, version_id):
+        return version_id in self.downloaded_by_type.get(model_type, set())
+
+    async def get_downloaded_version_ids(self, model_type, model_id):
+        entries = self.downloaded_by_type.get(model_type, {})
+        if isinstance(entries, dict):
+            return sorted(entries.get(model_id, set()))
+        return []
+
+    async def get_downloaded_version_ids_bulk(self, model_type, model_ids):
+        entries = self.downloaded_by_type.get(model_type, {})
+        if not isinstance(entries, dict):
+            return {}
+        return {
+            model_id: set(entries.get(model_id, set()))
+            for model_id in model_ids
+            if model_id in entries
+        }
+
+    async def mark_downloaded(
+        self, model_type, version_id, *, model_id=None, source="manual", file_path=None
+    ):
+        self.marked_downloaded.append(
+            (model_type, version_id, model_id, source, file_path)
+        )
+
+    async def mark_not_downloaded(self, model_type, version_id):
+        self.marked_not_downloaded.append((model_type, version_id))
+
+
+async def fake_download_history_service_factory():
+    return FakeDownloadHistoryService()
+
+
 class RecordingRegistrar:
     def __init__(self, _app):
         self.registered_mapping = None
@@ -452,6 +595,7 @@ async def test_misc_routes_bind_produces_expected_handlers():
         get_lora_scanner=fake_scanner_factory,
         get_checkpoint_scanner=fake_scanner_factory,
         get_embedding_scanner=fake_scanner_factory,
+        get_downloaded_version_history_service=fake_download_history_service_factory,
     )
 
     recorded_registrars = []
@@ -578,6 +722,7 @@ async def test_get_civitai_user_models_marks_library_versions():
             get_lora_scanner=lora_factory,
             get_checkpoint_scanner=checkpoint_factory,
             get_embedding_scanner=embedding_factory,
+            get_downloaded_version_history_service=lambda: fake_download_history_service_factory(),
         ),
         metadata_provider_factory=provider_factory,
     )
@@ -600,6 +745,7 @@ async def test_get_civitai_user_models_marks_library_versions():
             "baseModel": "Flux.1",
             "thumbnailUrl": "http://example.com/a1.jpg",
             "inLibrary": False,
+            "hasBeenDownloaded": False,
         },
         {
             "modelId": 1,
@@ -611,6 +757,7 @@ async def test_get_civitai_user_models_marks_library_versions():
             "baseModel": "Flux.1",
             "thumbnailUrl": "http://example.com/a2.jpg",
             "inLibrary": True,
+            "hasBeenDownloaded": False,
         },
         {
             "modelId": 2,
@@ -622,6 +769,7 @@ async def test_get_civitai_user_models_marks_library_versions():
             "baseModel": None,
             "thumbnailUrl": "http://example.com/e1.jpg",
             "inLibrary": False,
+            "hasBeenDownloaded": False,
         },
         {
             "modelId": 2,
@@ -633,6 +781,7 @@ async def test_get_civitai_user_models_marks_library_versions():
             "baseModel": None,
             "thumbnailUrl": None,
             "inLibrary": True,
+            "hasBeenDownloaded": False,
         },
         {
             "modelId": 3,
@@ -644,6 +793,7 @@ async def test_get_civitai_user_models_marks_library_versions():
             "baseModel": "SDXL",
             "thumbnailUrl": None,
             "inLibrary": False,
+            "hasBeenDownloaded": False,
         },
     ]
 
@@ -692,6 +842,7 @@ async def test_get_civitai_user_models_rewrites_civitai_previews():
             get_lora_scanner=fake_scanner_factory,
             get_checkpoint_scanner=fake_scanner_factory,
             get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
         ),
         metadata_provider_factory=provider_factory,
     )
@@ -727,6 +878,7 @@ async def test_get_civitai_user_models_requires_username():
             get_lora_scanner=fake_scanner_factory,
             get_checkpoint_scanner=fake_scanner_factory,
             get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
         ),
         metadata_provider_factory=provider_factory,
     )
@@ -760,6 +912,7 @@ def test_ensure_handler_mapping_caches_result():
             get_lora_scanner=fake_scanner_factory,
             get_checkpoint_scanner=fake_scanner_factory,
             get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
         ),
         metadata_provider_factory=fake_metadata_provider_factory,
         metadata_archive_manager_factory=fake_metadata_archive_manager_factory,
@@ -802,6 +955,7 @@ async def test_check_model_exists_returns_local_versions():
             get_lora_scanner=lora_factory,
             get_checkpoint_scanner=checkpoint_factory,
             get_embedding_scanner=embedding_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
         ),
         metadata_provider_factory=fake_metadata_provider_factory,
     )
@@ -811,10 +965,139 @@ async def test_check_model_exists_returns_local_versions():
 
     assert payload["success"] is True
     assert payload["modelType"] == "lora"
-    assert payload["versions"] == versions
+    assert payload["versions"] == [
+        {"versionId": 11, "name": "v1", "fileName": "model-one", "hasBeenDownloaded": True},
+        {"versionId": 12, "name": "v2", "fileName": "model-two", "hasBeenDownloaded": True},
+    ]
     assert lora_scanner.version_calls == [5]
 
 
+@pytest.mark.asyncio
+async def test_check_model_exists_model_id_only_does_not_call_metadata_provider():
+    async def metadata_provider_factory():
+        raise AssertionError("metadata provider should not be called for modelId-only checks")
+
+    handler = ModelLibraryHandler(
+        ServiceRegistryAdapter(
+            get_lora_scanner=fake_scanner_factory,
+            get_checkpoint_scanner=fake_scanner_factory,
+            get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
+        ),
+        metadata_provider_factory=metadata_provider_factory,
+    )
+
+    response = await handler.check_model_exists(FakeRequest(query={"modelId": "5"}))
+    payload = json.loads(response.text)
+
+    assert payload == {
+        "success": True,
+        "modelType": None,
+        "versions": [],
+        "downloadedVersionIds": [],
+    }
+
+
+@pytest.mark.asyncio
+async def test_check_model_exists_returns_download_history_when_file_missing():
+    history_service = FakeDownloadHistoryService({"checkpoint": {999}})
+
+    async def history_factory():
+        return history_service
+
+    handler = ModelLibraryHandler(
+        ServiceRegistryAdapter(
+            get_lora_scanner=fake_scanner_factory,
+            get_checkpoint_scanner=fake_scanner_factory,
+            get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=history_factory,
+        ),
+        metadata_provider_factory=fake_metadata_provider_factory,
+    )
+
+    response = await handler.check_model_exists(
+        FakeRequest(query={"modelId": "5", "modelVersionId": "999"})
+    )
+    payload = json.loads(response.text)
+
+    assert payload == {
+        "success": True,
+        "exists": False,
+        "modelType": "checkpoint",
+        "hasBeenDownloaded": True,
+    }
+
+
+@pytest.mark.asyncio
+async def test_model_version_download_status_endpoints():
+    history_service = FakeDownloadHistoryService({"lora": {123}})
+
+    async def history_factory():
+        return history_service
+
+    handler = ModelLibraryHandler(
+        ServiceRegistryAdapter(
+            get_lora_scanner=fake_scanner_factory,
+            get_checkpoint_scanner=fake_scanner_factory,
+            get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=history_factory,
+        ),
+        metadata_provider_factory=fake_metadata_provider_factory,
+    )
+
+    get_response = await handler.get_model_version_download_status(
+        FakeRequest(query={"modelType": "lora", "modelVersionId": "123"})
+    )
+    get_payload = json.loads(get_response.text)
+    assert get_payload == {
+        "success": True,
+        "modelType": "lora",
+        "modelVersionId": 123,
+        "hasBeenDownloaded": True,
+    }
+
+    set_response = await handler.set_model_version_download_status(
+        FakeRequest(
+            json_data={
+                "modelType": "checkpoint",
+                "modelVersionId": 456,
+                "modelId": 78,
+                "downloaded": True,
+                "filePath": "/tmp/model.safetensors",
+            }
+        )
+    )
+    set_payload = json.loads(set_response.text)
+    assert set_payload == {
+        "success": True,
+        "modelType": "checkpoint",
+        "modelVersionId": 456,
+        "hasBeenDownloaded": True,
+    }
+    assert history_service.marked_downloaded == [
+        ("checkpoint", 456, 78, "manual", "/tmp/model.safetensors")
+    ]
+
+    set_get_response = await handler.set_model_version_download_status(
+        FakeRequest(
+            method="GET",
+            query={
+                "modelType": "embedding",
+                "modelVersionId": "789",
+                "modelId": "12",
+                "downloaded": "false",
+            },
+        )
+    )
+    set_get_payload = json.loads(set_get_response.text)
+    assert set_get_payload == {
+        "success": True,
+        "modelType": "embedding",
+        "modelVersionId": 789,
+        "hasBeenDownloaded": False,
+    }
+
+
 def test_create_handler_set_uses_provided_dependencies():
     recorded_handlers: list[dict] = []
 
@@ -845,6 +1128,7 @@ def test_create_handler_set_uses_provided_dependencies():
             get_lora_scanner=fake_scanner_factory,
             get_checkpoint_scanner=fake_scanner_factory,
             get_embedding_scanner=fake_scanner_factory,
+            get_downloaded_version_history_service=fake_download_history_service_factory,
         ),
         metadata_provider_factory=fake_metadata_provider_factory,
         metadata_archive_manager_factory=fake_metadata_archive_manager_factory,

tests/routes/test_preview_routes.py

@@ -113,6 +113,78 @@ async def test_config_updates_preview_roots_after_switch(tmp_path):
     assert decoded.replace("\\", "/").endswith("model.webp")
 
 
+async def test_preview_handler_allows_custom_recipes_path(tmp_path):
+    lora_root = tmp_path / "library"
+    lora_root.mkdir()
+    recipes_root = tmp_path / "recipes_storage"
+    recipes_root.mkdir()
+    preview_file = recipes_root / "recipe.webp"
+    preview_file.write_bytes(b"preview")
+
+    config = Config()
+    config.apply_library_settings(
+        {
+            "folder_paths": {
+                "loras": [str(lora_root)],
+                "checkpoints": [],
+                "unet": [],
+                "embeddings": [],
+            },
+            "recipes_path": str(recipes_root),
+        }
+    )
+
+    assert config.is_preview_path_allowed(str(preview_file))
+
+    handler = PreviewHandler(config=config)
+    encoded_path = urllib.parse.quote(str(preview_file), safe="")
+    request = make_mocked_request("GET", f"/api/lm/previews?path={encoded_path}")
+
+    response = await handler.serve_preview(request)
+
+    assert isinstance(response, web.FileResponse)
+    assert response.status == 200
+    assert Path(response._path) == preview_file
+
+
+async def test_preview_handler_allows_symlinked_recipes_path(tmp_path):
+    lora_root = tmp_path / "library"
+    lora_root.mkdir()
+    real_recipes_root = tmp_path / "real_recipes"
+    real_recipes_root.mkdir()
+    symlink_recipes_root = tmp_path / "linked_recipes"
+    symlink_recipes_root.symlink_to(real_recipes_root, target_is_directory=True)
+
+    preview_file = real_recipes_root / "recipe.webp"
+    preview_file.write_bytes(b"preview")
+
+    config = Config()
+    config.apply_library_settings(
+        {
+            "folder_paths": {
+                "loras": [str(lora_root)],
+                "checkpoints": [],
+                "unet": [],
+                "embeddings": [],
+            },
+            "recipes_path": str(symlink_recipes_root),
+        }
+    )
+
+    symlink_preview_path = symlink_recipes_root / "recipe.webp"
+    assert config.is_preview_path_allowed(str(symlink_preview_path))
+
+    handler = PreviewHandler(config=config)
+    encoded_path = urllib.parse.quote(str(symlink_preview_path), safe="")
+    request = make_mocked_request("GET", f"/api/lm/previews?path={encoded_path}")
+
+    response = await handler.serve_preview(request)
+
+    assert isinstance(response, web.FileResponse)
+    assert response.status == 200
+    assert Path(response._path) == preview_file.resolve()
+
+
 def test_is_preview_path_allowed_case_insensitive_on_windows(tmp_path):
     """Test that preview path validation is case-insensitive on Windows.
 

tests/services/test_backup_service.py

@@ -0,0 +1,228 @@
+import json
+import os
+import sqlite3
+from pathlib import Path
+
+import pytest
+
+import py.services.backup_service as backup_service
+from py.services.model_update_service import ModelUpdateService
+from py.utils.cache_paths import CacheType
+
+
+class DummySettings:
+    def __init__(self, settings_file: Path, *, library_name: str = "main", values=None):
+        self.settings_file = str(settings_file)
+        self._library_name = library_name
+        self._values = values or {}
+
+    def get(self, key, default=None):
+        return self._values.get(key, default)
+
+    def get_active_library_name(self):
+        return self._library_name
+
+
+def _configure_backup_paths(monkeypatch, root: Path):
+    settings_dir = root / "settings"
+    cache_dir = settings_dir / "cache"
+
+    def fake_get_settings_dir(create: bool = True):
+        if create:
+            settings_dir.mkdir(parents=True, exist_ok=True)
+        return str(settings_dir)
+
+    def fake_get_cache_base_dir(create: bool = True):
+        if create:
+            cache_dir.mkdir(parents=True, exist_ok=True)
+        return str(cache_dir)
+
+    def fake_get_cache_file_path(cache_type, library_name=None, create_dir=True):
+        if cache_type == CacheType.SYMLINK:
+            path = cache_dir / "symlink" / "symlink_map.json"
+        elif cache_type == CacheType.MODEL_UPDATE:
+            name = library_name or "default"
+            path = cache_dir / "model_update" / f"{name}.sqlite"
+        else:  # pragma: no cover - the test only covers the backup targets
+            raise AssertionError(f"Unexpected cache type: {cache_type}")
+
+        if create_dir:
+            path.parent.mkdir(parents=True, exist_ok=True)
+        return str(path)
+
+    monkeypatch.setattr(backup_service, "get_settings_dir", fake_get_settings_dir)
+    monkeypatch.setattr(backup_service, "get_cache_base_dir", fake_get_cache_base_dir)
+    monkeypatch.setattr(backup_service, "get_cache_file_path", fake_get_cache_file_path)
+
+    return settings_dir, cache_dir
+
+
+@pytest.mark.asyncio
+async def test_backup_round_trip_restores_user_state(tmp_path, monkeypatch):
+    settings_dir, cache_dir = _configure_backup_paths(monkeypatch, tmp_path)
+
+    settings_file = settings_dir / "settings.json"
+    download_history = cache_dir / "download_history" / "downloaded_versions.sqlite"
+    symlink_map = cache_dir / "symlink" / "symlink_map.json"
+    model_update_db = cache_dir / "model_update" / "main.sqlite"
+
+    settings_file.parent.mkdir(parents=True, exist_ok=True)
+    download_history.parent.mkdir(parents=True, exist_ok=True)
+    symlink_map.parent.mkdir(parents=True, exist_ok=True)
+    model_update_db.parent.mkdir(parents=True, exist_ok=True)
+
+    settings_file.write_text(json.dumps({"backup_auto_enabled": True}), encoding="utf-8")
+    download_history.write_bytes(b"download-history-v1")
+    symlink_map.write_text(json.dumps({"a": "/tmp/a"}), encoding="utf-8")
+    model_update_db.write_bytes(b"model-update-v1")
+
+    service = backup_service.BackupService(
+        settings_manager=DummySettings(settings_file),
+        backup_dir=str(tmp_path / "backups"),
+    )
+
+    snapshot = await service.create_snapshot(snapshot_type="manual", persist=False)
+    archive_path = tmp_path / snapshot["archive_name"]
+    archive_path.write_bytes(snapshot["archive_bytes"])
+
+    settings_file.write_text(json.dumps({"backup_auto_enabled": False}), encoding="utf-8")
+    download_history.write_bytes(b"download-history-v2")
+    symlink_map.write_text(json.dumps({"a": "/tmp/b"}), encoding="utf-8")
+    model_update_db.write_bytes(b"model-update-v2")
+
+    result = await service.restore_snapshot(str(archive_path))
+
+    assert result["success"] is True
+    assert settings_file.read_text(encoding="utf-8") == json.dumps({"backup_auto_enabled": True})
+    assert download_history.read_bytes() == b"download-history-v1"
+    assert symlink_map.read_text(encoding="utf-8") == json.dumps({"a": "/tmp/a"})
+    assert model_update_db.read_bytes() == b"model-update-v1"
+
+
+def test_prune_snapshots_keeps_latest_auto_only(tmp_path, monkeypatch):
+    settings_dir, _ = _configure_backup_paths(monkeypatch, tmp_path)
+    settings_file = settings_dir / "settings.json"
+    settings_file.parent.mkdir(parents=True, exist_ok=True)
+    settings_file.write_text(json.dumps({"backup_retention_count": 2}), encoding="utf-8")
+
+    service = backup_service.BackupService(
+        settings_manager=DummySettings(settings_file, values={"backup_retention_count": 2}),
+        backup_dir=str(tmp_path / "backups"),
+    )
+
+    backup_dir = Path(service.get_backup_dir())
+    backup_dir.mkdir(parents=True, exist_ok=True)
+
+    files = [
+        backup_dir / "lora-manager-backup-20240101T000000Z-auto.zip",
+        backup_dir / "lora-manager-backup-20240102T000000Z-auto.zip",
+        backup_dir / "lora-manager-backup-20240103T000000Z-auto.zip",
+        backup_dir / "lora-manager-backup-20240104T000000Z-manual.zip",
+    ]
+    for index, path in enumerate(files):
+        path.write_bytes(b"zip")
+        os.utime(path, (1000 + index, 1000 + index))
+
+    service._prune_snapshots()
+
+    remaining = sorted(p.name for p in backup_dir.glob("*.zip"))
+    assert remaining == [
+        "lora-manager-backup-20240102T000000Z-auto.zip",
+        "lora-manager-backup-20240103T000000Z-auto.zip",
+        "lora-manager-backup-20240104T000000Z-manual.zip",
+    ]
+
+
+def test_backup_status_includes_backup_dir(tmp_path, monkeypatch):
+    settings_dir, _ = _configure_backup_paths(monkeypatch, tmp_path)
+    settings_file = settings_dir / "settings.json"
+    settings_file.parent.mkdir(parents=True, exist_ok=True)
+    settings_file.write_text("{}", encoding="utf-8")
+
+    service = backup_service.BackupService(
+        settings_manager=DummySettings(settings_file),
+        backup_dir=str(tmp_path / "backups"),
+    )
+
+    status = service.get_status()
+
+    assert status["backupDir"] == str(tmp_path / "backups")
+
+
+@pytest.mark.asyncio
+async def test_model_update_service_migrates_legacy_snapshot_db(tmp_path, monkeypatch):
+    legacy_db = tmp_path / "legacy" / "main.sqlite"
+    new_db = tmp_path / "cache" / "model_update" / "main.sqlite"
+    legacy_db.parent.mkdir(parents=True, exist_ok=True)
+    new_db.parent.mkdir(parents=True, exist_ok=True)
+
+    with sqlite3.connect(legacy_db) as conn:
+        conn.executescript(
+            """
+            CREATE TABLE model_update_status (
+                model_id INTEGER PRIMARY KEY,
+                model_type TEXT NOT NULL,
+                last_checked_at REAL,
+                should_ignore_model INTEGER NOT NULL DEFAULT 0
+            );
+            CREATE TABLE model_update_versions (
+                model_id INTEGER NOT NULL,
+                version_id INTEGER NOT NULL,
+                sort_index INTEGER NOT NULL DEFAULT 0,
+                name TEXT,
+                base_model TEXT,
+                released_at TEXT,
+                size_bytes INTEGER,
+                preview_url TEXT,
+                is_in_library INTEGER NOT NULL DEFAULT 0,
+                should_ignore INTEGER NOT NULL DEFAULT 0,
+                early_access_ends_at TEXT,
+                is_early_access INTEGER NOT NULL DEFAULT 0,
+                PRIMARY KEY (model_id, version_id)
+            );
+            INSERT INTO model_update_status (
+                model_id, model_type, last_checked_at, should_ignore_model
+            ) VALUES (1, 'lora', 123.0, 1);
+            INSERT INTO model_update_versions (
+                model_id, version_id, sort_index, name, base_model, released_at,
+                size_bytes, preview_url, is_in_library, should_ignore,
+                early_access_ends_at, is_early_access
+            ) VALUES (
+                1, 11, 0, 'v1', 'SD15', '2024-01-01T00:00:00Z',
+                1024, 'https://example.com/v1.png', 1, 0, NULL, 0
+            );
+            """
+        )
+        conn.commit()
+
+    class DummySettingsManager:
+        def get_active_library_name(self):
+            return "main"
+
+    monkeypatch.setattr(
+        "py.services.model_update_service.resolve_cache_path_with_migration",
+        lambda *args, **kwargs: str(new_db),
+    )
+
+    class LegacyCache:
+        def get_database_path(self):
+            return str(legacy_db)
+
+    monkeypatch.setattr(
+        "py.services.persistent_model_cache.get_persistent_cache",
+        lambda *_args, **_kwargs: LegacyCache(),
+    )
+
+    service = ModelUpdateService(settings_manager=DummySettingsManager())
+
+    with sqlite3.connect(new_db) as conn:
+        row = conn.execute(
+            "SELECT model_id, model_type, last_checked_at, should_ignore_model FROM model_update_status"
+        ).fetchone()
+        version_row = conn.execute(
+            "SELECT model_id, version_id, name, base_model, is_in_library FROM model_update_versions"
+        ).fetchone()
+
+    assert row == (1, "lora", 123.0, 1)
+    assert version_row == (1, 11, "v1", "SD15", 1)
+    assert service._db_path == str(new_db)

tests/services/test_download_manager_basic.py

@@ -38,6 +38,7 @@ def isolate_settings(monkeypatch, tmp_path):
                 "embedding": "{base_model}/{first_tag}",
             },
             "base_model_path_mappings": {"BaseModel": "MappedModel"},
+            "skip_previously_downloaded_model_versions": False,
             "download_skip_base_models": [],
         }
     )
@@ -454,7 +455,7 @@ async def test_download_skips_excluded_base_model(monkeypatch, scanners, metadat
 
     metadata_provider.get_model_version = AsyncMock(
         return_value={
-            "id": 42,
+            "id": 99,
             "model": {"type": "LoRA", "tags": ["fantasy"]},
             "baseModel": "SDXL 1.0",
             "creator": {"username": "Author"},
@@ -490,3 +491,104 @@ async def test_download_skips_excluded_base_model(monkeypatch, scanners, metadat
     assert "file.safetensors" in result["message"]
     execute_download.assert_not_called()
     assert manager._active_downloads[result["download_id"]]["status"] == "skipped"
+
+
+@pytest.mark.asyncio
+async def test_download_skips_previously_downloaded_version(monkeypatch, scanners, metadata_provider):
+    manager = DownloadManager()
+    get_settings_manager().settings["skip_previously_downloaded_model_versions"] = True
+
+    metadata_provider.get_model_version = AsyncMock(
+        return_value={
+            "id": 42,
+            "model": {"type": "LoRA", "tags": ["fantasy"]},
+            "baseModel": "SDXL 1.0",
+            "creator": {"username": "Author"},
+            "files": [
+                {
+                    "type": "Model",
+                    "primary": True,
+                    "downloadUrl": "https://example.invalid/file.safetensors",
+                    "name": "file.safetensors",
+                }
+            ],
+        }
+    )
+
+    history_service = AsyncMock()
+    history_service.has_been_downloaded = AsyncMock(return_value=True)
+    monkeypatch.setattr(
+        ServiceRegistry,
+        "get_downloaded_version_history_service",
+        AsyncMock(return_value=history_service),
+    )
+
+    execute_download = AsyncMock()
+    monkeypatch.setattr(
+        DownloadManager, "_execute_download", execute_download, raising=False
+    )
+
+    result = await manager.download_from_civitai(
+        model_version_id=99,
+        use_default_paths=True,
+        progress_callback=None,
+        source=None,
+    )
+
+    assert result["success"] is True
+    assert result["skipped"] is True
+    assert result["status"] == "skipped"
+    assert result["reason"] == "previously_downloaded_version"
+    assert result["model_version_id"] == 99
+    assert result["file_name"] == "file.safetensors"
+    history_service.has_been_downloaded.assert_awaited_once_with("lora", 99)
+    execute_download.assert_not_called()
+    assert manager._active_downloads[result["download_id"]]["status"] == "skipped"
+
+
+@pytest.mark.asyncio
+async def test_download_proceeds_when_history_skip_disabled(monkeypatch, scanners, metadata_provider):
+    manager = DownloadManager()
+    get_settings_manager().settings["skip_previously_downloaded_model_versions"] = False
+
+    metadata_provider.get_model_version = AsyncMock(
+        return_value={
+            "id": 42,
+            "model": {"type": "LoRA", "tags": ["fantasy"]},
+            "baseModel": "SDXL 1.0",
+            "creator": {"username": "Author"},
+            "files": [
+                {
+                    "type": "Model",
+                    "primary": True,
+                    "downloadUrl": "https://example.invalid/file.safetensors",
+                    "name": "file.safetensors",
+                }
+            ],
+        }
+    )
+
+    history_service = AsyncMock()
+    history_service.has_been_downloaded = AsyncMock(return_value=True)
+    monkeypatch.setattr(
+        ServiceRegistry,
+        "get_downloaded_version_history_service",
+        AsyncMock(return_value=history_service),
+    )
+
+    execute_download = AsyncMock(return_value={"success": True, "download_id": "done"})
+    monkeypatch.setattr(
+        DownloadManager, "_execute_download", execute_download, raising=False
+    )
+
+    result = await manager.download_from_civitai(
+        model_version_id=99,
+        use_default_paths=True,
+        progress_callback=None,
+        source=None,
+    )
+
+    assert result["success"] is True
+    assert result.get("skipped") is not True
+    history_service.has_been_downloaded.assert_not_called()
+    execute_download.assert_awaited_once()

tests/services/test_downloaded_version_history_service.py

@@ -0,0 +1,70 @@
+from pathlib import Path
+
+import pytest
+
+from py.services.downloaded_version_history_service import (
+    DownloadedVersionHistoryService,
+)
+
+
+class DummySettings:
+    def get_active_library_name(self) -> str:
+        return "alpha"
+
+
+@pytest.mark.asyncio
+async def test_download_history_roundtrip_and_manual_override(tmp_path: Path) -> None:
+    db_path = tmp_path / "download-history.sqlite"
+    service = DownloadedVersionHistoryService(
+        str(db_path),
+        settings_manager=DummySettings(),
+    )
+
+    await service.mark_downloaded(
+        "lora",
+        101,
+        model_id=11,
+        source="scan",
+        file_path="/models/a.safetensors",
+    )
+    assert await service.has_been_downloaded("lora", 101) is True
+    assert await service.get_downloaded_version_ids("lora", 11) == [101]
+
+    await service.mark_not_downloaded("lora", 101)
+    assert await service.has_been_downloaded("lora", 101) is False
+    assert await service.get_downloaded_version_ids("lora", 11) == []
+
+    await service.mark_downloaded(
+        "lora",
+        101,
+        model_id=11,
+        source="download",
+        file_path="/models/a.safetensors",
+    )
+    assert await service.has_been_downloaded("lora", 101) is True
+    assert await service.get_downloaded_version_ids("lora", 11) == [101]
+
+
+@pytest.mark.asyncio
+async def test_download_history_bulk_lookup(tmp_path: Path) -> None:
+    db_path = tmp_path / "download-history.sqlite"
+    service = DownloadedVersionHistoryService(
+        str(db_path),
+        settings_manager=DummySettings(),
+    )
+
+    await service.mark_downloaded_bulk(
+        "checkpoint",
+        [
+            {"model_id": 5, "version_id": 501, "file_path": "/m/one.safetensors"},
+            {"model_id": 5, "version_id": 502, "file_path": "/m/two.safetensors"},
+            {"model_id": 6, "version_id": 601, "file_path": "/m/three.safetensors"},
+        ],
+        source="scan",
+    )
+
+    assert await service.get_downloaded_version_ids("checkpoint", 5) == [501, 502]
+    assert await service.get_downloaded_version_ids_bulk("checkpoint", [5, 6, 7]) == {
+        5: {501, 502},
+        6: {601},
+    }

tests/services/test_recipe_scanner.py

@@ -8,6 +8,7 @@ import pytest
 
 from py.config import config
 from py.services.recipe_scanner import RecipeScanner
+from py.services import settings_manager as settings_manager_module
 from py.utils.utils import calculate_recipe_fingerprint
 
 
@@ -72,12 +73,56 @@ class StubLoraScanner:
 @pytest.fixture
 def recipe_scanner(tmp_path: Path, monkeypatch):
     RecipeScanner._instance = None
+    settings_manager_module.reset_settings_manager()
     monkeypatch.setattr(config, "loras_roots", [str(tmp_path)])
     stub = StubLoraScanner()
     scanner = RecipeScanner(lora_scanner=stub)
     asyncio.run(scanner.refresh_cache(force=True))
     yield scanner, stub
     RecipeScanner._instance = None
+    settings_manager_module.reset_settings_manager()
+
+
+def test_recipes_dir_uses_custom_settings_path(tmp_path: Path, monkeypatch):
+    RecipeScanner._instance = None
+    settings_manager_module.reset_settings_manager()
+
+    settings_path = tmp_path / "settings.json"
+    custom_recipes = tmp_path / "custom" / ".." / "custom_recipes"
+
+    monkeypatch.setattr(
+        "py.services.settings_manager.ensure_settings_file",
+        lambda logger=None: str(settings_path),
+    )
+    monkeypatch.setattr(config, "loras_roots", [str(tmp_path / "loras-root")])
+
+    manager = settings_manager_module.get_settings_manager()
+    manager.set("recipes_path", str(custom_recipes))
+
+    scanner = RecipeScanner(lora_scanner=StubLoraScanner())
+    resolved = scanner.recipes_dir
+
+    assert resolved == str((tmp_path / "custom_recipes").resolve())
+    assert Path(resolved).is_dir()
+
+    RecipeScanner._instance = None
+    settings_manager_module.reset_settings_manager()
+
+
+def test_recipes_dir_falls_back_to_first_lora_root(tmp_path: Path, monkeypatch):
+    RecipeScanner._instance = None
+    settings_manager_module.reset_settings_manager()
+
+    monkeypatch.setattr(config, "loras_roots", [str(tmp_path / "alpha")])
+
+    scanner = RecipeScanner(lora_scanner=StubLoraScanner())
+    resolved = scanner.recipes_dir
+
+    assert resolved == str(tmp_path / "alpha" / "recipes")
+    assert Path(resolved).is_dir()
+
+    RecipeScanner._instance = None
+    settings_manager_module.reset_settings_manager()
 
 
 async def test_add_recipe_during_concurrent_reads(recipe_scanner):

tests/services/test_settings_manager.py

@@ -496,6 +496,7 @@ def test_migrate_sanitizes_legacy_libraries(tmp_path, monkeypatch):
     assert payload["default_lora_root"] == ""
     assert payload["default_checkpoint_root"] == ""
     assert payload["default_embedding_root"] == ""
+    assert payload["recipes_path"] == ""
     assert manager.get_active_library_name() == "legacy"
 
 
@@ -507,12 +508,14 @@ def test_active_library_syncs_top_level_settings(tmp_path, monkeypatch):
                 "default_lora_root": "/loras",
                 "default_checkpoint_root": "/ckpt",
                 "default_embedding_root": "/embed",
+                "recipes_path": "/loras/recipes",
             },
             "studio": {
                 "folder_paths": {"loras": ["/studio"]},
                 "default_lora_root": "/studio",
                 "default_checkpoint_root": "/studio_ckpt",
                 "default_embedding_root": "/studio_embed",
+                "recipes_path": "/studio/custom-recipes",
             },
         },
         "active_library": "studio",
@@ -521,6 +524,7 @@ def test_active_library_syncs_top_level_settings(tmp_path, monkeypatch):
         "default_lora_root": "/loras",
         "default_checkpoint_root": "/ckpt",
         "default_embedding_root": "/embed",
+        "recipes_path": "/loras/recipes",
     }
 
     manager = _create_manager_with_settings(tmp_path, monkeypatch, initial)
@@ -530,14 +534,17 @@ def test_active_library_syncs_top_level_settings(tmp_path, monkeypatch):
     assert manager.get("default_lora_root") == "/studio"
     assert manager.get("default_checkpoint_root") == "/studio_ckpt"
     assert manager.get("default_embedding_root") == "/studio_embed"
+    assert manager.get("recipes_path") == "/studio/custom-recipes"
 
     # Drift the top-level values again and ensure activate_library repairs them
     manager.settings["folder_paths"] = {"loras": ["/loras"]}
     manager.settings["default_lora_root"] = "/loras"
+    manager.settings["recipes_path"] = "/loras/recipes"
     manager.activate_library("studio")
 
     assert manager.get("folder_paths")["loras"] == ["/studio"]
     assert manager.get("default_lora_root") == "/studio"
+    assert manager.get("recipes_path") == "/studio/custom-recipes"
 
 
 def test_refresh_environment_variables_updates_stored_value(tmp_path, monkeypatch):
@@ -554,6 +561,7 @@ def test_refresh_environment_variables_updates_stored_value(tmp_path, monkeypatc
                 "default_lora_root": "",
                 "default_checkpoint_root": "",
                 "default_embedding_root": "",
+                "recipes_path": "",
             }
         },
         "active_library": "default",
@@ -589,6 +597,177 @@ def test_upsert_library_creates_entry_and_activates(manager, tmp_path):
     assert str(lora_dir).replace(os.sep, "/") in normalized_stored_paths
 
 
+def test_set_recipes_path_updates_active_library_entry(manager, tmp_path):
+    recipes_dir = tmp_path / "custom" / "recipes"
+
+    manager.set("recipes_path", str(recipes_dir))
+
+    assert manager.get("recipes_path") == str(recipes_dir.resolve())
+    assert (
+        manager.get_libraries()["default"]["recipes_path"]
+        == str(recipes_dir.resolve())
+    )
+
+
+def test_set_recipes_path_migrates_existing_recipe_files(manager, tmp_path):
+    lora_root = tmp_path / "loras"
+    old_recipes_dir = lora_root / "recipes" / "nested"
+    old_recipes_dir.mkdir(parents=True)
+    manager.set("folder_paths", {"loras": [str(lora_root)]})
+
+    recipe_id = "recipe-1"
+    old_image_path = old_recipes_dir / f"{recipe_id}.webp"
+    old_json_path = old_recipes_dir / f"{recipe_id}.recipe.json"
+    old_image_path.write_bytes(b"image-bytes")
+    old_json_path.write_text(
+        json.dumps(
+            {
+                "id": recipe_id,
+                "file_path": str(old_image_path),
+                "title": "Recipe 1",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    new_recipes_dir = tmp_path / "custom_recipes"
+    manager.set("recipes_path", str(new_recipes_dir))
+
+    migrated_image_path = new_recipes_dir / "nested" / f"{recipe_id}.webp"
+    migrated_json_path = new_recipes_dir / "nested" / f"{recipe_id}.recipe.json"
+
+    assert manager.get("recipes_path") == str(new_recipes_dir.resolve())
+    assert migrated_image_path.read_bytes() == b"image-bytes"
+    migrated_payload = json.loads(migrated_json_path.read_text(encoding="utf-8"))
+    assert migrated_payload["file_path"] == str(migrated_image_path)
+    assert not old_image_path.exists()
+    assert not old_json_path.exists()
+
+
+def test_clearing_recipes_path_migrates_files_to_default_location(manager, tmp_path):
+    lora_root = tmp_path / "loras"
+    custom_recipes_dir = tmp_path / "custom_recipes"
+    old_recipes_dir = custom_recipes_dir / "nested"
+    old_recipes_dir.mkdir(parents=True)
+    manager.set("folder_paths", {"loras": [str(lora_root)]})
+    manager.settings["recipes_path"] = str(custom_recipes_dir)
+
+    recipe_id = "recipe-2"
+    old_image_path = old_recipes_dir / f"{recipe_id}.webp"
+    old_json_path = old_recipes_dir / f"{recipe_id}.recipe.json"
+    old_image_path.write_bytes(b"image-bytes")
+    old_json_path.write_text(
+        json.dumps(
+            {
+                "id": recipe_id,
+                "file_path": str(old_image_path),
+                "title": "Recipe 2",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    manager.set("recipes_path", "")
+
+    fallback_recipes_dir = lora_root / "recipes"
+    migrated_image_path = fallback_recipes_dir / "nested" / f"{recipe_id}.webp"
+    migrated_json_path = fallback_recipes_dir / "nested" / f"{recipe_id}.recipe.json"
+
+    assert manager.get("recipes_path") == ""
+    assert migrated_image_path.read_bytes() == b"image-bytes"
+    migrated_payload = json.loads(migrated_json_path.read_text(encoding="utf-8"))
+    assert migrated_payload["file_path"] == str(migrated_image_path)
+    assert not old_image_path.exists()
+    assert not old_json_path.exists()
+
+
+def test_moving_recipes_path_back_to_parent_directory_is_allowed(manager, tmp_path):
+    lora_root = tmp_path / "loras"
+    manager.set("folder_paths", {"loras": [str(lora_root)]})
+
+    source_recipes_dir = lora_root / "recipes" / "custom"
+    source_recipes_dir.mkdir(parents=True)
+
+    recipe_id = "recipe-parent"
+    old_image_path = source_recipes_dir / f"{recipe_id}.webp"
+    old_json_path = source_recipes_dir / f"{recipe_id}.recipe.json"
+    old_image_path.write_bytes(b"parent-bytes")
+    old_json_path.write_text(
+        json.dumps(
+            {
+                "id": recipe_id,
+                "file_path": str(old_image_path),
+                "title": "Recipe Parent",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    manager.settings["recipes_path"] = str(source_recipes_dir)
+    manager.set("recipes_path", str(lora_root / "recipes"))
+
+    migrated_image_path = lora_root / "recipes" / f"{recipe_id}.webp"
+    migrated_json_path = lora_root / "recipes" / f"{recipe_id}.recipe.json"
+
+    assert manager.get("recipes_path") == str((lora_root / "recipes").resolve())
+    assert migrated_image_path.read_bytes() == b"parent-bytes"
+    migrated_payload = json.loads(migrated_json_path.read_text(encoding="utf-8"))
+    assert migrated_payload["file_path"] == str(migrated_image_path)
+    assert not old_image_path.exists()
+    assert not old_json_path.exists()
+
+
+def test_set_recipes_path_rewrites_symlinked_recipe_metadata(manager, tmp_path):
+    real_recipes_dir = tmp_path / "real_recipes"
+    real_recipes_dir.mkdir()
+    symlink_recipes_dir = tmp_path / "linked_recipes"
+    symlink_recipes_dir.symlink_to(real_recipes_dir, target_is_directory=True)
+
+    manager.settings["recipes_path"] = str(symlink_recipes_dir)
+    manager.set("folder_paths", {"loras": [str(tmp_path / "loras")]})
+
+    recipe_id = "recipe-symlink"
+    old_image_path = real_recipes_dir / f"{recipe_id}.webp"
+    old_json_path = real_recipes_dir / f"{recipe_id}.recipe.json"
+    old_image_path.write_bytes(b"symlink-bytes")
+    old_json_path.write_text(
+        json.dumps(
+            {
+                "id": recipe_id,
+                "file_path": str(old_image_path),
+                "title": "Recipe Symlink",
+            }
+        ),
+        encoding="utf-8",
+    )
+
+    new_recipes_dir = tmp_path / "migrated_recipes"
+    manager.set("recipes_path", str(new_recipes_dir))
+
+    migrated_image_path = new_recipes_dir / f"{recipe_id}.webp"
+    migrated_json_path = new_recipes_dir / f"{recipe_id}.recipe.json"
+
+    assert migrated_image_path.read_bytes() == b"symlink-bytes"
+    migrated_payload = json.loads(migrated_json_path.read_text(encoding="utf-8"))
+    assert migrated_payload["file_path"] == str(migrated_image_path)
+    assert not old_image_path.exists()
+    assert not old_json_path.exists()
+
+
+def test_set_recipes_path_rejects_file_target(manager, tmp_path):
+    lora_root = tmp_path / "loras"
+    lora_root.mkdir()
+    manager.set("folder_paths", {"loras": [str(lora_root)]})
+
+    target_file = tmp_path / "not_a_directory"
+    target_file.write_text("blocked", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="directory"):
+        manager.set("recipes_path", str(target_file))
+
+    assert manager.get("recipes_path") == ""
+
+
 def test_extra_folder_paths_stored_separately(manager, tmp_path):
     lora_dir = tmp_path / "loras"
     extra_dir = tmp_path / "extra_loras"
@@ -829,3 +1008,14 @@ def test_setting_download_skip_base_models_normalizes_string_input(manager):
     manager.set("download_skip_base_models", "SDXL 1.0, Pony; Invalid\nSDXL 1.0")
 
     assert manager.get("download_skip_base_models") == ["SDXL 1.0", "Pony"]
+
+
+def test_skip_previously_downloaded_model_versions_defaults_false(manager):
+    assert manager.get_skip_previously_downloaded_model_versions() is False
+
+
+def test_skip_previously_downloaded_model_versions_coerces_string_input(manager):
+    manager.settings["skip_previously_downloaded_model_versions"] = "true"
+
+    assert manager.get_skip_previously_downloaded_model_versions() is True
+    assert manager.settings["skip_previously_downloaded_model_versions"] is True

tests/utils/test_civitai_utils_rewrite.py

@@ -0,0 +1,144 @@
+"""Tests for CivitAI URL utilities."""
+
+import pytest
+
+from py.utils.civitai_utils import rewrite_preview_url
+
+
+class TestRewritePreviewUrl:
+    """Test cases for rewrite_preview_url function."""
+
+    def test_handles_none_input(self):
+        """Should return (None, False) for None input."""
+        result, was_rewritten = rewrite_preview_url(None)
+        assert result is None
+        assert was_rewritten is False
+
+    def test_handles_empty_string(self):
+        """Should return (empty_string, False) for empty input."""
+        result, was_rewritten = rewrite_preview_url("")
+        assert result == ""
+        assert was_rewritten is False
+
+    def test_handles_invalid_url(self):
+        """Should return original URL and False for invalid URLs."""
+        invalid_url = "not-a-valid-url"
+        result, was_rewritten = rewrite_preview_url(invalid_url)
+        assert result == invalid_url
+        assert was_rewritten is False
+
+    def test_handles_url_without_scheme(self):
+        """Should return original URL and False for URLs without scheme."""
+        url = "image.civitai.com/something"
+        result, was_rewritten = rewrite_preview_url(url)
+        assert result == url
+        assert was_rewritten is False
+
+    def test_returns_false_for_non_civitai_domains(self):
+        """Should not rewrite URLs from other domains."""
+        url = "https://example.com/image.jpg"
+        result, was_rewritten = rewrite_preview_url(url)
+        assert result == url
+        assert was_rewritten is False
+
+    def test_returns_false_for_main_civitai_domain(self):
+        """Should not rewrite URLs from main civitai.com domain."""
+        url = "https://civitai.com/images/123"
+        result, was_rewritten = rewrite_preview_url(url)
+        assert result == url
+        assert was_rewritten is False
+
+    def test_rewrites_image_civitai_com_urls(self):
+        """Should rewrite URLs from image.civitai.com."""
+        url = "https://image.civitai.com/checkpoints/original=true"
+        result, was_rewritten = rewrite_preview_url(url, "image")
+        assert (
+            result == "https://image.civitai.com/checkpoints/width=450,optimized=true"
+        )
+        assert was_rewritten is True
+
+    def test_rewrites_subdomain_civitai_urls(self):
+        """Should rewrite URLs from CivitAI CDN subdomains like image-b2.civitai.com."""
+        url = "https://image-b2.civitai.com/file/civitai-media-cache/original=true/sample.png"
+        result, was_rewritten = rewrite_preview_url(url, "image")
+        assert (
+            result
+            == "https://image-b2.civitai.com/file/civitai-media-cache/width=450,optimized=true/sample.png"
+        )
+        assert was_rewritten is True
+
+    def test_rewrites_multiple_subdomains(self):
+        """Should rewrite URLs from various CivitAI subdomains."""
+        test_cases = [
+            "https://image-b3.civitai.com/original=true/test.jpg",
+            "https://cdn.civitai.com/original=true/test.png",
+        ]
+        for url in test_cases:
+            result, was_rewritten = rewrite_preview_url(url, "image")
+            assert was_rewritten is True
+            assert "width=450,optimized=true" in result
+
+    def test_handles_urls_with_explicit_port(self):
+        """Should correctly handle URLs with explicit port numbers."""
+        url = "https://image.civitai.com:443/checkpoints/original=true"
+        result, was_rewritten = rewrite_preview_url(url, "image")
+        assert was_rewritten is True
+        assert "width=450,optimized=true" in result
+        # Port is preserved in the URL (this is acceptable behavior)
+        assert ":443" in result
+
+    def test_rewrites_video_urls_with_transcode(self):
+        """Should rewrite video URLs with transcode parameter."""
+        url = "https://image.civitai.com/videos/original=true/sample.mp4"
+        result, was_rewritten = rewrite_preview_url(url, "video")
+        assert (
+            result
+            == "https://image.civitai.com/videos/transcode=true,width=450,optimized=true/sample.mp4"
+        )
+        assert was_rewritten is True
+
+    def test_video_rewrite_uses_case_insensitive_type(self):
+        """Should handle video type case-insensitively."""
+        url = "https://image.civitai.com/original=true/test.mp4"
+        result1, was1 = rewrite_preview_url(url, "VIDEO")
+        result2, was2 = rewrite_preview_url(url, "Video")
+        assert was1 is True
+        assert was2 is True
+        assert "transcode=true" in result1
+        assert "transcode=true" in result2
+
+    def test_returns_original_when_no_original_true_in_path(self):
+        """Should not rewrite URLs that don't contain /original=true."""
+        url = "https://image.civitai.com/checkpoints/optimized=true"
+        result, was_rewritten = rewrite_preview_url(url)
+        assert result == url
+        assert was_rewritten is False
+
+    def test_preserves_path_structure_after_rewrite(self):
+        """Should maintain path structure after rewriting."""
+        url = "https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/original=true/12345.png"
+        result, was_rewritten = rewrite_preview_url(url, "image")
+        assert was_rewritten is True
+        assert result.startswith(
+            "https://image.civitai.com/xG1nkqKTMzGDvpLrqFT7WA/abc123/"
+        )
+        assert result.endswith("/12345.png")
+
+    def test_defaults_to_image_mode_when_media_type_is_none(self):
+        """Should use image optimization when media_type is None."""
+        url = "https://image.civitai.com/original=true/test.png"
+        result, was_rewritten = rewrite_preview_url(url, None)
+        assert was_rewritten is True
+        assert "transcode=true" not in result
+        assert "width=450,optimized=true" in result
+
+    def test_case_insensitive_hostname_matching(self):
+        """Should handle case-insensitive hostname matching."""
+        test_cases = [
+            "https://IMAGE.CIVITAI.COM/original=true/test.png",
+            "https://Image.Civitai.Com/original=true/test.png",
+            "https://image-b2.CIVITAI.com/original=true/test.png",
+        ]
+        for url in test_cases:
+            result, was_rewritten = rewrite_preview_url(url, "image")
+            assert was_rewritten is True, f"Failed for URL: {url}"

tests/utils/test_usage_stats.py

@@ -152,3 +152,67 @@ async def test_usage_stats_background_processor_handles_pending_prompts(tmp_path
     assert stats.stats["loras"]["lora-hash"]["history"][today] == 1
 
     await _finalize_usage_stats(tasks)
+
+
+async def test_usage_stats_calculates_pending_checkpoint_hash_on_demand(tmp_path, monkeypatch):
+    stats, tasks, _ = _prepare_usage_stats(tmp_path, monkeypatch)
+
+    metadata_payload = {
+        "models": {
+            "1": {"type": "checkpoint", "name": "pending_model.safetensors"},
+        },
+        "loras": {},
+    }
+
+    checkpoint_cache = SimpleNamespace(
+        raw_data=[
+            {
+                "file_name": "pending_model",
+                "model_name": "pending_model",
+                "file_path": "/models/pending_model.safetensors",
+                "sha256": "",
+                "hash_status": "pending",
+            }
+        ]
+    )
+    checkpoint_scanner = SimpleNamespace(
+        get_hash_by_filename=lambda name: None,
+        get_cached_data=AsyncMock(return_value=checkpoint_cache),
+        calculate_hash_for_model=AsyncMock(return_value="resolved-hash"),
+    )
+    lora_scanner = SimpleNamespace(get_hash_by_filename=lambda name: None)
+
+    monkeypatch.setattr(ServiceRegistry, "get_checkpoint_scanner", AsyncMock(return_value=checkpoint_scanner))
+    monkeypatch.setattr(ServiceRegistry, "get_lora_scanner", AsyncMock(return_value=lora_scanner))
+
+    await stats._process_metadata(metadata_payload)
+
+    today = datetime.now().strftime("%Y-%m-%d")
+    checkpoint_scanner.calculate_hash_for_model.assert_awaited_once_with("/models/pending_model.safetensors")
+    assert stats.stats["checkpoints"]["resolved-hash"]["history"][today] == 1
+
+    await _finalize_usage_stats(tasks)
+
+
+async def test_usage_stats_skips_name_fallback_for_missing_lora_hash(tmp_path, monkeypatch):
+    stats, tasks, _ = _prepare_usage_stats(tmp_path, monkeypatch)
+
+    metadata_payload = {
+        "models": {},
+        "loras": {
+            "2": {"lora_list": [{"name": "missing_lora"}]},
+        },
+    }
+
+    checkpoint_scanner = SimpleNamespace(get_hash_by_filename=lambda name: None)
+    lora_scanner = SimpleNamespace(get_hash_by_filename=lambda name: None)
+
+    monkeypatch.setattr(ServiceRegistry, "get_checkpoint_scanner", AsyncMock(return_value=checkpoint_scanner))
+    monkeypatch.setattr(ServiceRegistry, "get_lora_scanner", AsyncMock(return_value=lora_scanner))
+
+    await stats._process_metadata(metadata_payload)
+
+    assert stats.stats["loras"] == {}
+    assert not any(key.startswith("name:") for key in stats.stats["loras"])
+
+    await _finalize_usage_stats(tasks)

vue-widgets/src/main.ts

@@ -9,7 +9,7 @@ import type { LoraPoolConfig, RandomizerConfig, CyclerConfig } from './composabl
 import {
   setupModeChangeHandler,
   createModeChangeCallback,
-  LORA_PROVIDER_NODE_TYPES
+  LORA_CHAIN_NODE_TYPES
 } from './mode-change-handler'
 
 const LORA_POOL_WIDGET_MIN_WIDTH = 500
@@ -755,8 +755,8 @@ app.registerExtension({
       }
     }
 
-    // Register mode change handlers for LoRA provider nodes
-    if (LORA_PROVIDER_NODE_TYPES.includes(comfyClass)) {
+    // Register mode change handlers for LORA_STACK chain nodes
+    if (LORA_CHAIN_NODE_TYPES.includes(comfyClass)) {
       const originalOnNodeCreated = nodeType.prototype.onNodeCreated
 
       nodeType.prototype.onNodeCreated = function () {

vue-widgets/src/mode-change-handler.ts

@@ -18,7 +18,22 @@ export const LORA_PROVIDER_NODE_TYPES = [
   "Lora Cycler (LoraManager)",
 ] as const;
 
+/**
+ * Nodes that do not own LoRA state themselves, but merge or forward LORA_STACK
+ * inputs so downstream trigger-word updates must traverse through them.
+ */
+export const LORA_STACK_AGGREGATOR_NODE_TYPES = [
+  "Lora Stack Combiner (LoraManager)",
+] as const;
+
+export const LORA_CHAIN_NODE_TYPES = [
+  ...LORA_PROVIDER_NODE_TYPES,
+  ...LORA_STACK_AGGREGATOR_NODE_TYPES,
+] as const;
+
 export type LoraProviderNodeType = typeof LORA_PROVIDER_NODE_TYPES[number];
+export type LoraStackAggregatorNodeType = typeof LORA_STACK_AGGREGATOR_NODE_TYPES[number];
+export type LoraChainNodeType = typeof LORA_CHAIN_NODE_TYPES[number];
 
 /**
  * Check if a node class is a LoRA provider node.
@@ -27,6 +42,16 @@ export function isLoraProviderNode(comfyClass: string): comfyClass is LoraProvid
   return LORA_PROVIDER_NODE_TYPES.includes(comfyClass as LoraProviderNodeType);
 }
 
+export function isLoraStackAggregatorNode(
+  comfyClass: string
+): comfyClass is LoraStackAggregatorNodeType {
+  return LORA_STACK_AGGREGATOR_NODE_TYPES.includes(comfyClass as LoraStackAggregatorNodeType);
+}
+
+export function isLoraChainNode(comfyClass: string): comfyClass is LoraChainNodeType {
+  return LORA_CHAIN_NODE_TYPES.includes(comfyClass as LoraChainNodeType);
+}
+
 /**
  * Extract active LoRA filenames from a node based on its type.
  *
@@ -40,6 +65,10 @@ export function getActiveLorasFromNodeByType(node: any): Set<string> {
     return extractFromCyclerConfig(node);
   }
 
+  if (isLoraStackAggregatorNode(comfyClass)) {
+    return new Set<string>();
+  }
+
   // Default: use lorasWidget (works for Stacker and Randomizer)
   return extractFromLorasWidget(node);
 }

web/comfyui/autocomplete.js

@@ -3,6 +3,7 @@ import { app } from "../../scripts/app.js";
 import { TextAreaCaretHelper } from "./textarea_caret_helper.js";
 import {
     getAutocompleteAppendCommaPreference,
+    getAutocompleteAutoFormatPreference,
     getAutocompleteAcceptKeyPreference,
     getPromptTagAutocompletePreference,
     getTagSpaceReplacementPreference,
@@ -122,6 +123,32 @@ function formatAutocompleteInsertion(text = '') {
     return getAutocompleteAppendCommaPreference() ? `${trimmed},` : `${trimmed} `;
 }
 
+function normalizeAutocompleteSegment(segment = '') {
+    return segment.replace(/\s+/g, ' ').trim();
+}
+
+export function formatAutocompleteTextOnBlur(text = '') {
+    if (typeof text !== 'string') {
+        return '';
+    }
+
+    return text
+        .split('\n')
+        .map((line) => {
+            if (!line.trim()) {
+                return '';
+            }
+
+            const cleanedSegments = line
+                .split(',')
+                .map(normalizeAutocompleteSegment)
+                .filter(Boolean);
+
+            return cleanedSegments.join(', ');
+        })
+        .join('\n');
+}
+
 function shouldAcceptAutocompleteKey(key) {
     const mode = getAutocompleteAcceptKeyPreference();
 
@@ -481,6 +508,14 @@ class AutoComplete {
 
         // Handle focus out to hide dropdown
         this.onBlur = () => {
+            if (getAutocompleteAutoFormatPreference()) {
+                const formattedValue = formatAutocompleteTextOnBlur(this.inputElement.value);
+                if (formattedValue !== this.inputElement.value) {
+                    this.inputElement.value = formattedValue;
+                    this.inputElement.dispatchEvent(new Event('input', { bubbles: true }));
+                }
+            }
+
             // Delay hiding to allow for clicks on dropdown items
             setTimeout(() => {
                 this.hide();

web/comfyui/settings.js

@@ -16,6 +16,9 @@ const PROMPT_TAG_AUTOCOMPLETE_DEFAULT = true;
 const AUTOCOMPLETE_APPEND_COMMA_SETTING_ID = "loramanager.autocomplete_append_comma";
 const AUTOCOMPLETE_APPEND_COMMA_DEFAULT = true;
 
+const AUTOCOMPLETE_AUTO_FORMAT_SETTING_ID = "loramanager.autocomplete_auto_format";
+const AUTOCOMPLETE_AUTO_FORMAT_DEFAULT = true;
+
 const AUTOCOMPLETE_ACCEPT_KEY_SETTING_ID = "loramanager.autocomplete_accept_key";
 const AUTOCOMPLETE_ACCEPT_KEY_DEFAULT = "both";
 const AUTOCOMPLETE_ACCEPT_KEY_OPTION_BOTH = "Tab or Enter";
@@ -192,6 +195,32 @@ const getAutocompleteAppendCommaPreference = (() => {
     };
 })();
 
+const getAutocompleteAutoFormatPreference = (() => {
+    let settingsUnavailableLogged = false;
+
+    return () => {
+        const settingManager = app?.extensionManager?.setting;
+        if (!settingManager || typeof settingManager.get !== "function") {
+            if (!settingsUnavailableLogged) {
+                console.warn("LoRA Manager: settings API unavailable, using default autocomplete auto format setting.");
+                settingsUnavailableLogged = true;
+            }
+            return AUTOCOMPLETE_AUTO_FORMAT_DEFAULT;
+        }
+
+        try {
+            const value = settingManager.get(AUTOCOMPLETE_AUTO_FORMAT_SETTING_ID);
+            return value ?? AUTOCOMPLETE_AUTO_FORMAT_DEFAULT;
+        } catch (error) {
+            if (!settingsUnavailableLogged) {
+                console.warn("LoRA Manager: unable to read autocomplete auto format setting, using default.", error);
+                settingsUnavailableLogged = true;
+            }
+            return AUTOCOMPLETE_AUTO_FORMAT_DEFAULT;
+        }
+    };
+})();
+
 const getAutocompleteAcceptKeyPreference = (() => {
     let settingsUnavailableLogged = false;
 
@@ -375,6 +404,14 @@ app.registerExtension({
             tooltip: "When enabled, accepted autocomplete suggestions append ', ' to the inserted text.",
             category: ["LoRA Manager", "Autocomplete", "Append comma"],
         },
+        {
+            id: AUTOCOMPLETE_AUTO_FORMAT_SETTING_ID,
+            name: "Auto format autocomplete text on blur",
+            type: "boolean",
+            defaultValue: AUTOCOMPLETE_AUTO_FORMAT_DEFAULT,
+            tooltip: "When enabled, leaving an autocomplete textarea removes duplicate commas and collapses unnecessary spaces.",
+            category: ["LoRA Manager", "Autocomplete", "Auto Format"],
+        },
         {
             id: AUTOCOMPLETE_ACCEPT_KEY_SETTING_ID,
             name: "Autocomplete accept key",
@@ -505,6 +542,7 @@ export {
     getWheelSensitivity,
     getAutoPathCorrectionPreference,
     getAutocompleteAppendCommaPreference,
+    getAutocompleteAutoFormatPreference,
     getAutocompleteAcceptKeyPreference,
     getPromptTagAutocompletePreference,
     getTagSpaceReplacementPreference,

web/comfyui/utils.js

@@ -10,10 +10,27 @@ export const LORA_PROVIDER_NODE_TYPES = [
   "Lora Cycler (LoraManager)",
 ];
 
+export const LORA_STACK_AGGREGATOR_NODE_TYPES = [
+  "Lora Stack Combiner (LoraManager)",
+];
+
+export const LORA_CHAIN_NODE_TYPES = [
+  ...LORA_PROVIDER_NODE_TYPES,
+  ...LORA_STACK_AGGREGATOR_NODE_TYPES,
+];
+
 export function isLoraProviderNode(comfyClass) {
   return LORA_PROVIDER_NODE_TYPES.includes(comfyClass);
 }
 
+export function isLoraStackAggregatorNode(comfyClass) {
+    return LORA_STACK_AGGREGATOR_NODE_TYPES.includes(comfyClass);
+}
+
+export function isLoraChainNode(comfyClass) {
+    return LORA_CHAIN_NODE_TYPES.includes(comfyClass);
+}
+
 function isMapLike(collection) {
     return collection && typeof collection.entries === "function" && typeof collection.values === "function";
 }
@@ -245,16 +262,20 @@ export function hideWidgetForGood(node, widget, suffix = "") {
 // Update pattern to match both formats: <lora:name:model_strength> or <lora:name:model_strength:clip_strength>
 export const LORA_PATTERN = /<lora:([^:]+):([-\d\.]+)(?::([-\d\.]+))?>/g;
 
-// Get connected Lora Stacker nodes that feed into the current node
-export function getConnectedInputStackers(node) {
-    const connectedStackers = [];
+function isLoraStackInput(input) {
+    return input?.type === "LORA_STACK";
+}
+
+// Get connected LORA_STACK chain nodes that feed into the current node
+export function getConnectedInputLoraChainNodes(node) {
+    const connectedNodes = [];
 
     if (!node?.inputs) {
-        return connectedStackers;
+        return connectedNodes;
     }
 
     for (const input of node.inputs) {
-        if (input.name !== "lora_stack" || !input.link) {
+        if (!isLoraStackInput(input) || !input.link) {
             continue;
         }
 
@@ -264,12 +285,12 @@ export function getConnectedInputStackers(node) {
         }
 
         const sourceNode = node.graph?.getNodeById?.(link.origin_id);
-        if (sourceNode && isLoraProviderNode(sourceNode.comfyClass)) {
-            connectedStackers.push(sourceNode);
+        if (sourceNode && isLoraChainNode(sourceNode.comfyClass)) {
+            connectedNodes.push(sourceNode);
         }
     }
 
-    return connectedStackers;
+    return connectedNodes;
 }
 
 // Get connected TriggerWord Toggle nodes that receive output from the current node
@@ -314,6 +335,11 @@ export function getActiveLorasFromNode(node) {
         return activeLoraNames;
     }
 
+    // Aggregator nodes do not own LoRA state directly; they only forward upstream stacks.
+    if (isLoraStackAggregatorNode(node.comfyClass)) {
+        return activeLoraNames;
+    }
+
     // Handle Lora Stacker and Lora Randomizer (lorasWidget)
     let lorasWidget = node.lorasWidget;
     if (!lorasWidget && node.widgets) {
@@ -348,14 +374,18 @@ export function collectActiveLorasFromChain(node, visited = new Set()) {
     // Mode 2 is Never, Mode 4 is Bypass
     const isNodeActive = node.mode === undefined || node.mode === 0 || node.mode === 3;
     
+    if (!isNodeActive) {
+        return new Set();
+    }
+
     // Get active loras from current node only if node is active
-    const allActiveLoraNames = isNodeActive ? getActiveLorasFromNode(node) : new Set();
+    const allActiveLoraNames = getActiveLorasFromNode(node);
     
-    // Get connected input stackers and collect their active loras
-    const inputStackers = getConnectedInputStackers(node);
-    for (const stacker of inputStackers) {
-        const stackerLoras = collectActiveLorasFromChain(stacker, visited);
-        stackerLoras.forEach(name => allActiveLoraNames.add(name));
+    // Get connected input LORA_STACK chain nodes and collect their active loras
+    const inputChainNodes = getConnectedInputLoraChainNodes(node);
+    for (const chainNode of inputChainNodes) {
+        const upstreamLoras = collectActiveLorasFromChain(chainNode, visited);
+        upstreamLoras.forEach(name => allActiveLoraNames.add(name));
     }
     
     return allActiveLoraNames;
@@ -819,8 +849,8 @@ export function updateDownstreamLoaders(startNode, visited = new Set()) {
                 collectActiveLorasFromChain(targetNode);
               updateConnectedTriggerWords(targetNode, allActiveLoraNames);
             }
-            // If target is another LoRA provider node, recursively check its outputs
-            else if (targetNode && isLoraProviderNode(targetNode.comfyClass)) {
+            // If target is another LORA_STACK chain node, recursively check its outputs
+            else if (targetNode && isLoraChainNode(targetNode.comfyClass)) {
               updateDownstreamLoaders(targetNode, visited);
             }
           }

web/comfyui/vue-widgets/lora-manager-widgets.js

@@ -14938,11 +14938,24 @@ const LORA_PROVIDER_NODE_TYPES$1 = [
   "Lora Randomizer (LoraManager)",
   "Lora Cycler (LoraManager)"
 ];
+const LORA_STACK_AGGREGATOR_NODE_TYPES$1 = [
+  "Lora Stack Combiner (LoraManager)"
+];
+const LORA_CHAIN_NODE_TYPES$1 = [
+  ...LORA_PROVIDER_NODE_TYPES$1,
+  ...LORA_STACK_AGGREGATOR_NODE_TYPES$1
+];
+function isLoraStackAggregatorNode$1(comfyClass) {
+  return LORA_STACK_AGGREGATOR_NODE_TYPES$1.includes(comfyClass);
+}
 function getActiveLorasFromNodeByType(node) {
   const comfyClass = node == null ? void 0 : node.comfyClass;
   if (comfyClass === "Lora Cycler (LoraManager)") {
     return extractFromCyclerConfig(node);
   }
+  if (isLoraStackAggregatorNode$1(comfyClass)) {
+    return /* @__PURE__ */ new Set();
+  }
   return extractFromLorasWidget(node);
 }
 function extractFromLorasWidget(node) {
@@ -15002,8 +15015,18 @@ const LORA_PROVIDER_NODE_TYPES = [
   "Lora Randomizer (LoraManager)",
   "Lora Cycler (LoraManager)"
 ];
-function isLoraProviderNode(comfyClass) {
-  return LORA_PROVIDER_NODE_TYPES.includes(comfyClass);
+const LORA_STACK_AGGREGATOR_NODE_TYPES = [
+  "Lora Stack Combiner (LoraManager)"
+];
+const LORA_CHAIN_NODE_TYPES = [
+  ...LORA_PROVIDER_NODE_TYPES,
+  ...LORA_STACK_AGGREGATOR_NODE_TYPES
+];
+function isLoraStackAggregatorNode(comfyClass) {
+  return LORA_STACK_AGGREGATOR_NODE_TYPES.includes(comfyClass);
+}
+function isLoraChainNode(comfyClass) {
+  return LORA_CHAIN_NODE_TYPES.includes(comfyClass);
 }
 function isMapLike(collection) {
   return collection && typeof collection.entries === "function" && typeof collection.values === "function";
@@ -15041,14 +15064,17 @@ function getLinkFromGraph(graph, linkId) {
   }
   return graph.links[linkId] || null;
 }
-function getConnectedInputStackers(node) {
+function isLoraStackInput(input) {
+  return (input == null ? void 0 : input.type) === "LORA_STACK";
+}
+function getConnectedInputLoraChainNodes(node) {
   var _a2, _b;
-  const connectedStackers = [];
+  const connectedNodes = [];
   if (!(node == null ? void 0 : node.inputs)) {
-    return connectedStackers;
+    return connectedNodes;
   }
   for (const input of node.inputs) {
-    if (input.name !== "lora_stack" || !input.link) {
+    if (!isLoraStackInput(input) || !input.link) {
       continue;
     }
     const link = getLinkFromGraph(node.graph, input.link);
@@ -15056,11 +15082,11 @@ function getConnectedInputStackers(node) {
       continue;
     }
     const sourceNode = (_b = (_a2 = node.graph) == null ? void 0 : _a2.getNodeById) == null ? void 0 : _b.call(_a2, link.origin_id);
-    if (sourceNode && isLoraProviderNode(sourceNode.comfyClass)) {
-      connectedStackers.push(sourceNode);
+    if (sourceNode && isLoraChainNode(sourceNode.comfyClass)) {
+      connectedNodes.push(sourceNode);
     }
   }
-  return connectedStackers;
+  return connectedNodes;
 }
 function getConnectedTriggerToggleNodes(node) {
   var _a2, _b, _c;
@@ -15095,6 +15121,9 @@ function getActiveLorasFromNode(node) {
     }
     return activeLoraNames;
   }
+  if (isLoraStackAggregatorNode(node.comfyClass)) {
+    return activeLoraNames;
+  }
   let lorasWidget = node.lorasWidget;
   if (!lorasWidget && node.widgets) {
     lorasWidget = node.widgets.find((w2) => w2.name === "loras");
@@ -15118,11 +15147,14 @@ function collectActiveLorasFromChain(node, visited = /* @__PURE__ */ new Set())
   }
   visited.add(nodeKey);
   const isNodeActive2 = node.mode === void 0 || node.mode === 0 || node.mode === 3;
-  const allActiveLoraNames = isNodeActive2 ? getActiveLorasFromNode(node) : /* @__PURE__ */ new Set();
-  const inputStackers = getConnectedInputStackers(node);
-  for (const stacker of inputStackers) {
-    const stackerLoras = collectActiveLorasFromChain(stacker, visited);
-    stackerLoras.forEach((name) => allActiveLoraNames.add(name));
+  if (!isNodeActive2) {
+    return /* @__PURE__ */ new Set();
+  }
+  const allActiveLoraNames = getActiveLorasFromNode(node);
+  const inputChainNodes = getConnectedInputLoraChainNodes(node);
+  for (const chainNode of inputChainNodes) {
+    const upstreamLoras = collectActiveLorasFromChain(chainNode, visited);
+    upstreamLoras.forEach((name) => allActiveLoraNames.add(name));
   }
   return allActiveLoraNames;
 }
@@ -15191,7 +15223,7 @@ function updateDownstreamLoaders(startNode, visited = /* @__PURE__ */ new Set())
             if (targetNode && targetNode.comfyClass === "Lora Loader (LoraManager)") {
               const allActiveLoraNames = collectActiveLorasFromChain(targetNode);
               updateConnectedTriggerWords(targetNode, allActiveLoraNames);
-            } else if (targetNode && isLoraProviderNode(targetNode.comfyClass)) {
+            } else if (targetNode && isLoraChainNode(targetNode.comfyClass)) {
               updateDownstreamLoaders(targetNode, visited);
             }
           }
@@ -15784,7 +15816,7 @@ app$1.registerExtension({
         return originalConfigure == null ? void 0 : originalConfigure.apply(this, arguments);
       };
     }
-    if (LORA_PROVIDER_NODE_TYPES$1.includes(comfyClass)) {
+    if (LORA_CHAIN_NODE_TYPES$1.includes(comfyClass)) {
       const originalOnNodeCreated = nodeType.prototype.onNodeCreated;
       nodeType.prototype.onNodeCreated = function() {
         originalOnNodeCreated == null ? void 0 : originalOnNodeCreated.apply(this, arguments);